text: /**
   * Autogenerated by Thrift Compiler (0.9.0)
   *
   * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
   *  @generated
   */
  #include "Hbase.h"
  
  namespace apache { namespace hadoop { namespace hbase { namespace thrift {
  
  uint32_t Hbase_enableTable_args::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::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(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_enableTable_args");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::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(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_enableTable_pargs");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::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(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::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(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("Hbase_enableTable_result");
  
    if (this->__isset.io) {
      xfer += oprot->writeFieldBegin("io", ::apache::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(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::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(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::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(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_disableTable_args");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::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(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_disableTable_pargs");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::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(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::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(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("Hbase_disableTable_result");
  
    if (this->__isset.io) {
      xfer += oprot->writeFieldBegin("io", ::apache::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(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::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(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::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(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_isTableEnabled_args");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::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(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_isTableEnabled_pargs");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::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(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 0:
          if (ftype == ::apache::thrift::protocol::T_BOOL) {
            xfer += iprot->readBool(this->success);
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 1:
          if (ftype == ::apache::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(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("Hbase_isTableEnabled_result");
  
    if (this->__isset.success) {
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0);
      xfer += oprot->writeBool(this->success);
      xfer += oprot->writeFieldEnd();
    } else if (this->__isset.io) {
      xfer += oprot->writeFieldBegin("io", ::apache::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(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 0:
          if (ftype == ::apache::thrift::protocol::T_BOOL) {
            xfer += iprot->readBool((*(this->success)));
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 1:
          if (ftype == ::apache::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_compact_args::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->tableNameOrRegionName);
            this->__isset.tableNameOrRegionName = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  uint32_t Hbase_compact_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_compact_args");
  
    xfer += oprot->writeFieldBegin("tableNameOrRegionName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary(this->tableNameOrRegionName);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_compact_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_compact_pargs");
  
    xfer += oprot->writeFieldBegin("tableNameOrRegionName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary((*(this->tableNameOrRegionName)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_compact_result::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::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_compact_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("Hbase_compact_result");
  
    if (this->__isset.io) {
      xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
      xfer += this->io.write(oprot);
      xfer += oprot->writeFieldEnd();
    }
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_compact_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::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_majorCompact_args::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->tableNameOrRegionName);
            this->__isset.tableNameOrRegionName = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  uint32_t Hbase_majorCompact_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_majorCompact_args");
  
    xfer += oprot->writeFieldBegin("tableNameOrRegionName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary(this->tableNameOrRegionName);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_majorCompact_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_majorCompact_pargs");
  
    xfer += oprot->writeFieldBegin("tableNameOrRegionName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary((*(this->tableNameOrRegionName)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_majorCompact_result::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::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_majorCompact_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("Hbase_majorCompact_result");
  
    if (this->__isset.io) {
      xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
      xfer += this->io.write(oprot);
      xfer += oprot->writeFieldEnd();
    }
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_majorCompact_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::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(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      xfer += iprot->skip(ftype);
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  uint32_t Hbase_getTableNames_args::write(::apache::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(::apache::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(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 0:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
              uint32_t _size20;
              ::apache::thrift::protocol::TType _etype23;
              xfer += iprot->readListBegin(_etype23, _size20);
              this->success.resize(_size20);
              uint32_t _i24;
              for (_i24 = 0; _i24 < _size20; ++_i24)
              {
                xfer += iprot->readBinary(this->success[_i24]);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 1:
          if (ftype == ::apache::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(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("Hbase_getTableNames_result");
  
    if (this->__isset.success) {
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
      {
        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size()));
        std::vector<Text> ::const_iterator _iter25;
        for (_iter25 = this->success.begin(); _iter25 != this->success.end(); ++_iter25)
        {
          xfer += oprot->writeBinary((*_iter25));
        }
        xfer += oprot->writeListEnd();
      }
      xfer += oprot->writeFieldEnd();
    } else if (this->__isset.io) {
      xfer += oprot->writeFieldBegin("io", ::apache::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(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 0:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
              uint32_t _size26;
              ::apache::thrift::protocol::TType _etype29;
              xfer += iprot->readListBegin(_etype29, _size26);
              (*(this->success)).resize(_size26);
              uint32_t _i30;
              for (_i30 = 0; _i30 < _size26; ++_i30)
              {
                xfer += iprot->readBinary((*(this->success))[_i30]);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 1:
          if (ftype == ::apache::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(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::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(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_getColumnDescriptors_args");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::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(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_getColumnDescriptors_pargs");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::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(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 0:
          if (ftype == ::apache::thrift::protocol::T_MAP) {
            {
              this->success.clear();
              uint32_t _size31;
              ::apache::thrift::protocol::TType _ktype32;
              ::apache::thrift::protocol::TType _vtype33;
              xfer += iprot->readMapBegin(_ktype32, _vtype33, _size31);
              uint32_t _i35;
              for (_i35 = 0; _i35 < _size31; ++_i35)
              {
                Text _key36;
                xfer += iprot->readBinary(_key36);
                ColumnDescriptor& _val37 = this->success[_key36];
                xfer += _val37.read(iprot);
              }
              xfer += iprot->readMapEnd();
            }
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 1:
          if (ftype == ::apache::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(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("Hbase_getColumnDescriptors_result");
  
    if (this->__isset.success) {
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_MAP, 0);
      {
        xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
        std::map<Text, ColumnDescriptor> ::const_iterator _iter38;
        for (_iter38 = this->success.begin(); _iter38 != this->success.end(); ++_iter38)
        {
          xfer += oprot->writeBinary(_iter38->first);
          xfer += _iter38->second.write(oprot);
        }
        xfer += oprot->writeMapEnd();
      }
      xfer += oprot->writeFieldEnd();
    } else if (this->__isset.io) {
      xfer += oprot->writeFieldBegin("io", ::apache::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(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 0:
          if (ftype == ::apache::thrift::protocol::T_MAP) {
            {
              (*(this->success)).clear();
              uint32_t _size39;
              ::apache::thrift::protocol::TType _ktype40;
              ::apache::thrift::protocol::TType _vtype41;
              xfer += iprot->readMapBegin(_ktype40, _vtype41, _size39);
              uint32_t _i43;
              for (_i43 = 0; _i43 < _size39; ++_i43)
              {
                Text _key44;
                xfer += iprot->readBinary(_key44);
                ColumnDescriptor& _val45 = (*(this->success))[_key44];
                xfer += _val45.read(iprot);
              }
              xfer += iprot->readMapEnd();
            }
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 1:
          if (ftype == ::apache::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(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::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(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_getTableRegions_args");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::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(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_getTableRegions_pargs");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::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(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 0:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
              uint32_t _size46;
              ::apache::thrift::protocol::TType _etype49;
              xfer += iprot->readListBegin(_etype49, _size46);
              this->success.resize(_size46);
              uint32_t _i50;
              for (_i50 = 0; _i50 < _size46; ++_i50)
              {
                xfer += this->success[_i50].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 1:
          if (ftype == ::apache::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(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("Hbase_getTableRegions_result");
  
    if (this->__isset.success) {
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
      {
        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
        std::vector<TRegionInfo> ::const_iterator _iter51;
        for (_iter51 = this->success.begin(); _iter51 != this->success.end(); ++_iter51)
        {
          xfer += (*_iter51).write(oprot);
        }
        xfer += oprot->writeListEnd();
      }
      xfer += oprot->writeFieldEnd();
    } else if (this->__isset.io) {
      xfer += oprot->writeFieldBegin("io", ::apache::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(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 0:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
              uint32_t _size52;
              ::apache::thrift::protocol::TType _etype55;
              xfer += iprot->readListBegin(_etype55, _size52);
              (*(this->success)).resize(_size52);
              uint32_t _i56;
              for (_i56 = 0; _i56 < _size52; ++_i56)
              {
                xfer += (*(this->success))[_i56].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 1:
          if (ftype == ::apache::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(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->tableName);
            this->__isset.tableName = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->columnFamilies.clear();
              uint32_t _size57;
              ::apache::thrift::protocol::TType _etype60;
              xfer += iprot->readListBegin(_etype60, _size57);
              this->columnFamilies.resize(_size57);
              uint32_t _i61;
              for (_i61 = 0; _i61 < _size57; ++_i61)
              {
                xfer += this->columnFamilies[_i61].read(iprot);
              }
              xfer += 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(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_createTable_args");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary(this->tableName);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("columnFamilies", ::apache::thrift::protocol::T_LIST, 2);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->columnFamilies.size()));
      std::vector<ColumnDescriptor> ::const_iterator _iter62;
      for (_iter62 = this->columnFamilies.begin(); _iter62 != this->columnFamilies.end(); ++_iter62)
      {
        xfer += (*_iter62).write(oprot);
      }
      xfer += oprot->writeListEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_createTable_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_createTable_pargs");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary((*(this->tableName)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("columnFamilies", ::apache::thrift::protocol::T_LIST, 2);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->columnFamilies)).size()));
      std::vector<ColumnDescriptor> ::const_iterator _iter63;
      for (_iter63 = (*(this->columnFamilies)).begin(); _iter63 != (*(this->columnFamilies)).end(); ++_iter63)
      {
        xfer += (*_iter63).write(oprot);
      }
      xfer += oprot->writeListEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_createTable_result::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::thrift::protocol::T_STRUCT) {
            xfer += this->io.read(iprot);
            this->__isset.io = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::thrift::protocol::T_STRUCT) {
            xfer += this->ia.read(iprot);
            this->__isset.ia = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 3:
          if (ftype == ::apache::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(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("Hbase_createTable_result");
  
    if (this->__isset.io) {
      xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
      xfer += this->io.write(oprot);
      xfer += oprot->writeFieldEnd();
    } else if (this->__isset.ia) {
      xfer += oprot->writeFieldBegin("ia", ::apache::thrift::protocol::T_STRUCT, 2);
      xfer += this->ia.write(oprot);
      xfer += oprot->writeFieldEnd();
    } else if (this->__isset.exist) {
      xfer += oprot->writeFieldBegin("exist", ::apache::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(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::thrift::protocol::T_STRUCT) {
            xfer += this->io.read(iprot);
            this->__isset.io = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::thrift::protocol::T_STRUCT) {
            xfer += this->ia.read(iprot);
            this->__isset.ia = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 3:
          if (ftype == ::apache::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(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::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(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_deleteTable_args");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::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(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_deleteTable_pargs");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::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(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::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_deleteTable_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("Hbase_deleteTable_result");
  
    if (this->__isset.io) {
      xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
      xfer += this->io.write(oprot);
      xfer += oprot->writeFieldEnd();
    }
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_deleteTable_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::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_get_args::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->tableName);
            this->__isset.tableName = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->row);
            this->__isset.row = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 3:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->column);
            this->__isset.column = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 4:
          if (ftype == ::apache::thrift::protocol::T_MAP) {
            {
              this->attributes.clear();
              uint32_t _size64;
              ::apache::thrift::protocol::TType _ktype65;
              ::apache::thrift::protocol::TType _vtype66;
              xfer += iprot->readMapBegin(_ktype65, _vtype66, _size64);
              uint32_t _i68;
              for (_i68 = 0; _i68 < _size64; ++_i68)
              {
                Text _key69;
                xfer += iprot->readBinary(_key69);
                Text& _val70 = this->attributes[_key69];
                xfer += iprot->readBinary(_val70);
              }
              xfer += iprot->readMapEnd();
            }
            this->__isset.attributes = 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(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_get_args");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary(this->tableName);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
    xfer += oprot->writeBinary(this->row);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRING, 3);
    xfer += oprot->writeBinary(this->column);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 4);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->attributes.size()));
      std::map<Text, Text> ::const_iterator _iter71;
      for (_iter71 = this->attributes.begin(); _iter71 != this->attributes.end(); ++_iter71)
      {
        xfer += oprot->writeBinary(_iter71->first);
        xfer += oprot->writeBinary(_iter71->second);
      }
      xfer += oprot->writeMapEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_get_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_get_pargs");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary((*(this->tableName)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
    xfer += oprot->writeBinary((*(this->row)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRING, 3);
    xfer += oprot->writeBinary((*(this->column)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 4);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->attributes)).size()));
      std::map<Text, Text> ::const_iterator _iter72;
      for (_iter72 = (*(this->attributes)).begin(); _iter72 != (*(this->attributes)).end(); ++_iter72)
      {
        xfer += oprot->writeBinary(_iter72->first);
        xfer += oprot->writeBinary(_iter72->second);
      }
      xfer += oprot->writeMapEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_get_result::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 0:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
              uint32_t _size73;
              ::apache::thrift::protocol::TType _etype76;
              xfer += iprot->readListBegin(_etype76, _size73);
              this->success.resize(_size73);
              uint32_t _i77;
              for (_i77 = 0; _i77 < _size73; ++_i77)
              {
                xfer += this->success[_i77].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 1:
          if (ftype == ::apache::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_get_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("Hbase_get_result");
  
    if (this->__isset.success) {
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
      {
        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
        std::vector<TCell> ::const_iterator _iter78;
        for (_iter78 = this->success.begin(); _iter78 != this->success.end(); ++_iter78)
        {
          xfer += (*_iter78).write(oprot);
        }
        xfer += oprot->writeListEnd();
      }
      xfer += oprot->writeFieldEnd();
    } else if (this->__isset.io) {
      xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
      xfer += this->io.write(oprot);
      xfer += oprot->writeFieldEnd();
    }
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_get_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 0:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
              uint32_t _size79;
              ::apache::thrift::protocol::TType _etype82;
              xfer += iprot->readListBegin(_etype82, _size79);
              (*(this->success)).resize(_size79);
              uint32_t _i83;
              for (_i83 = 0; _i83 < _size79; ++_i83)
              {
                xfer += (*(this->success))[_i83].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 1:
          if (ftype == ::apache::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_getVer_args::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->tableName);
            this->__isset.tableName = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->row);
            this->__isset.row = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 3:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->column);
            this->__isset.column = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 4:
          if (ftype == ::apache::thrift::protocol::T_I32) {
            xfer += iprot->readI32(this->numVersions);
            this->__isset.numVersions = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 5:
          if (ftype == ::apache::thrift::protocol::T_MAP) {
            {
              this->attributes.clear();
              uint32_t _size84;
              ::apache::thrift::protocol::TType _ktype85;
              ::apache::thrift::protocol::TType _vtype86;
              xfer += iprot->readMapBegin(_ktype85, _vtype86, _size84);
              uint32_t _i88;
              for (_i88 = 0; _i88 < _size84; ++_i88)
              {
                Text _key89;
                xfer += iprot->readBinary(_key89);
                Text& _val90 = this->attributes[_key89];
                xfer += iprot->readBinary(_val90);
              }
              xfer += iprot->readMapEnd();
            }
            this->__isset.attributes = 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(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_getVer_args");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary(this->tableName);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
    xfer += oprot->writeBinary(this->row);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRING, 3);
    xfer += oprot->writeBinary(this->column);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("numVersions", ::apache::thrift::protocol::T_I32, 4);
    xfer += oprot->writeI32(this->numVersions);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 5);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->attributes.size()));
      std::map<Text, Text> ::const_iterator _iter91;
      for (_iter91 = this->attributes.begin(); _iter91 != this->attributes.end(); ++_iter91)
      {
        xfer += oprot->writeBinary(_iter91->first);
        xfer += oprot->writeBinary(_iter91->second);
      }
      xfer += oprot->writeMapEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_getVer_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_getVer_pargs");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary((*(this->tableName)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
    xfer += oprot->writeBinary((*(this->row)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRING, 3);
    xfer += oprot->writeBinary((*(this->column)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("numVersions", ::apache::thrift::protocol::T_I32, 4);
    xfer += oprot->writeI32((*(this->numVersions)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 5);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->attributes)).size()));
      std::map<Text, Text> ::const_iterator _iter92;
      for (_iter92 = (*(this->attributes)).begin(); _iter92 != (*(this->attributes)).end(); ++_iter92)
      {
        xfer += oprot->writeBinary(_iter92->first);
        xfer += oprot->writeBinary(_iter92->second);
      }
      xfer += oprot->writeMapEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_getVer_result::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 0:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
              uint32_t _size93;
              ::apache::thrift::protocol::TType _etype96;
              xfer += iprot->readListBegin(_etype96, _size93);
              this->success.resize(_size93);
              uint32_t _i97;
              for (_i97 = 0; _i97 < _size93; ++_i97)
              {
                xfer += this->success[_i97].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 1:
          if (ftype == ::apache::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_getVer_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("Hbase_getVer_result");
  
    if (this->__isset.success) {
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
      {
        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
        std::vector<TCell> ::const_iterator _iter98;
        for (_iter98 = this->success.begin(); _iter98 != this->success.end(); ++_iter98)
        {
          xfer += (*_iter98).write(oprot);
        }
        xfer += oprot->writeListEnd();
      }
      xfer += oprot->writeFieldEnd();
    } else if (this->__isset.io) {
      xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
      xfer += this->io.write(oprot);
      xfer += oprot->writeFieldEnd();
    }
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_getVer_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 0:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
              uint32_t _size99;
              ::apache::thrift::protocol::TType _etype102;
              xfer += iprot->readListBegin(_etype102, _size99);
              (*(this->success)).resize(_size99);
              uint32_t _i103;
              for (_i103 = 0; _i103 < _size99; ++_i103)
              {
                xfer += (*(this->success))[_i103].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 1:
          if (ftype == ::apache::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_getVerTs_args::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->tableName);
            this->__isset.tableName = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->row);
            this->__isset.row = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 3:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->column);
            this->__isset.column = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 4:
          if (ftype == ::apache::thrift::protocol::T_I64) {
            xfer += iprot->readI64(this->timestamp);
            this->__isset.timestamp = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 5:
          if (ftype == ::apache::thrift::protocol::T_I32) {
            xfer += iprot->readI32(this->numVersions);
            this->__isset.numVersions = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 6:
          if (ftype == ::apache::thrift::protocol::T_MAP) {
            {
              this->attributes.clear();
              uint32_t _size104;
              ::apache::thrift::protocol::TType _ktype105;
              ::apache::thrift::protocol::TType _vtype106;
              xfer += iprot->readMapBegin(_ktype105, _vtype106, _size104);
              uint32_t _i108;
              for (_i108 = 0; _i108 < _size104; ++_i108)
              {
                Text _key109;
                xfer += iprot->readBinary(_key109);
                Text& _val110 = this->attributes[_key109];
                xfer += iprot->readBinary(_val110);
              }
              xfer += iprot->readMapEnd();
            }
            this->__isset.attributes = 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(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_getVerTs_args");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary(this->tableName);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
    xfer += oprot->writeBinary(this->row);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRING, 3);
    xfer += oprot->writeBinary(this->column);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 4);
    xfer += oprot->writeI64(this->timestamp);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("numVersions", ::apache::thrift::protocol::T_I32, 5);
    xfer += oprot->writeI32(this->numVersions);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 6);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->attributes.size()));
      std::map<Text, Text> ::const_iterator _iter111;
      for (_iter111 = this->attributes.begin(); _iter111 != this->attributes.end(); ++_iter111)
      {
        xfer += oprot->writeBinary(_iter111->first);
        xfer += oprot->writeBinary(_iter111->second);
      }
      xfer += oprot->writeMapEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_getVerTs_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_getVerTs_pargs");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary((*(this->tableName)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
    xfer += oprot->writeBinary((*(this->row)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRING, 3);
    xfer += oprot->writeBinary((*(this->column)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 4);
    xfer += oprot->writeI64((*(this->timestamp)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("numVersions", ::apache::thrift::protocol::T_I32, 5);
    xfer += oprot->writeI32((*(this->numVersions)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 6);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->attributes)).size()));
      std::map<Text, Text> ::const_iterator _iter112;
      for (_iter112 = (*(this->attributes)).begin(); _iter112 != (*(this->attributes)).end(); ++_iter112)
      {
        xfer += oprot->writeBinary(_iter112->first);
        xfer += oprot->writeBinary(_iter112->second);
      }
      xfer += oprot->writeMapEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_getVerTs_result::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 0:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
              uint32_t _size113;
              ::apache::thrift::protocol::TType _etype116;
              xfer += iprot->readListBegin(_etype116, _size113);
              this->success.resize(_size113);
              uint32_t _i117;
              for (_i117 = 0; _i117 < _size113; ++_i117)
              {
                xfer += this->success[_i117].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 1:
          if (ftype == ::apache::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_getVerTs_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("Hbase_getVerTs_result");
  
    if (this->__isset.success) {
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
      {
        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
        std::vector<TCell> ::const_iterator _iter118;
        for (_iter118 = this->success.begin(); _iter118 != this->success.end(); ++_iter118)
        {
          xfer += (*_iter118).write(oprot);
        }
        xfer += oprot->writeListEnd();
      }
      xfer += oprot->writeFieldEnd();
    } else if (this->__isset.io) {
      xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
      xfer += this->io.write(oprot);
      xfer += oprot->writeFieldEnd();
    }
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_getVerTs_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 0:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
              uint32_t _size119;
              ::apache::thrift::protocol::TType _etype122;
              xfer += iprot->readListBegin(_etype122, _size119);
              (*(this->success)).resize(_size119);
              uint32_t _i123;
              for (_i123 = 0; _i123 < _size119; ++_i123)
              {
                xfer += (*(this->success))[_i123].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 1:
          if (ftype == ::apache::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_args::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->tableName);
            this->__isset.tableName = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->row);
            this->__isset.row = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 3:
          if (ftype == ::apache::thrift::protocol::T_MAP) {
            {
              this->attributes.clear();
              uint32_t _size124;
              ::apache::thrift::protocol::TType _ktype125;
              ::apache::thrift::protocol::TType _vtype126;
              xfer += iprot->readMapBegin(_ktype125, _vtype126, _size124);
              uint32_t _i128;
              for (_i128 = 0; _i128 < _size124; ++_i128)
              {
                Text _key129;
                xfer += iprot->readBinary(_key129);
                Text& _val130 = this->attributes[_key129];
                xfer += iprot->readBinary(_val130);
              }
              xfer += iprot->readMapEnd();
            }
            this->__isset.attributes = 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(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_getRow_args");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary(this->tableName);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
    xfer += oprot->writeBinary(this->row);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 3);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->attributes.size()));
      std::map<Text, Text> ::const_iterator _iter131;
      for (_iter131 = this->attributes.begin(); _iter131 != this->attributes.end(); ++_iter131)
      {
        xfer += oprot->writeBinary(_iter131->first);
        xfer += oprot->writeBinary(_iter131->second);
      }
      xfer += oprot->writeMapEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_getRow_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_getRow_pargs");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary((*(this->tableName)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
    xfer += oprot->writeBinary((*(this->row)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 3);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->attributes)).size()));
      std::map<Text, Text> ::const_iterator _iter132;
      for (_iter132 = (*(this->attributes)).begin(); _iter132 != (*(this->attributes)).end(); ++_iter132)
      {
        xfer += oprot->writeBinary(_iter132->first);
        xfer += oprot->writeBinary(_iter132->second);
      }
      xfer += oprot->writeMapEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_getRow_result::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 0:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
              uint32_t _size133;
              ::apache::thrift::protocol::TType _etype136;
              xfer += iprot->readListBegin(_etype136, _size133);
              this->success.resize(_size133);
              uint32_t _i137;
              for (_i137 = 0; _i137 < _size133; ++_i137)
              {
                xfer += this->success[_i137].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 1:
          if (ftype == ::apache::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(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("Hbase_getRow_result");
  
    if (this->__isset.success) {
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
      {
        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
        std::vector<TRowResult> ::const_iterator _iter138;
        for (_iter138 = this->success.begin(); _iter138 != this->success.end(); ++_iter138)
        {
          xfer += (*_iter138).write(oprot);
        }
        xfer += oprot->writeListEnd();
      }
      xfer += oprot->writeFieldEnd();
    } else if (this->__isset.io) {
      xfer += oprot->writeFieldBegin("io", ::apache::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(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 0:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
              uint32_t _size139;
              ::apache::thrift::protocol::TType _etype142;
              xfer += iprot->readListBegin(_etype142, _size139);
              (*(this->success)).resize(_size139);
              uint32_t _i143;
              for (_i143 = 0; _i143 < _size139; ++_i143)
              {
                xfer += (*(this->success))[_i143].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 1:
          if (ftype == ::apache::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_getRowWithColumns_args::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->tableName);
            this->__isset.tableName = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->row);
            this->__isset.row = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 3:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->columns.clear();
              uint32_t _size144;
              ::apache::thrift::protocol::TType _etype147;
              xfer += iprot->readListBegin(_etype147, _size144);
              this->columns.resize(_size144);
              uint32_t _i148;
              for (_i148 = 0; _i148 < _size144; ++_i148)
              {
                xfer += iprot->readBinary(this->columns[_i148]);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.columns = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 4:
          if (ftype == ::apache::thrift::protocol::T_MAP) {
            {
              this->attributes.clear();
              uint32_t _size149;
              ::apache::thrift::protocol::TType _ktype150;
              ::apache::thrift::protocol::TType _vtype151;
              xfer += iprot->readMapBegin(_ktype150, _vtype151, _size149);
              uint32_t _i153;
              for (_i153 = 0; _i153 < _size149; ++_i153)
              {
                Text _key154;
                xfer += iprot->readBinary(_key154);
                Text& _val155 = this->attributes[_key154];
                xfer += iprot->readBinary(_val155);
              }
              xfer += iprot->readMapEnd();
            }
            this->__isset.attributes = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  uint32_t Hbase_getRowWithColumns_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_getRowWithColumns_args");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary(this->tableName);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
    xfer += oprot->writeBinary(this->row);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 3);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->columns.size()));
      std::vector<Text> ::const_iterator _iter156;
      for (_iter156 = this->columns.begin(); _iter156 != this->columns.end(); ++_iter156)
      {
        xfer += oprot->writeBinary((*_iter156));
      }
      xfer += oprot->writeListEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 4);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->attributes.size()));
      std::map<Text, Text> ::const_iterator _iter157;
      for (_iter157 = this->attributes.begin(); _iter157 != this->attributes.end(); ++_iter157)
      {
        xfer += oprot->writeBinary(_iter157->first);
        xfer += oprot->writeBinary(_iter157->second);
      }
      xfer += oprot->writeMapEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_getRowWithColumns_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_getRowWithColumns_pargs");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary((*(this->tableName)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
    xfer += oprot->writeBinary((*(this->row)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 3);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->columns)).size()));
      std::vector<Text> ::const_iterator _iter158;
      for (_iter158 = (*(this->columns)).begin(); _iter158 != (*(this->columns)).end(); ++_iter158)
      {
        xfer += oprot->writeBinary((*_iter158));
      }
      xfer += oprot->writeListEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 4);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->attributes)).size()));
      std::map<Text, Text> ::const_iterator _iter159;
      for (_iter159 = (*(this->attributes)).begin(); _iter159 != (*(this->attributes)).end(); ++_iter159)
      {
        xfer += oprot->writeBinary(_iter159->first);
        xfer += oprot->writeBinary(_iter159->second);
      }
      xfer += oprot->writeMapEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_getRowWithColumns_result::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 0:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
              uint32_t _size160;
              ::apache::thrift::protocol::TType _etype163;
              xfer += iprot->readListBegin(_etype163, _size160);
              this->success.resize(_size160);
              uint32_t _i164;
              for (_i164 = 0; _i164 < _size160; ++_i164)
              {
                xfer += this->success[_i164].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 1:
          if (ftype == ::apache::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_getRowWithColumns_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("Hbase_getRowWithColumns_result");
  
    if (this->__isset.success) {
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
      {
        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
        std::vector<TRowResult> ::const_iterator _iter165;
        for (_iter165 = this->success.begin(); _iter165 != this->success.end(); ++_iter165)
        {
          xfer += (*_iter165).write(oprot);
        }
        xfer += oprot->writeListEnd();
      }
      xfer += oprot->writeFieldEnd();
    } else if (this->__isset.io) {
      xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
      xfer += this->io.write(oprot);
      xfer += oprot->writeFieldEnd();
    }
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_getRowWithColumns_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 0:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
              uint32_t _size166;
              ::apache::thrift::protocol::TType _etype169;
              xfer += iprot->readListBegin(_etype169, _size166);
              (*(this->success)).resize(_size166);
              uint32_t _i170;
              for (_i170 = 0; _i170 < _size166; ++_i170)
              {
                xfer += (*(this->success))[_i170].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 1:
          if (ftype == ::apache::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(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->tableName);
            this->__isset.tableName = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->row);
            this->__isset.row = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 3:
          if (ftype == ::apache::thrift::protocol::T_I64) {
            xfer += iprot->readI64(this->timestamp);
            this->__isset.timestamp = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 4:
          if (ftype == ::apache::thrift::protocol::T_MAP) {
            {
              this->attributes.clear();
              uint32_t _size171;
              ::apache::thrift::protocol::TType _ktype172;
              ::apache::thrift::protocol::TType _vtype173;
              xfer += iprot->readMapBegin(_ktype172, _vtype173, _size171);
              uint32_t _i175;
              for (_i175 = 0; _i175 < _size171; ++_i175)
              {
                Text _key176;
                xfer += iprot->readBinary(_key176);
                Text& _val177 = this->attributes[_key176];
                xfer += iprot->readBinary(_val177);
              }
              xfer += iprot->readMapEnd();
            }
            this->__isset.attributes = 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(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_getRowTs_args");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary(this->tableName);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
    xfer += oprot->writeBinary(this->row);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 3);
    xfer += oprot->writeI64(this->timestamp);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 4);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->attributes.size()));
      std::map<Text, Text> ::const_iterator _iter178;
      for (_iter178 = this->attributes.begin(); _iter178 != this->attributes.end(); ++_iter178)
      {
        xfer += oprot->writeBinary(_iter178->first);
        xfer += oprot->writeBinary(_iter178->second);
      }
      xfer += oprot->writeMapEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_getRowTs_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_getRowTs_pargs");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary((*(this->tableName)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
    xfer += oprot->writeBinary((*(this->row)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 3);
    xfer += oprot->writeI64((*(this->timestamp)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 4);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->attributes)).size()));
      std::map<Text, Text> ::const_iterator _iter179;
      for (_iter179 = (*(this->attributes)).begin(); _iter179 != (*(this->attributes)).end(); ++_iter179)
      {
        xfer += oprot->writeBinary(_iter179->first);
        xfer += oprot->writeBinary(_iter179->second);
      }
      xfer += oprot->writeMapEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_getRowTs_result::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 0:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
              uint32_t _size180;
              ::apache::thrift::protocol::TType _etype183;
              xfer += iprot->readListBegin(_etype183, _size180);
              this->success.resize(_size180);
              uint32_t _i184;
              for (_i184 = 0; _i184 < _size180; ++_i184)
              {
                xfer += this->success[_i184].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 1:
          if (ftype == ::apache::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(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("Hbase_getRowTs_result");
  
    if (this->__isset.success) {
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
      {
        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
        std::vector<TRowResult> ::const_iterator _iter185;
        for (_iter185 = this->success.begin(); _iter185 != this->success.end(); ++_iter185)
        {
          xfer += (*_iter185).write(oprot);
        }
        xfer += oprot->writeListEnd();
      }
      xfer += oprot->writeFieldEnd();
    } else if (this->__isset.io) {
      xfer += oprot->writeFieldBegin("io", ::apache::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(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 0:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
              uint32_t _size186;
              ::apache::thrift::protocol::TType _etype189;
              xfer += iprot->readListBegin(_etype189, _size186);
              (*(this->success)).resize(_size186);
              uint32_t _i190;
              for (_i190 = 0; _i190 < _size186; ++_i190)
              {
                xfer += (*(this->success))[_i190].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 1:
          if (ftype == ::apache::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_getRowWithColumnsTs_args::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->tableName);
            this->__isset.tableName = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->row);
            this->__isset.row = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 3:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->columns.clear();
              uint32_t _size191;
              ::apache::thrift::protocol::TType _etype194;
              xfer += iprot->readListBegin(_etype194, _size191);
              this->columns.resize(_size191);
              uint32_t _i195;
              for (_i195 = 0; _i195 < _size191; ++_i195)
              {
                xfer += iprot->readBinary(this->columns[_i195]);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.columns = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 4:
          if (ftype == ::apache::thrift::protocol::T_I64) {
            xfer += iprot->readI64(this->timestamp);
            this->__isset.timestamp = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 5:
          if (ftype == ::apache::thrift::protocol::T_MAP) {
            {
              this->attributes.clear();
              uint32_t _size196;
              ::apache::thrift::protocol::TType _ktype197;
              ::apache::thrift::protocol::TType _vtype198;
              xfer += iprot->readMapBegin(_ktype197, _vtype198, _size196);
              uint32_t _i200;
              for (_i200 = 0; _i200 < _size196; ++_i200)
              {
                Text _key201;
                xfer += iprot->readBinary(_key201);
                Text& _val202 = this->attributes[_key201];
                xfer += iprot->readBinary(_val202);
              }
              xfer += iprot->readMapEnd();
            }
            this->__isset.attributes = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  uint32_t Hbase_getRowWithColumnsTs_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_getRowWithColumnsTs_args");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary(this->tableName);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
    xfer += oprot->writeBinary(this->row);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 3);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->columns.size()));
      std::vector<Text> ::const_iterator _iter203;
      for (_iter203 = this->columns.begin(); _iter203 != this->columns.end(); ++_iter203)
      {
        xfer += oprot->writeBinary((*_iter203));
      }
      xfer += oprot->writeListEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 4);
    xfer += oprot->writeI64(this->timestamp);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 5);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->attributes.size()));
      std::map<Text, Text> ::const_iterator _iter204;
      for (_iter204 = this->attributes.begin(); _iter204 != this->attributes.end(); ++_iter204)
      {
        xfer += oprot->writeBinary(_iter204->first);
        xfer += oprot->writeBinary(_iter204->second);
      }
      xfer += oprot->writeMapEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_getRowWithColumnsTs_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_getRowWithColumnsTs_pargs");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary((*(this->tableName)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
    xfer += oprot->writeBinary((*(this->row)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 3);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->columns)).size()));
      std::vector<Text> ::const_iterator _iter205;
      for (_iter205 = (*(this->columns)).begin(); _iter205 != (*(this->columns)).end(); ++_iter205)
      {
        xfer += oprot->writeBinary((*_iter205));
      }
      xfer += oprot->writeListEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 4);
    xfer += oprot->writeI64((*(this->timestamp)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 5);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->attributes)).size()));
      std::map<Text, Text> ::const_iterator _iter206;
      for (_iter206 = (*(this->attributes)).begin(); _iter206 != (*(this->attributes)).end(); ++_iter206)
      {
        xfer += oprot->writeBinary(_iter206->first);
        xfer += oprot->writeBinary(_iter206->second);
      }
      xfer += oprot->writeMapEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_getRowWithColumnsTs_result::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 0:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
              uint32_t _size207;
              ::apache::thrift::protocol::TType _etype210;
              xfer += iprot->readListBegin(_etype210, _size207);
              this->success.resize(_size207);
              uint32_t _i211;
              for (_i211 = 0; _i211 < _size207; ++_i211)
              {
                xfer += this->success[_i211].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 1:
          if (ftype == ::apache::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_getRowWithColumnsTs_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("Hbase_getRowWithColumnsTs_result");
  
    if (this->__isset.success) {
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
      {
        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
        std::vector<TRowResult> ::const_iterator _iter212;
        for (_iter212 = this->success.begin(); _iter212 != this->success.end(); ++_iter212)
        {
          xfer += (*_iter212).write(oprot);
        }
        xfer += oprot->writeListEnd();
      }
      xfer += oprot->writeFieldEnd();
    } else if (this->__isset.io) {
      xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
      xfer += this->io.write(oprot);
      xfer += oprot->writeFieldEnd();
    }
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_getRowWithColumnsTs_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 0:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
              uint32_t _size213;
              ::apache::thrift::protocol::TType _etype216;
              xfer += iprot->readListBegin(_etype216, _size213);
              (*(this->success)).resize(_size213);
              uint32_t _i217;
              for (_i217 = 0; _i217 < _size213; ++_i217)
              {
                xfer += (*(this->success))[_i217].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 1:
          if (ftype == ::apache::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_getRows_args::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->tableName);
            this->__isset.tableName = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->rows.clear();
              uint32_t _size218;
              ::apache::thrift::protocol::TType _etype221;
              xfer += iprot->readListBegin(_etype221, _size218);
              this->rows.resize(_size218);
              uint32_t _i222;
              for (_i222 = 0; _i222 < _size218; ++_i222)
              {
                xfer += iprot->readBinary(this->rows[_i222]);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.rows = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 3:
          if (ftype == ::apache::thrift::protocol::T_MAP) {
            {
              this->attributes.clear();
              uint32_t _size223;
              ::apache::thrift::protocol::TType _ktype224;
              ::apache::thrift::protocol::TType _vtype225;
              xfer += iprot->readMapBegin(_ktype224, _vtype225, _size223);
              uint32_t _i227;
              for (_i227 = 0; _i227 < _size223; ++_i227)
              {
                Text _key228;
                xfer += iprot->readBinary(_key228);
                Text& _val229 = this->attributes[_key228];
                xfer += iprot->readBinary(_val229);
              }
              xfer += iprot->readMapEnd();
            }
            this->__isset.attributes = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  uint32_t Hbase_getRows_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_getRows_args");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary(this->tableName);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("rows", ::apache::thrift::protocol::T_LIST, 2);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->rows.size()));
      std::vector<Text> ::const_iterator _iter230;
      for (_iter230 = this->rows.begin(); _iter230 != this->rows.end(); ++_iter230)
      {
        xfer += oprot->writeBinary((*_iter230));
      }
      xfer += oprot->writeListEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 3);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->attributes.size()));
      std::map<Text, Text> ::const_iterator _iter231;
      for (_iter231 = this->attributes.begin(); _iter231 != this->attributes.end(); ++_iter231)
      {
        xfer += oprot->writeBinary(_iter231->first);
        xfer += oprot->writeBinary(_iter231->second);
      }
      xfer += oprot->writeMapEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_getRows_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_getRows_pargs");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary((*(this->tableName)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("rows", ::apache::thrift::protocol::T_LIST, 2);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->rows)).size()));
      std::vector<Text> ::const_iterator _iter232;
      for (_iter232 = (*(this->rows)).begin(); _iter232 != (*(this->rows)).end(); ++_iter232)
      {
        xfer += oprot->writeBinary((*_iter232));
      }
      xfer += oprot->writeListEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 3);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->attributes)).size()));
      std::map<Text, Text> ::const_iterator _iter233;
      for (_iter233 = (*(this->attributes)).begin(); _iter233 != (*(this->attributes)).end(); ++_iter233)
      {
        xfer += oprot->writeBinary(_iter233->first);
        xfer += oprot->writeBinary(_iter233->second);
      }
      xfer += oprot->writeMapEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_getRows_result::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 0:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
              uint32_t _size234;
              ::apache::thrift::protocol::TType _etype237;
              xfer += iprot->readListBegin(_etype237, _size234);
              this->success.resize(_size234);
              uint32_t _i238;
              for (_i238 = 0; _i238 < _size234; ++_i238)
              {
                xfer += this->success[_i238].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 1:
          if (ftype == ::apache::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_getRows_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("Hbase_getRows_result");
  
    if (this->__isset.success) {
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
      {
        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
        std::vector<TRowResult> ::const_iterator _iter239;
        for (_iter239 = this->success.begin(); _iter239 != this->success.end(); ++_iter239)
        {
          xfer += (*_iter239).write(oprot);
        }
        xfer += oprot->writeListEnd();
      }
      xfer += oprot->writeFieldEnd();
    } else if (this->__isset.io) {
      xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
      xfer += this->io.write(oprot);
      xfer += oprot->writeFieldEnd();
    }
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_getRows_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 0:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
              uint32_t _size240;
              ::apache::thrift::protocol::TType _etype243;
              xfer += iprot->readListBegin(_etype243, _size240);
              (*(this->success)).resize(_size240);
              uint32_t _i244;
              for (_i244 = 0; _i244 < _size240; ++_i244)
              {
                xfer += (*(this->success))[_i244].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 1:
          if (ftype == ::apache::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_getRowsWithColumns_args::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->tableName);
            this->__isset.tableName = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->rows.clear();
              uint32_t _size245;
              ::apache::thrift::protocol::TType _etype248;
              xfer += iprot->readListBegin(_etype248, _size245);
              this->rows.resize(_size245);
              uint32_t _i249;
              for (_i249 = 0; _i249 < _size245; ++_i249)
              {
                xfer += iprot->readBinary(this->rows[_i249]);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.rows = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 3:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->columns.clear();
              uint32_t _size250;
              ::apache::thrift::protocol::TType _etype253;
              xfer += iprot->readListBegin(_etype253, _size250);
              this->columns.resize(_size250);
              uint32_t _i254;
              for (_i254 = 0; _i254 < _size250; ++_i254)
              {
                xfer += iprot->readBinary(this->columns[_i254]);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.columns = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 4:
          if (ftype == ::apache::thrift::protocol::T_MAP) {
            {
              this->attributes.clear();
              uint32_t _size255;
              ::apache::thrift::protocol::TType _ktype256;
              ::apache::thrift::protocol::TType _vtype257;
              xfer += iprot->readMapBegin(_ktype256, _vtype257, _size255);
              uint32_t _i259;
              for (_i259 = 0; _i259 < _size255; ++_i259)
              {
                Text _key260;
                xfer += iprot->readBinary(_key260);
                Text& _val261 = this->attributes[_key260];
                xfer += iprot->readBinary(_val261);
              }
              xfer += iprot->readMapEnd();
            }
            this->__isset.attributes = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  uint32_t Hbase_getRowsWithColumns_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_getRowsWithColumns_args");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary(this->tableName);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("rows", ::apache::thrift::protocol::T_LIST, 2);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->rows.size()));
      std::vector<Text> ::const_iterator _iter262;
      for (_iter262 = this->rows.begin(); _iter262 != this->rows.end(); ++_iter262)
      {
        xfer += oprot->writeBinary((*_iter262));
      }
      xfer += oprot->writeListEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 3);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->columns.size()));
      std::vector<Text> ::const_iterator _iter263;
      for (_iter263 = this->columns.begin(); _iter263 != this->columns.end(); ++_iter263)
      {
        xfer += oprot->writeBinary((*_iter263));
      }
      xfer += oprot->writeListEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 4);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->attributes.size()));
      std::map<Text, Text> ::const_iterator _iter264;
      for (_iter264 = this->attributes.begin(); _iter264 != this->attributes.end(); ++_iter264)
      {
        xfer += oprot->writeBinary(_iter264->first);
        xfer += oprot->writeBinary(_iter264->second);
      }
      xfer += oprot->writeMapEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_getRowsWithColumns_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_getRowsWithColumns_pargs");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary((*(this->tableName)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("rows", ::apache::thrift::protocol::T_LIST, 2);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->rows)).size()));
      std::vector<Text> ::const_iterator _iter265;
      for (_iter265 = (*(this->rows)).begin(); _iter265 != (*(this->rows)).end(); ++_iter265)
      {
        xfer += oprot->writeBinary((*_iter265));
      }
      xfer += oprot->writeListEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 3);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->columns)).size()));
      std::vector<Text> ::const_iterator _iter266;
      for (_iter266 = (*(this->columns)).begin(); _iter266 != (*(this->columns)).end(); ++_iter266)
      {
        xfer += oprot->writeBinary((*_iter266));
      }
      xfer += oprot->writeListEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 4);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->attributes)).size()));
      std::map<Text, Text> ::const_iterator _iter267;
      for (_iter267 = (*(this->attributes)).begin(); _iter267 != (*(this->attributes)).end(); ++_iter267)
      {
        xfer += oprot->writeBinary(_iter267->first);
        xfer += oprot->writeBinary(_iter267->second);
      }
      xfer += oprot->writeMapEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_getRowsWithColumns_result::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 0:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
              uint32_t _size268;
              ::apache::thrift::protocol::TType _etype271;
              xfer += iprot->readListBegin(_etype271, _size268);
              this->success.resize(_size268);
              uint32_t _i272;
              for (_i272 = 0; _i272 < _size268; ++_i272)
              {
                xfer += this->success[_i272].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 1:
          if (ftype == ::apache::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_getRowsWithColumns_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("Hbase_getRowsWithColumns_result");
  
    if (this->__isset.success) {
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
      {
        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
        std::vector<TRowResult> ::const_iterator _iter273;
        for (_iter273 = this->success.begin(); _iter273 != this->success.end(); ++_iter273)
        {
          xfer += (*_iter273).write(oprot);
        }
        xfer += oprot->writeListEnd();
      }
      xfer += oprot->writeFieldEnd();
    } else if (this->__isset.io) {
      xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
      xfer += this->io.write(oprot);
      xfer += oprot->writeFieldEnd();
    }
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_getRowsWithColumns_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 0:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
              uint32_t _size274;
              ::apache::thrift::protocol::TType _etype277;
              xfer += iprot->readListBegin(_etype277, _size274);
              (*(this->success)).resize(_size274);
              uint32_t _i278;
              for (_i278 = 0; _i278 < _size274; ++_i278)
              {
                xfer += (*(this->success))[_i278].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 1:
          if (ftype == ::apache::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_getRowsTs_args::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->tableName);
            this->__isset.tableName = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->rows.clear();
              uint32_t _size279;
              ::apache::thrift::protocol::TType _etype282;
              xfer += iprot->readListBegin(_etype282, _size279);
              this->rows.resize(_size279);
              uint32_t _i283;
              for (_i283 = 0; _i283 < _size279; ++_i283)
              {
                xfer += iprot->readBinary(this->rows[_i283]);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.rows = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 3:
          if (ftype == ::apache::thrift::protocol::T_I64) {
            xfer += iprot->readI64(this->timestamp);
            this->__isset.timestamp = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 4:
          if (ftype == ::apache::thrift::protocol::T_MAP) {
            {
              this->attributes.clear();
              uint32_t _size284;
              ::apache::thrift::protocol::TType _ktype285;
              ::apache::thrift::protocol::TType _vtype286;
              xfer += iprot->readMapBegin(_ktype285, _vtype286, _size284);
              uint32_t _i288;
              for (_i288 = 0; _i288 < _size284; ++_i288)
              {
                Text _key289;
                xfer += iprot->readBinary(_key289);
                Text& _val290 = this->attributes[_key289];
                xfer += iprot->readBinary(_val290);
              }
              xfer += iprot->readMapEnd();
            }
            this->__isset.attributes = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  uint32_t Hbase_getRowsTs_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_getRowsTs_args");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary(this->tableName);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("rows", ::apache::thrift::protocol::T_LIST, 2);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->rows.size()));
      std::vector<Text> ::const_iterator _iter291;
      for (_iter291 = this->rows.begin(); _iter291 != this->rows.end(); ++_iter291)
      {
        xfer += oprot->writeBinary((*_iter291));
      }
      xfer += oprot->writeListEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 3);
    xfer += oprot->writeI64(this->timestamp);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 4);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->attributes.size()));
      std::map<Text, Text> ::const_iterator _iter292;
      for (_iter292 = this->attributes.begin(); _iter292 != this->attributes.end(); ++_iter292)
      {
        xfer += oprot->writeBinary(_iter292->first);
        xfer += oprot->writeBinary(_iter292->second);
      }
      xfer += oprot->writeMapEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_getRowsTs_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_getRowsTs_pargs");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary((*(this->tableName)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("rows", ::apache::thrift::protocol::T_LIST, 2);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->rows)).size()));
      std::vector<Text> ::const_iterator _iter293;
      for (_iter293 = (*(this->rows)).begin(); _iter293 != (*(this->rows)).end(); ++_iter293)
      {
        xfer += oprot->writeBinary((*_iter293));
      }
      xfer += oprot->writeListEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 3);
    xfer += oprot->writeI64((*(this->timestamp)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 4);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->attributes)).size()));
      std::map<Text, Text> ::const_iterator _iter294;
      for (_iter294 = (*(this->attributes)).begin(); _iter294 != (*(this->attributes)).end(); ++_iter294)
      {
        xfer += oprot->writeBinary(_iter294->first);
        xfer += oprot->writeBinary(_iter294->second);
      }
      xfer += oprot->writeMapEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_getRowsTs_result::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 0:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
              uint32_t _size295;
              ::apache::thrift::protocol::TType _etype298;
              xfer += iprot->readListBegin(_etype298, _size295);
              this->success.resize(_size295);
              uint32_t _i299;
              for (_i299 = 0; _i299 < _size295; ++_i299)
              {
                xfer += this->success[_i299].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 1:
          if (ftype == ::apache::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_getRowsTs_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("Hbase_getRowsTs_result");
  
    if (this->__isset.success) {
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
      {
        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
        std::vector<TRowResult> ::const_iterator _iter300;
        for (_iter300 = this->success.begin(); _iter300 != this->success.end(); ++_iter300)
        {
          xfer += (*_iter300).write(oprot);
        }
        xfer += oprot->writeListEnd();
      }
      xfer += oprot->writeFieldEnd();
    } else if (this->__isset.io) {
      xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
      xfer += this->io.write(oprot);
      xfer += oprot->writeFieldEnd();
    }
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_getRowsTs_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 0:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
              uint32_t _size301;
              ::apache::thrift::protocol::TType _etype304;
              xfer += iprot->readListBegin(_etype304, _size301);
              (*(this->success)).resize(_size301);
              uint32_t _i305;
              for (_i305 = 0; _i305 < _size301; ++_i305)
              {
                xfer += (*(this->success))[_i305].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 1:
          if (ftype == ::apache::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_getRowsWithColumnsTs_args::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->tableName);
            this->__isset.tableName = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->rows.clear();
              uint32_t _size306;
              ::apache::thrift::protocol::TType _etype309;
              xfer += iprot->readListBegin(_etype309, _size306);
              this->rows.resize(_size306);
              uint32_t _i310;
              for (_i310 = 0; _i310 < _size306; ++_i310)
              {
                xfer += iprot->readBinary(this->rows[_i310]);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.rows = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 3:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->columns.clear();
              uint32_t _size311;
              ::apache::thrift::protocol::TType _etype314;
              xfer += iprot->readListBegin(_etype314, _size311);
              this->columns.resize(_size311);
              uint32_t _i315;
              for (_i315 = 0; _i315 < _size311; ++_i315)
              {
                xfer += iprot->readBinary(this->columns[_i315]);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.columns = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 4:
          if (ftype == ::apache::thrift::protocol::T_I64) {
            xfer += iprot->readI64(this->timestamp);
            this->__isset.timestamp = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 5:
          if (ftype == ::apache::thrift::protocol::T_MAP) {
            {
              this->attributes.clear();
              uint32_t _size316;
              ::apache::thrift::protocol::TType _ktype317;
              ::apache::thrift::protocol::TType _vtype318;
              xfer += iprot->readMapBegin(_ktype317, _vtype318, _size316);
              uint32_t _i320;
              for (_i320 = 0; _i320 < _size316; ++_i320)
              {
                Text _key321;
                xfer += iprot->readBinary(_key321);
                Text& _val322 = this->attributes[_key321];
                xfer += iprot->readBinary(_val322);
              }
              xfer += iprot->readMapEnd();
            }
            this->__isset.attributes = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  uint32_t Hbase_getRowsWithColumnsTs_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_getRowsWithColumnsTs_args");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary(this->tableName);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("rows", ::apache::thrift::protocol::T_LIST, 2);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->rows.size()));
      std::vector<Text> ::const_iterator _iter323;
      for (_iter323 = this->rows.begin(); _iter323 != this->rows.end(); ++_iter323)
      {
        xfer += oprot->writeBinary((*_iter323));
      }
      xfer += oprot->writeListEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 3);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->columns.size()));
      std::vector<Text> ::const_iterator _iter324;
      for (_iter324 = this->columns.begin(); _iter324 != this->columns.end(); ++_iter324)
      {
        xfer += oprot->writeBinary((*_iter324));
      }
      xfer += oprot->writeListEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 4);
    xfer += oprot->writeI64(this->timestamp);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 5);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->attributes.size()));
      std::map<Text, Text> ::const_iterator _iter325;
      for (_iter325 = this->attributes.begin(); _iter325 != this->attributes.end(); ++_iter325)
      {
        xfer += oprot->writeBinary(_iter325->first);
        xfer += oprot->writeBinary(_iter325->second);
      }
      xfer += oprot->writeMapEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_getRowsWithColumnsTs_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_getRowsWithColumnsTs_pargs");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary((*(this->tableName)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("rows", ::apache::thrift::protocol::T_LIST, 2);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->rows)).size()));
      std::vector<Text> ::const_iterator _iter326;
      for (_iter326 = (*(this->rows)).begin(); _iter326 != (*(this->rows)).end(); ++_iter326)
      {
        xfer += oprot->writeBinary((*_iter326));
      }
      xfer += oprot->writeListEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 3);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->columns)).size()));
      std::vector<Text> ::const_iterator _iter327;
      for (_iter327 = (*(this->columns)).begin(); _iter327 != (*(this->columns)).end(); ++_iter327)
      {
        xfer += oprot->writeBinary((*_iter327));
      }
      xfer += oprot->writeListEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 4);
    xfer += oprot->writeI64((*(this->timestamp)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 5);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->attributes)).size()));
      std::map<Text, Text> ::const_iterator _iter328;
      for (_iter328 = (*(this->attributes)).begin(); _iter328 != (*(this->attributes)).end(); ++_iter328)
      {
        xfer += oprot->writeBinary(_iter328->first);
        xfer += oprot->writeBinary(_iter328->second);
      }
      xfer += oprot->writeMapEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_getRowsWithColumnsTs_result::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 0:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
              uint32_t _size329;
              ::apache::thrift::protocol::TType _etype332;
              xfer += iprot->readListBegin(_etype332, _size329);
              this->success.resize(_size329);
              uint32_t _i333;
              for (_i333 = 0; _i333 < _size329; ++_i333)
              {
                xfer += this->success[_i333].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 1:
          if (ftype == ::apache::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_getRowsWithColumnsTs_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("Hbase_getRowsWithColumnsTs_result");
  
    if (this->__isset.success) {
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
      {
        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
        std::vector<TRowResult> ::const_iterator _iter334;
        for (_iter334 = this->success.begin(); _iter334 != this->success.end(); ++_iter334)
        {
          xfer += (*_iter334).write(oprot);
        }
        xfer += oprot->writeListEnd();
      }
      xfer += oprot->writeFieldEnd();
    } else if (this->__isset.io) {
      xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
      xfer += this->io.write(oprot);
      xfer += oprot->writeFieldEnd();
    }
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_getRowsWithColumnsTs_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 0:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
              uint32_t _size335;
              ::apache::thrift::protocol::TType _etype338;
              xfer += iprot->readListBegin(_etype338, _size335);
              (*(this->success)).resize(_size335);
              uint32_t _i339;
              for (_i339 = 0; _i339 < _size335; ++_i339)
              {
                xfer += (*(this->success))[_i339].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 1:
          if (ftype == ::apache::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(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->tableName);
            this->__isset.tableName = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->row);
            this->__isset.row = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 3:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->mutations.clear();
              uint32_t _size340;
              ::apache::thrift::protocol::TType _etype343;
              xfer += iprot->readListBegin(_etype343, _size340);
              this->mutations.resize(_size340);
              uint32_t _i344;
              for (_i344 = 0; _i344 < _size340; ++_i344)
              {
                xfer += this->mutations[_i344].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.mutations = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 4:
          if (ftype == ::apache::thrift::protocol::T_MAP) {
            {
              this->attributes.clear();
              uint32_t _size345;
              ::apache::thrift::protocol::TType _ktype346;
              ::apache::thrift::protocol::TType _vtype347;
              xfer += iprot->readMapBegin(_ktype346, _vtype347, _size345);
              uint32_t _i349;
              for (_i349 = 0; _i349 < _size345; ++_i349)
              {
                Text _key350;
                xfer += iprot->readBinary(_key350);
                Text& _val351 = this->attributes[_key350];
                xfer += iprot->readBinary(_val351);
              }
              xfer += iprot->readMapEnd();
            }
            this->__isset.attributes = 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(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_mutateRow_args");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary(this->tableName);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
    xfer += oprot->writeBinary(this->row);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("mutations", ::apache::thrift::protocol::T_LIST, 3);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->mutations.size()));
      std::vector<Mutation> ::const_iterator _iter352;
      for (_iter352 = this->mutations.begin(); _iter352 != this->mutations.end(); ++_iter352)
      {
        xfer += (*_iter352).write(oprot);
      }
      xfer += oprot->writeListEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 4);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->attributes.size()));
      std::map<Text, Text> ::const_iterator _iter353;
      for (_iter353 = this->attributes.begin(); _iter353 != this->attributes.end(); ++_iter353)
      {
        xfer += oprot->writeBinary(_iter353->first);
        xfer += oprot->writeBinary(_iter353->second);
      }
      xfer += oprot->writeMapEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_mutateRow_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_mutateRow_pargs");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary((*(this->tableName)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
    xfer += oprot->writeBinary((*(this->row)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("mutations", ::apache::thrift::protocol::T_LIST, 3);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->mutations)).size()));
      std::vector<Mutation> ::const_iterator _iter354;
      for (_iter354 = (*(this->mutations)).begin(); _iter354 != (*(this->mutations)).end(); ++_iter354)
      {
        xfer += (*_iter354).write(oprot);
      }
      xfer += oprot->writeListEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 4);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->attributes)).size()));
      std::map<Text, Text> ::const_iterator _iter355;
      for (_iter355 = (*(this->attributes)).begin(); _iter355 != (*(this->attributes)).end(); ++_iter355)
      {
        xfer += oprot->writeBinary(_iter355->first);
        xfer += oprot->writeBinary(_iter355->second);
      }
      xfer += oprot->writeMapEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_mutateRow_result::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::thrift::protocol::T_STRUCT) {
            xfer += this->io.read(iprot);
            this->__isset.io = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::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(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("Hbase_mutateRow_result");
  
    if (this->__isset.io) {
      xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
      xfer += this->io.write(oprot);
      xfer += oprot->writeFieldEnd();
    } else if (this->__isset.ia) {
      xfer += oprot->writeFieldBegin("ia", ::apache::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(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::thrift::protocol::T_STRUCT) {
            xfer += this->io.read(iprot);
            this->__isset.io = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::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(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->tableName);
            this->__isset.tableName = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->row);
            this->__isset.row = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 3:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->mutations.clear();
              uint32_t _size356;
              ::apache::thrift::protocol::TType _etype359;
              xfer += iprot->readListBegin(_etype359, _size356);
              this->mutations.resize(_size356);
              uint32_t _i360;
              for (_i360 = 0; _i360 < _size356; ++_i360)
              {
                xfer += this->mutations[_i360].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.mutations = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 4:
          if (ftype == ::apache::thrift::protocol::T_I64) {
            xfer += iprot->readI64(this->timestamp);
            this->__isset.timestamp = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 5:
          if (ftype == ::apache::thrift::protocol::T_MAP) {
            {
              this->attributes.clear();
              uint32_t _size361;
              ::apache::thrift::protocol::TType _ktype362;
              ::apache::thrift::protocol::TType _vtype363;
              xfer += iprot->readMapBegin(_ktype362, _vtype363, _size361);
              uint32_t _i365;
              for (_i365 = 0; _i365 < _size361; ++_i365)
              {
                Text _key366;
                xfer += iprot->readBinary(_key366);
                Text& _val367 = this->attributes[_key366];
                xfer += iprot->readBinary(_val367);
              }
              xfer += iprot->readMapEnd();
            }
            this->__isset.attributes = 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(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_mutateRowTs_args");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary(this->tableName);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
    xfer += oprot->writeBinary(this->row);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("mutations", ::apache::thrift::protocol::T_LIST, 3);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->mutations.size()));
      std::vector<Mutation> ::const_iterator _iter368;
      for (_iter368 = this->mutations.begin(); _iter368 != this->mutations.end(); ++_iter368)
      {
        xfer += (*_iter368).write(oprot);
      }
      xfer += oprot->writeListEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 4);
    xfer += oprot->writeI64(this->timestamp);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 5);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->attributes.size()));
      std::map<Text, Text> ::const_iterator _iter369;
      for (_iter369 = this->attributes.begin(); _iter369 != this->attributes.end(); ++_iter369)
      {
        xfer += oprot->writeBinary(_iter369->first);
        xfer += oprot->writeBinary(_iter369->second);
      }
      xfer += oprot->writeMapEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_mutateRowTs_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_mutateRowTs_pargs");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary((*(this->tableName)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
    xfer += oprot->writeBinary((*(this->row)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("mutations", ::apache::thrift::protocol::T_LIST, 3);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->mutations)).size()));
      std::vector<Mutation> ::const_iterator _iter370;
      for (_iter370 = (*(this->mutations)).begin(); _iter370 != (*(this->mutations)).end(); ++_iter370)
      {
        xfer += (*_iter370).write(oprot);
      }
      xfer += oprot->writeListEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 4);
    xfer += oprot->writeI64((*(this->timestamp)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 5);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->attributes)).size()));
      std::map<Text, Text> ::const_iterator _iter371;
      for (_iter371 = (*(this->attributes)).begin(); _iter371 != (*(this->attributes)).end(); ++_iter371)
      {
        xfer += oprot->writeBinary(_iter371->first);
        xfer += oprot->writeBinary(_iter371->second);
      }
      xfer += oprot->writeMapEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_mutateRowTs_result::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::thrift::protocol::T_STRUCT) {
            xfer += this->io.read(iprot);
            this->__isset.io = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::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(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("Hbase_mutateRowTs_result");
  
    if (this->__isset.io) {
      xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
      xfer += this->io.write(oprot);
      xfer += oprot->writeFieldEnd();
    } else if (this->__isset.ia) {
      xfer += oprot->writeFieldBegin("ia", ::apache::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(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::thrift::protocol::T_STRUCT) {
            xfer += this->io.read(iprot);
            this->__isset.io = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::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(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->tableName);
            this->__isset.tableName = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->rowBatches.clear();
              uint32_t _size372;
              ::apache::thrift::protocol::TType _etype375;
              xfer += iprot->readListBegin(_etype375, _size372);
              this->rowBatches.resize(_size372);
              uint32_t _i376;
              for (_i376 = 0; _i376 < _size372; ++_i376)
              {
                xfer += this->rowBatches[_i376].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.rowBatches = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 3:
          if (ftype == ::apache::thrift::protocol::T_MAP) {
            {
              this->attributes.clear();
              uint32_t _size377;
              ::apache::thrift::protocol::TType _ktype378;
              ::apache::thrift::protocol::TType _vtype379;
              xfer += iprot->readMapBegin(_ktype378, _vtype379, _size377);
              uint32_t _i381;
              for (_i381 = 0; _i381 < _size377; ++_i381)
              {
                Text _key382;
                xfer += iprot->readBinary(_key382);
                Text& _val383 = this->attributes[_key382];
                xfer += iprot->readBinary(_val383);
              }
              xfer += iprot->readMapEnd();
            }
            this->__isset.attributes = 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(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_mutateRows_args");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary(this->tableName);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("rowBatches", ::apache::thrift::protocol::T_LIST, 2);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->rowBatches.size()));
      std::vector<BatchMutation> ::const_iterator _iter384;
      for (_iter384 = this->rowBatches.begin(); _iter384 != this->rowBatches.end(); ++_iter384)
      {
        xfer += (*_iter384).write(oprot);
      }
      xfer += oprot->writeListEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 3);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->attributes.size()));
      std::map<Text, Text> ::const_iterator _iter385;
      for (_iter385 = this->attributes.begin(); _iter385 != this->attributes.end(); ++_iter385)
      {
        xfer += oprot->writeBinary(_iter385->first);
        xfer += oprot->writeBinary(_iter385->second);
      }
      xfer += oprot->writeMapEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_mutateRows_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_mutateRows_pargs");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary((*(this->tableName)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("rowBatches", ::apache::thrift::protocol::T_LIST, 2);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->rowBatches)).size()));
      std::vector<BatchMutation> ::const_iterator _iter386;
      for (_iter386 = (*(this->rowBatches)).begin(); _iter386 != (*(this->rowBatches)).end(); ++_iter386)
      {
        xfer += (*_iter386).write(oprot);
      }
      xfer += oprot->writeListEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 3);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->attributes)).size()));
      std::map<Text, Text> ::const_iterator _iter387;
      for (_iter387 = (*(this->attributes)).begin(); _iter387 != (*(this->attributes)).end(); ++_iter387)
      {
        xfer += oprot->writeBinary(_iter387->first);
        xfer += oprot->writeBinary(_iter387->second);
      }
      xfer += oprot->writeMapEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_mutateRows_result::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::thrift::protocol::T_STRUCT) {
            xfer += this->io.read(iprot);
            this->__isset.io = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::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(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("Hbase_mutateRows_result");
  
    if (this->__isset.io) {
      xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
      xfer += this->io.write(oprot);
      xfer += oprot->writeFieldEnd();
    } else if (this->__isset.ia) {
      xfer += oprot->writeFieldBegin("ia", ::apache::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(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::thrift::protocol::T_STRUCT) {
            xfer += this->io.read(iprot);
            this->__isset.io = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::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(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->tableName);
            this->__isset.tableName = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->rowBatches.clear();
              uint32_t _size388;
              ::apache::thrift::protocol::TType _etype391;
              xfer += iprot->readListBegin(_etype391, _size388);
              this->rowBatches.resize(_size388);
              uint32_t _i392;
              for (_i392 = 0; _i392 < _size388; ++_i392)
              {
                xfer += this->rowBatches[_i392].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.rowBatches = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 3:
          if (ftype == ::apache::thrift::protocol::T_I64) {
            xfer += iprot->readI64(this->timestamp);
            this->__isset.timestamp = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 4:
          if (ftype == ::apache::thrift::protocol::T_MAP) {
            {
              this->attributes.clear();
              uint32_t _size393;
              ::apache::thrift::protocol::TType _ktype394;
              ::apache::thrift::protocol::TType _vtype395;
              xfer += iprot->readMapBegin(_ktype394, _vtype395, _size393);
              uint32_t _i397;
              for (_i397 = 0; _i397 < _size393; ++_i397)
              {
                Text _key398;
                xfer += iprot->readBinary(_key398);
                Text& _val399 = this->attributes[_key398];
                xfer += iprot->readBinary(_val399);
              }
              xfer += iprot->readMapEnd();
            }
            this->__isset.attributes = 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(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_mutateRowsTs_args");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary(this->tableName);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("rowBatches", ::apache::thrift::protocol::T_LIST, 2);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->rowBatches.size()));
      std::vector<BatchMutation> ::const_iterator _iter400;
      for (_iter400 = this->rowBatches.begin(); _iter400 != this->rowBatches.end(); ++_iter400)
      {
        xfer += (*_iter400).write(oprot);
      }
      xfer += oprot->writeListEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 3);
    xfer += oprot->writeI64(this->timestamp);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 4);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->attributes.size()));
      std::map<Text, Text> ::const_iterator _iter401;
      for (_iter401 = this->attributes.begin(); _iter401 != this->attributes.end(); ++_iter401)
      {
        xfer += oprot->writeBinary(_iter401->first);
        xfer += oprot->writeBinary(_iter401->second);
      }
      xfer += oprot->writeMapEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_mutateRowsTs_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_mutateRowsTs_pargs");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary((*(this->tableName)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("rowBatches", ::apache::thrift::protocol::T_LIST, 2);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->rowBatches)).size()));
      std::vector<BatchMutation> ::const_iterator _iter402;
      for (_iter402 = (*(this->rowBatches)).begin(); _iter402 != (*(this->rowBatches)).end(); ++_iter402)
      {
        xfer += (*_iter402).write(oprot);
      }
      xfer += oprot->writeListEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 3);
    xfer += oprot->writeI64((*(this->timestamp)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 4);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->attributes)).size()));
      std::map<Text, Text> ::const_iterator _iter403;
      for (_iter403 = (*(this->attributes)).begin(); _iter403 != (*(this->attributes)).end(); ++_iter403)
      {
        xfer += oprot->writeBinary(_iter403->first);
        xfer += oprot->writeBinary(_iter403->second);
      }
      xfer += oprot->writeMapEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_mutateRowsTs_result::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::thrift::protocol::T_STRUCT) {
            xfer += this->io.read(iprot);
            this->__isset.io = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::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(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("Hbase_mutateRowsTs_result");
  
    if (this->__isset.io) {
      xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
      xfer += this->io.write(oprot);
      xfer += oprot->writeFieldEnd();
    } else if (this->__isset.ia) {
      xfer += oprot->writeFieldBegin("ia", ::apache::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(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::thrift::protocol::T_STRUCT) {
            xfer += this->io.read(iprot);
            this->__isset.io = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::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_atomicIncrement_args::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->tableName);
            this->__isset.tableName = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->row);
            this->__isset.row = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 3:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->column);
            this->__isset.column = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 4:
          if (ftype == ::apache::thrift::protocol::T_I64) {
            xfer += iprot->readI64(this->value);
            this->__isset.value = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  uint32_t Hbase_atomicIncrement_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_atomicIncrement_args");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary(this->tableName);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
    xfer += oprot->writeBinary(this->row);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRING, 3);
    xfer += oprot->writeBinary(this->column);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_I64, 4);
    xfer += oprot->writeI64(this->value);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_atomicIncrement_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_atomicIncrement_pargs");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary((*(this->tableName)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
    xfer += oprot->writeBinary((*(this->row)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRING, 3);
    xfer += oprot->writeBinary((*(this->column)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_I64, 4);
    xfer += oprot->writeI64((*(this->value)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_atomicIncrement_result::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 0:
          if (ftype == ::apache::thrift::protocol::T_I64) {
            xfer += iprot->readI64(this->success);
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 1:
          if (ftype == ::apache::thrift::protocol::T_STRUCT) {
            xfer += this->io.read(iprot);
            this->__isset.io = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::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_atomicIncrement_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("Hbase_atomicIncrement_result");
  
    if (this->__isset.success) {
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I64, 0);
      xfer += oprot->writeI64(this->success);
      xfer += oprot->writeFieldEnd();
    } else if (this->__isset.io) {
      xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
      xfer += this->io.write(oprot);
      xfer += oprot->writeFieldEnd();
    } else if (this->__isset.ia) {
      xfer += oprot->writeFieldBegin("ia", ::apache::thrift::protocol::T_STRUCT, 2);
      xfer += this->ia.write(oprot);
      xfer += oprot->writeFieldEnd();
    }
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_atomicIncrement_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 0:
          if (ftype == ::apache::thrift::protocol::T_I64) {
            xfer += iprot->readI64((*(this->success)));
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 1:
          if (ftype == ::apache::thrift::protocol::T_STRUCT) {
            xfer += this->io.read(iprot);
            this->__isset.io = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::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(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->tableName);
            this->__isset.tableName = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->row);
            this->__isset.row = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 3:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->column);
            this->__isset.column = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 4:
          if (ftype == ::apache::thrift::protocol::T_MAP) {
            {
              this->attributes.clear();
              uint32_t _size404;
              ::apache::thrift::protocol::TType _ktype405;
              ::apache::thrift::protocol::TType _vtype406;
              xfer += iprot->readMapBegin(_ktype405, _vtype406, _size404);
              uint32_t _i408;
              for (_i408 = 0; _i408 < _size404; ++_i408)
              {
                Text _key409;
                xfer += iprot->readBinary(_key409);
                Text& _val410 = this->attributes[_key409];
                xfer += iprot->readBinary(_val410);
              }
              xfer += iprot->readMapEnd();
            }
            this->__isset.attributes = 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(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_deleteAll_args");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary(this->tableName);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
    xfer += oprot->writeBinary(this->row);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRING, 3);
    xfer += oprot->writeBinary(this->column);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 4);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->attributes.size()));
      std::map<Text, Text> ::const_iterator _iter411;
      for (_iter411 = this->attributes.begin(); _iter411 != this->attributes.end(); ++_iter411)
      {
        xfer += oprot->writeBinary(_iter411->first);
        xfer += oprot->writeBinary(_iter411->second);
      }
      xfer += oprot->writeMapEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_deleteAll_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_deleteAll_pargs");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary((*(this->tableName)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
    xfer += oprot->writeBinary((*(this->row)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRING, 3);
    xfer += oprot->writeBinary((*(this->column)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 4);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->attributes)).size()));
      std::map<Text, Text> ::const_iterator _iter412;
      for (_iter412 = (*(this->attributes)).begin(); _iter412 != (*(this->attributes)).end(); ++_iter412)
      {
        xfer += oprot->writeBinary(_iter412->first);
        xfer += oprot->writeBinary(_iter412->second);
      }
      xfer += oprot->writeMapEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_deleteAll_result::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::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(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("Hbase_deleteAll_result");
  
    if (this->__isset.io) {
      xfer += oprot->writeFieldBegin("io", ::apache::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(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::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(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->tableName);
            this->__isset.tableName = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->row);
            this->__isset.row = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 3:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->column);
            this->__isset.column = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 4:
          if (ftype == ::apache::thrift::protocol::T_I64) {
            xfer += iprot->readI64(this->timestamp);
            this->__isset.timestamp = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 5:
          if (ftype == ::apache::thrift::protocol::T_MAP) {
            {
              this->attributes.clear();
              uint32_t _size413;
              ::apache::thrift::protocol::TType _ktype414;
              ::apache::thrift::protocol::TType _vtype415;
              xfer += iprot->readMapBegin(_ktype414, _vtype415, _size413);
              uint32_t _i417;
              for (_i417 = 0; _i417 < _size413; ++_i417)
              {
                Text _key418;
                xfer += iprot->readBinary(_key418);
                Text& _val419 = this->attributes[_key418];
                xfer += iprot->readBinary(_val419);
              }
              xfer += iprot->readMapEnd();
            }
            this->__isset.attributes = 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(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_deleteAllTs_args");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary(this->tableName);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
    xfer += oprot->writeBinary(this->row);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRING, 3);
    xfer += oprot->writeBinary(this->column);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 4);
    xfer += oprot->writeI64(this->timestamp);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 5);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->attributes.size()));
      std::map<Text, Text> ::const_iterator _iter420;
      for (_iter420 = this->attributes.begin(); _iter420 != this->attributes.end(); ++_iter420)
      {
        xfer += oprot->writeBinary(_iter420->first);
        xfer += oprot->writeBinary(_iter420->second);
      }
      xfer += oprot->writeMapEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_deleteAllTs_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_deleteAllTs_pargs");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary((*(this->tableName)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
    xfer += oprot->writeBinary((*(this->row)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRING, 3);
    xfer += oprot->writeBinary((*(this->column)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 4);
    xfer += oprot->writeI64((*(this->timestamp)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 5);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->attributes)).size()));
      std::map<Text, Text> ::const_iterator _iter421;
      for (_iter421 = (*(this->attributes)).begin(); _iter421 != (*(this->attributes)).end(); ++_iter421)
      {
        xfer += oprot->writeBinary(_iter421->first);
        xfer += oprot->writeBinary(_iter421->second);
      }
      xfer += oprot->writeMapEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_deleteAllTs_result::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::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(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("Hbase_deleteAllTs_result");
  
    if (this->__isset.io) {
      xfer += oprot->writeFieldBegin("io", ::apache::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(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::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(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->tableName);
            this->__isset.tableName = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->row);
            this->__isset.row = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 3:
          if (ftype == ::apache::thrift::protocol::T_MAP) {
            {
              this->attributes.clear();
              uint32_t _size422;
              ::apache::thrift::protocol::TType _ktype423;
              ::apache::thrift::protocol::TType _vtype424;
              xfer += iprot->readMapBegin(_ktype423, _vtype424, _size422);
              uint32_t _i426;
              for (_i426 = 0; _i426 < _size422; ++_i426)
              {
                Text _key427;
                xfer += iprot->readBinary(_key427);
                Text& _val428 = this->attributes[_key427];
                xfer += iprot->readBinary(_val428);
              }
              xfer += iprot->readMapEnd();
            }
            this->__isset.attributes = 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(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_deleteAllRow_args");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary(this->tableName);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
    xfer += oprot->writeBinary(this->row);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 3);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->attributes.size()));
      std::map<Text, Text> ::const_iterator _iter429;
      for (_iter429 = this->attributes.begin(); _iter429 != this->attributes.end(); ++_iter429)
      {
        xfer += oprot->writeBinary(_iter429->first);
        xfer += oprot->writeBinary(_iter429->second);
      }
      xfer += oprot->writeMapEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_deleteAllRow_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_deleteAllRow_pargs");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary((*(this->tableName)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
    xfer += oprot->writeBinary((*(this->row)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 3);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->attributes)).size()));
      std::map<Text, Text> ::const_iterator _iter430;
      for (_iter430 = (*(this->attributes)).begin(); _iter430 != (*(this->attributes)).end(); ++_iter430)
      {
        xfer += oprot->writeBinary(_iter430->first);
        xfer += oprot->writeBinary(_iter430->second);
      }
      xfer += oprot->writeMapEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_deleteAllRow_result::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::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(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("Hbase_deleteAllRow_result");
  
    if (this->__isset.io) {
      xfer += oprot->writeFieldBegin("io", ::apache::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(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::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_increment_args::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::thrift::protocol::T_STRUCT) {
            xfer += this->increment.read(iprot);
            this->__isset.increment = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  uint32_t Hbase_increment_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_increment_args");
  
    xfer += oprot->writeFieldBegin("increment", ::apache::thrift::protocol::T_STRUCT, 1);
    xfer += this->increment.write(oprot);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_increment_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_increment_pargs");
  
    xfer += oprot->writeFieldBegin("increment", ::apache::thrift::protocol::T_STRUCT, 1);
    xfer += (*(this->increment)).write(oprot);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_increment_result::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::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_increment_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("Hbase_increment_result");
  
    if (this->__isset.io) {
      xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
      xfer += this->io.write(oprot);
      xfer += oprot->writeFieldEnd();
    }
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_increment_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::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_incrementRows_args::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->increments.clear();
              uint32_t _size431;
              ::apache::thrift::protocol::TType _etype434;
              xfer += iprot->readListBegin(_etype434, _size431);
              this->increments.resize(_size431);
              uint32_t _i435;
              for (_i435 = 0; _i435 < _size431; ++_i435)
              {
                xfer += this->increments[_i435].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.increments = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  uint32_t Hbase_incrementRows_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_incrementRows_args");
  
    xfer += oprot->writeFieldBegin("increments", ::apache::thrift::protocol::T_LIST, 1);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->increments.size()));
      std::vector<TIncrement> ::const_iterator _iter436;
      for (_iter436 = this->increments.begin(); _iter436 != this->increments.end(); ++_iter436)
      {
        xfer += (*_iter436).write(oprot);
      }
      xfer += oprot->writeListEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_incrementRows_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_incrementRows_pargs");
  
    xfer += oprot->writeFieldBegin("increments", ::apache::thrift::protocol::T_LIST, 1);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->increments)).size()));
      std::vector<TIncrement> ::const_iterator _iter437;
      for (_iter437 = (*(this->increments)).begin(); _iter437 != (*(this->increments)).end(); ++_iter437)
      {
        xfer += (*_iter437).write(oprot);
      }
      xfer += oprot->writeListEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_incrementRows_result::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::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_incrementRows_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("Hbase_incrementRows_result");
  
    if (this->__isset.io) {
      xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
      xfer += this->io.write(oprot);
      xfer += oprot->writeFieldEnd();
    }
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_incrementRows_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::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(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->tableName);
            this->__isset.tableName = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->row);
            this->__isset.row = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 3:
          if (ftype == ::apache::thrift::protocol::T_I64) {
            xfer += iprot->readI64(this->timestamp);
            this->__isset.timestamp = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 4:
          if (ftype == ::apache::thrift::protocol::T_MAP) {
            {
              this->attributes.clear();
              uint32_t _size438;
              ::apache::thrift::protocol::TType _ktype439;
              ::apache::thrift::protocol::TType _vtype440;
              xfer += iprot->readMapBegin(_ktype439, _vtype440, _size438);
              uint32_t _i442;
              for (_i442 = 0; _i442 < _size438; ++_i442)
              {
                Text _key443;
                xfer += iprot->readBinary(_key443);
                Text& _val444 = this->attributes[_key443];
                xfer += iprot->readBinary(_val444);
              }
              xfer += iprot->readMapEnd();
            }
            this->__isset.attributes = 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(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_deleteAllRowTs_args");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary(this->tableName);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
    xfer += oprot->writeBinary(this->row);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 3);
    xfer += oprot->writeI64(this->timestamp);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 4);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->attributes.size()));
      std::map<Text, Text> ::const_iterator _iter445;
      for (_iter445 = this->attributes.begin(); _iter445 != this->attributes.end(); ++_iter445)
      {
        xfer += oprot->writeBinary(_iter445->first);
        xfer += oprot->writeBinary(_iter445->second);
      }
      xfer += oprot->writeMapEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_deleteAllRowTs_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_deleteAllRowTs_pargs");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary((*(this->tableName)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
    xfer += oprot->writeBinary((*(this->row)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 3);
    xfer += oprot->writeI64((*(this->timestamp)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 4);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->attributes)).size()));
      std::map<Text, Text> ::const_iterator _iter446;
      for (_iter446 = (*(this->attributes)).begin(); _iter446 != (*(this->attributes)).end(); ++_iter446)
      {
        xfer += oprot->writeBinary(_iter446->first);
        xfer += oprot->writeBinary(_iter446->second);
      }
      xfer += oprot->writeMapEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_deleteAllRowTs_result::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::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(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("Hbase_deleteAllRowTs_result");
  
    if (this->__isset.io) {
      xfer += oprot->writeFieldBegin("io", ::apache::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(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::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_scannerOpenWithScan_args::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->tableName);
            this->__isset.tableName = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::thrift::protocol::T_STRUCT) {
            xfer += this->scan.read(iprot);
            this->__isset.scan = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 3:
          if (ftype == ::apache::thrift::protocol::T_MAP) {
            {
              this->attributes.clear();
              uint32_t _size447;
              ::apache::thrift::protocol::TType _ktype448;
              ::apache::thrift::protocol::TType _vtype449;
              xfer += iprot->readMapBegin(_ktype448, _vtype449, _size447);
              uint32_t _i451;
              for (_i451 = 0; _i451 < _size447; ++_i451)
              {
                Text _key452;
                xfer += iprot->readBinary(_key452);
                Text& _val453 = this->attributes[_key452];
                xfer += iprot->readBinary(_val453);
              }
              xfer += iprot->readMapEnd();
            }
            this->__isset.attributes = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  uint32_t Hbase_scannerOpenWithScan_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_scannerOpenWithScan_args");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary(this->tableName);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("scan", ::apache::thrift::protocol::T_STRUCT, 2);
    xfer += this->scan.write(oprot);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 3);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->attributes.size()));
      std::map<Text, Text> ::const_iterator _iter454;
      for (_iter454 = this->attributes.begin(); _iter454 != this->attributes.end(); ++_iter454)
      {
        xfer += oprot->writeBinary(_iter454->first);
        xfer += oprot->writeBinary(_iter454->second);
      }
      xfer += oprot->writeMapEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_scannerOpenWithScan_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_scannerOpenWithScan_pargs");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary((*(this->tableName)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("scan", ::apache::thrift::protocol::T_STRUCT, 2);
    xfer += (*(this->scan)).write(oprot);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 3);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->attributes)).size()));
      std::map<Text, Text> ::const_iterator _iter455;
      for (_iter455 = (*(this->attributes)).begin(); _iter455 != (*(this->attributes)).end(); ++_iter455)
      {
        xfer += oprot->writeBinary(_iter455->first);
        xfer += oprot->writeBinary(_iter455->second);
      }
      xfer += oprot->writeMapEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_scannerOpenWithScan_result::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 0:
          if (ftype == ::apache::thrift::protocol::T_I32) {
            xfer += iprot->readI32(this->success);
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 1:
          if (ftype == ::apache::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_scannerOpenWithScan_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("Hbase_scannerOpenWithScan_result");
  
    if (this->__isset.success) {
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I32, 0);
      xfer += oprot->writeI32(this->success);
      xfer += oprot->writeFieldEnd();
    } else if (this->__isset.io) {
      xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
      xfer += this->io.write(oprot);
      xfer += oprot->writeFieldEnd();
    }
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_scannerOpenWithScan_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 0:
          if (ftype == ::apache::thrift::protocol::T_I32) {
            xfer += iprot->readI32((*(this->success)));
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 1:
          if (ftype == ::apache::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(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->tableName);
            this->__isset.tableName = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->startRow);
            this->__isset.startRow = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 3:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->columns.clear();
              uint32_t _size456;
              ::apache::thrift::protocol::TType _etype459;
              xfer += iprot->readListBegin(_etype459, _size456);
              this->columns.resize(_size456);
              uint32_t _i460;
              for (_i460 = 0; _i460 < _size456; ++_i460)
              {
                xfer += iprot->readBinary(this->columns[_i460]);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.columns = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 4:
          if (ftype == ::apache::thrift::protocol::T_MAP) {
            {
              this->attributes.clear();
              uint32_t _size461;
              ::apache::thrift::protocol::TType _ktype462;
              ::apache::thrift::protocol::TType _vtype463;
              xfer += iprot->readMapBegin(_ktype462, _vtype463, _size461);
              uint32_t _i465;
              for (_i465 = 0; _i465 < _size461; ++_i465)
              {
                Text _key466;
                xfer += iprot->readBinary(_key466);
                Text& _val467 = this->attributes[_key466];
                xfer += iprot->readBinary(_val467);
              }
              xfer += iprot->readMapEnd();
            }
            this->__isset.attributes = 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(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_scannerOpen_args");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary(this->tableName);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("startRow", ::apache::thrift::protocol::T_STRING, 2);
    xfer += oprot->writeBinary(this->startRow);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 3);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->columns.size()));
      std::vector<Text> ::const_iterator _iter468;
      for (_iter468 = this->columns.begin(); _iter468 != this->columns.end(); ++_iter468)
      {
        xfer += oprot->writeBinary((*_iter468));
      }
      xfer += oprot->writeListEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 4);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->attributes.size()));
      std::map<Text, Text> ::const_iterator _iter469;
      for (_iter469 = this->attributes.begin(); _iter469 != this->attributes.end(); ++_iter469)
      {
        xfer += oprot->writeBinary(_iter469->first);
        xfer += oprot->writeBinary(_iter469->second);
      }
      xfer += oprot->writeMapEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_scannerOpen_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_scannerOpen_pargs");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary((*(this->tableName)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("startRow", ::apache::thrift::protocol::T_STRING, 2);
    xfer += oprot->writeBinary((*(this->startRow)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 3);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->columns)).size()));
      std::vector<Text> ::const_iterator _iter470;
      for (_iter470 = (*(this->columns)).begin(); _iter470 != (*(this->columns)).end(); ++_iter470)
      {
        xfer += oprot->writeBinary((*_iter470));
      }
      xfer += oprot->writeListEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 4);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->attributes)).size()));
      std::map<Text, Text> ::const_iterator _iter471;
      for (_iter471 = (*(this->attributes)).begin(); _iter471 != (*(this->attributes)).end(); ++_iter471)
      {
        xfer += oprot->writeBinary(_iter471->first);
        xfer += oprot->writeBinary(_iter471->second);
      }
      xfer += oprot->writeMapEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_scannerOpen_result::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 0:
          if (ftype == ::apache::thrift::protocol::T_I32) {
            xfer += iprot->readI32(this->success);
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 1:
          if (ftype == ::apache::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(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("Hbase_scannerOpen_result");
  
    if (this->__isset.success) {
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I32, 0);
      xfer += oprot->writeI32(this->success);
      xfer += oprot->writeFieldEnd();
    } else if (this->__isset.io) {
      xfer += oprot->writeFieldBegin("io", ::apache::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(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 0:
          if (ftype == ::apache::thrift::protocol::T_I32) {
            xfer += iprot->readI32((*(this->success)));
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 1:
          if (ftype == ::apache::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(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->tableName);
            this->__isset.tableName = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->startRow);
            this->__isset.startRow = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 3:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->stopRow);
            this->__isset.stopRow = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 4:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->columns.clear();
              uint32_t _size472;
              ::apache::thrift::protocol::TType _etype475;
              xfer += iprot->readListBegin(_etype475, _size472);
              this->columns.resize(_size472);
              uint32_t _i476;
              for (_i476 = 0; _i476 < _size472; ++_i476)
              {
                xfer += iprot->readBinary(this->columns[_i476]);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.columns = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 5:
          if (ftype == ::apache::thrift::protocol::T_MAP) {
            {
              this->attributes.clear();
              uint32_t _size477;
              ::apache::thrift::protocol::TType _ktype478;
              ::apache::thrift::protocol::TType _vtype479;
              xfer += iprot->readMapBegin(_ktype478, _vtype479, _size477);
              uint32_t _i481;
              for (_i481 = 0; _i481 < _size477; ++_i481)
              {
                Text _key482;
                xfer += iprot->readBinary(_key482);
                Text& _val483 = this->attributes[_key482];
                xfer += iprot->readBinary(_val483);
              }
              xfer += iprot->readMapEnd();
            }
            this->__isset.attributes = 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(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_scannerOpenWithStop_args");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary(this->tableName);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("startRow", ::apache::thrift::protocol::T_STRING, 2);
    xfer += oprot->writeBinary(this->startRow);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("stopRow", ::apache::thrift::protocol::T_STRING, 3);
    xfer += oprot->writeBinary(this->stopRow);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 4);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->columns.size()));
      std::vector<Text> ::const_iterator _iter484;
      for (_iter484 = this->columns.begin(); _iter484 != this->columns.end(); ++_iter484)
      {
        xfer += oprot->writeBinary((*_iter484));
      }
      xfer += oprot->writeListEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 5);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->attributes.size()));
      std::map<Text, Text> ::const_iterator _iter485;
      for (_iter485 = this->attributes.begin(); _iter485 != this->attributes.end(); ++_iter485)
      {
        xfer += oprot->writeBinary(_iter485->first);
        xfer += oprot->writeBinary(_iter485->second);
      }
      xfer += oprot->writeMapEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_scannerOpenWithStop_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_scannerOpenWithStop_pargs");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary((*(this->tableName)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("startRow", ::apache::thrift::protocol::T_STRING, 2);
    xfer += oprot->writeBinary((*(this->startRow)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("stopRow", ::apache::thrift::protocol::T_STRING, 3);
    xfer += oprot->writeBinary((*(this->stopRow)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 4);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->columns)).size()));
      std::vector<Text> ::const_iterator _iter486;
      for (_iter486 = (*(this->columns)).begin(); _iter486 != (*(this->columns)).end(); ++_iter486)
      {
        xfer += oprot->writeBinary((*_iter486));
      }
      xfer += oprot->writeListEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 5);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->attributes)).size()));
      std::map<Text, Text> ::const_iterator _iter487;
      for (_iter487 = (*(this->attributes)).begin(); _iter487 != (*(this->attributes)).end(); ++_iter487)
      {
        xfer += oprot->writeBinary(_iter487->first);
        xfer += oprot->writeBinary(_iter487->second);
      }
      xfer += oprot->writeMapEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_scannerOpenWithStop_result::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 0:
          if (ftype == ::apache::thrift::protocol::T_I32) {
            xfer += iprot->readI32(this->success);
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 1:
          if (ftype == ::apache::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(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("Hbase_scannerOpenWithStop_result");
  
    if (this->__isset.success) {
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I32, 0);
      xfer += oprot->writeI32(this->success);
      xfer += oprot->writeFieldEnd();
    } else if (this->__isset.io) {
      xfer += oprot->writeFieldBegin("io", ::apache::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(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 0:
          if (ftype == ::apache::thrift::protocol::T_I32) {
            xfer += iprot->readI32((*(this->success)));
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 1:
          if (ftype == ::apache::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_scannerOpenWithPrefix_args::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->tableName);
            this->__isset.tableName = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->startAndPrefix);
            this->__isset.startAndPrefix = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 3:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->columns.clear();
              uint32_t _size488;
              ::apache::thrift::protocol::TType _etype491;
              xfer += iprot->readListBegin(_etype491, _size488);
              this->columns.resize(_size488);
              uint32_t _i492;
              for (_i492 = 0; _i492 < _size488; ++_i492)
              {
                xfer += iprot->readBinary(this->columns[_i492]);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.columns = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 4:
          if (ftype == ::apache::thrift::protocol::T_MAP) {
            {
              this->attributes.clear();
              uint32_t _size493;
              ::apache::thrift::protocol::TType _ktype494;
              ::apache::thrift::protocol::TType _vtype495;
              xfer += iprot->readMapBegin(_ktype494, _vtype495, _size493);
              uint32_t _i497;
              for (_i497 = 0; _i497 < _size493; ++_i497)
              {
                Text _key498;
                xfer += iprot->readBinary(_key498);
                Text& _val499 = this->attributes[_key498];
                xfer += iprot->readBinary(_val499);
              }
              xfer += iprot->readMapEnd();
            }
            this->__isset.attributes = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  uint32_t Hbase_scannerOpenWithPrefix_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_scannerOpenWithPrefix_args");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary(this->tableName);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("startAndPrefix", ::apache::thrift::protocol::T_STRING, 2);
    xfer += oprot->writeBinary(this->startAndPrefix);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 3);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->columns.size()));
      std::vector<Text> ::const_iterator _iter500;
      for (_iter500 = this->columns.begin(); _iter500 != this->columns.end(); ++_iter500)
      {
        xfer += oprot->writeBinary((*_iter500));
      }
      xfer += oprot->writeListEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 4);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->attributes.size()));
      std::map<Text, Text> ::const_iterator _iter501;
      for (_iter501 = this->attributes.begin(); _iter501 != this->attributes.end(); ++_iter501)
      {
        xfer += oprot->writeBinary(_iter501->first);
        xfer += oprot->writeBinary(_iter501->second);
      }
      xfer += oprot->writeMapEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_scannerOpenWithPrefix_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_scannerOpenWithPrefix_pargs");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary((*(this->tableName)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("startAndPrefix", ::apache::thrift::protocol::T_STRING, 2);
    xfer += oprot->writeBinary((*(this->startAndPrefix)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 3);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->columns)).size()));
      std::vector<Text> ::const_iterator _iter502;
      for (_iter502 = (*(this->columns)).begin(); _iter502 != (*(this->columns)).end(); ++_iter502)
      {
        xfer += oprot->writeBinary((*_iter502));
      }
      xfer += oprot->writeListEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 4);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->attributes)).size()));
      std::map<Text, Text> ::const_iterator _iter503;
      for (_iter503 = (*(this->attributes)).begin(); _iter503 != (*(this->attributes)).end(); ++_iter503)
      {
        xfer += oprot->writeBinary(_iter503->first);
        xfer += oprot->writeBinary(_iter503->second);
      }
      xfer += oprot->writeMapEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_scannerOpenWithPrefix_result::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 0:
          if (ftype == ::apache::thrift::protocol::T_I32) {
            xfer += iprot->readI32(this->success);
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 1:
          if (ftype == ::apache::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_scannerOpenWithPrefix_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("Hbase_scannerOpenWithPrefix_result");
  
    if (this->__isset.success) {
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I32, 0);
      xfer += oprot->writeI32(this->success);
      xfer += oprot->writeFieldEnd();
    } else if (this->__isset.io) {
      xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
      xfer += this->io.write(oprot);
      xfer += oprot->writeFieldEnd();
    }
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_scannerOpenWithPrefix_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 0:
          if (ftype == ::apache::thrift::protocol::T_I32) {
            xfer += iprot->readI32((*(this->success)));
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 1:
          if (ftype == ::apache::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(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->tableName);
            this->__isset.tableName = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->startRow);
            this->__isset.startRow = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 3:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->columns.clear();
              uint32_t _size504;
              ::apache::thrift::protocol::TType _etype507;
              xfer += iprot->readListBegin(_etype507, _size504);
              this->columns.resize(_size504);
              uint32_t _i508;
              for (_i508 = 0; _i508 < _size504; ++_i508)
              {
                xfer += iprot->readBinary(this->columns[_i508]);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.columns = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 4:
          if (ftype == ::apache::thrift::protocol::T_I64) {
            xfer += iprot->readI64(this->timestamp);
            this->__isset.timestamp = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 5:
          if (ftype == ::apache::thrift::protocol::T_MAP) {
            {
              this->attributes.clear();
              uint32_t _size509;
              ::apache::thrift::protocol::TType _ktype510;
              ::apache::thrift::protocol::TType _vtype511;
              xfer += iprot->readMapBegin(_ktype510, _vtype511, _size509);
              uint32_t _i513;
              for (_i513 = 0; _i513 < _size509; ++_i513)
              {
                Text _key514;
                xfer += iprot->readBinary(_key514);
                Text& _val515 = this->attributes[_key514];
                xfer += iprot->readBinary(_val515);
              }
              xfer += iprot->readMapEnd();
            }
            this->__isset.attributes = 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(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_scannerOpenTs_args");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary(this->tableName);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("startRow", ::apache::thrift::protocol::T_STRING, 2);
    xfer += oprot->writeBinary(this->startRow);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 3);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->columns.size()));
      std::vector<Text> ::const_iterator _iter516;
      for (_iter516 = this->columns.begin(); _iter516 != this->columns.end(); ++_iter516)
      {
        xfer += oprot->writeBinary((*_iter516));
      }
      xfer += oprot->writeListEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 4);
    xfer += oprot->writeI64(this->timestamp);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 5);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->attributes.size()));
      std::map<Text, Text> ::const_iterator _iter517;
      for (_iter517 = this->attributes.begin(); _iter517 != this->attributes.end(); ++_iter517)
      {
        xfer += oprot->writeBinary(_iter517->first);
        xfer += oprot->writeBinary(_iter517->second);
      }
      xfer += oprot->writeMapEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_scannerOpenTs_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_scannerOpenTs_pargs");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary((*(this->tableName)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("startRow", ::apache::thrift::protocol::T_STRING, 2);
    xfer += oprot->writeBinary((*(this->startRow)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 3);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->columns)).size()));
      std::vector<Text> ::const_iterator _iter518;
      for (_iter518 = (*(this->columns)).begin(); _iter518 != (*(this->columns)).end(); ++_iter518)
      {
        xfer += oprot->writeBinary((*_iter518));
      }
      xfer += oprot->writeListEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 4);
    xfer += oprot->writeI64((*(this->timestamp)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 5);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->attributes)).size()));
      std::map<Text, Text> ::const_iterator _iter519;
      for (_iter519 = (*(this->attributes)).begin(); _iter519 != (*(this->attributes)).end(); ++_iter519)
      {
        xfer += oprot->writeBinary(_iter519->first);
        xfer += oprot->writeBinary(_iter519->second);
      }
      xfer += oprot->writeMapEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_scannerOpenTs_result::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 0:
          if (ftype == ::apache::thrift::protocol::T_I32) {
            xfer += iprot->readI32(this->success);
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 1:
          if (ftype == ::apache::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(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("Hbase_scannerOpenTs_result");
  
    if (this->__isset.success) {
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I32, 0);
      xfer += oprot->writeI32(this->success);
      xfer += oprot->writeFieldEnd();
    } else if (this->__isset.io) {
      xfer += oprot->writeFieldBegin("io", ::apache::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(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 0:
          if (ftype == ::apache::thrift::protocol::T_I32) {
            xfer += iprot->readI32((*(this->success)));
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 1:
          if (ftype == ::apache::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(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->tableName);
            this->__isset.tableName = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->startRow);
            this->__isset.startRow = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 3:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->stopRow);
            this->__isset.stopRow = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 4:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->columns.clear();
              uint32_t _size520;
              ::apache::thrift::protocol::TType _etype523;
              xfer += iprot->readListBegin(_etype523, _size520);
              this->columns.resize(_size520);
              uint32_t _i524;
              for (_i524 = 0; _i524 < _size520; ++_i524)
              {
                xfer += iprot->readBinary(this->columns[_i524]);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.columns = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 5:
          if (ftype == ::apache::thrift::protocol::T_I64) {
            xfer += iprot->readI64(this->timestamp);
            this->__isset.timestamp = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 6:
          if (ftype == ::apache::thrift::protocol::T_MAP) {
            {
              this->attributes.clear();
              uint32_t _size525;
              ::apache::thrift::protocol::TType _ktype526;
              ::apache::thrift::protocol::TType _vtype527;
              xfer += iprot->readMapBegin(_ktype526, _vtype527, _size525);
              uint32_t _i529;
              for (_i529 = 0; _i529 < _size525; ++_i529)
              {
                Text _key530;
                xfer += iprot->readBinary(_key530);
                Text& _val531 = this->attributes[_key530];
                xfer += iprot->readBinary(_val531);
              }
              xfer += iprot->readMapEnd();
            }
            this->__isset.attributes = 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(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_scannerOpenWithStopTs_args");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary(this->tableName);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("startRow", ::apache::thrift::protocol::T_STRING, 2);
    xfer += oprot->writeBinary(this->startRow);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("stopRow", ::apache::thrift::protocol::T_STRING, 3);
    xfer += oprot->writeBinary(this->stopRow);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 4);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->columns.size()));
      std::vector<Text> ::const_iterator _iter532;
      for (_iter532 = this->columns.begin(); _iter532 != this->columns.end(); ++_iter532)
      {
        xfer += oprot->writeBinary((*_iter532));
      }
      xfer += oprot->writeListEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 5);
    xfer += oprot->writeI64(this->timestamp);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 6);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->attributes.size()));
      std::map<Text, Text> ::const_iterator _iter533;
      for (_iter533 = this->attributes.begin(); _iter533 != this->attributes.end(); ++_iter533)
      {
        xfer += oprot->writeBinary(_iter533->first);
        xfer += oprot->writeBinary(_iter533->second);
      }
      xfer += oprot->writeMapEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_scannerOpenWithStopTs_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_scannerOpenWithStopTs_pargs");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary((*(this->tableName)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("startRow", ::apache::thrift::protocol::T_STRING, 2);
    xfer += oprot->writeBinary((*(this->startRow)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("stopRow", ::apache::thrift::protocol::T_STRING, 3);
    xfer += oprot->writeBinary((*(this->stopRow)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 4);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->columns)).size()));
      std::vector<Text> ::const_iterator _iter534;
      for (_iter534 = (*(this->columns)).begin(); _iter534 != (*(this->columns)).end(); ++_iter534)
      {
        xfer += oprot->writeBinary((*_iter534));
      }
      xfer += oprot->writeListEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 5);
    xfer += oprot->writeI64((*(this->timestamp)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 6);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->attributes)).size()));
      std::map<Text, Text> ::const_iterator _iter535;
      for (_iter535 = (*(this->attributes)).begin(); _iter535 != (*(this->attributes)).end(); ++_iter535)
      {
        xfer += oprot->writeBinary(_iter535->first);
        xfer += oprot->writeBinary(_iter535->second);
      }
      xfer += oprot->writeMapEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_scannerOpenWithStopTs_result::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 0:
          if (ftype == ::apache::thrift::protocol::T_I32) {
            xfer += iprot->readI32(this->success);
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 1:
          if (ftype == ::apache::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(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("Hbase_scannerOpenWithStopTs_result");
  
    if (this->__isset.success) {
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I32, 0);
      xfer += oprot->writeI32(this->success);
      xfer += oprot->writeFieldEnd();
    } else if (this->__isset.io) {
      xfer += oprot->writeFieldBegin("io", ::apache::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(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 0:
          if (ftype == ::apache::thrift::protocol::T_I32) {
            xfer += iprot->readI32((*(this->success)));
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 1:
          if (ftype == ::apache::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(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::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(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_scannerGet_args");
  
    xfer += oprot->writeFieldBegin("id", ::apache::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(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_scannerGet_pargs");
  
    xfer += oprot->writeFieldBegin("id", ::apache::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(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 0:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
              uint32_t _size536;
              ::apache::thrift::protocol::TType _etype539;
              xfer += iprot->readListBegin(_etype539, _size536);
              this->success.resize(_size536);
              uint32_t _i540;
              for (_i540 = 0; _i540 < _size536; ++_i540)
              {
                xfer += this->success[_i540].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 1:
          if (ftype == ::apache::thrift::protocol::T_STRUCT) {
            xfer += this->io.read(iprot);
            this->__isset.io = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::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_scannerGet_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("Hbase_scannerGet_result");
  
    if (this->__isset.success) {
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
      {
        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
        std::vector<TRowResult> ::const_iterator _iter541;
        for (_iter541 = this->success.begin(); _iter541 != this->success.end(); ++_iter541)
        {
          xfer += (*_iter541).write(oprot);
        }
        xfer += oprot->writeListEnd();
      }
      xfer += oprot->writeFieldEnd();
    } else if (this->__isset.io) {
      xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
      xfer += this->io.write(oprot);
      xfer += oprot->writeFieldEnd();
    } else if (this->__isset.ia) {
      xfer += oprot->writeFieldBegin("ia", ::apache::thrift::protocol::T_STRUCT, 2);
      xfer += this->ia.write(oprot);
      xfer += oprot->writeFieldEnd();
    }
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_scannerGet_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 0:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
              uint32_t _size542;
              ::apache::thrift::protocol::TType _etype545;
              xfer += iprot->readListBegin(_etype545, _size542);
              (*(this->success)).resize(_size542);
              uint32_t _i546;
              for (_i546 = 0; _i546 < _size542; ++_i546)
              {
                xfer += (*(this->success))[_i546].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 1:
          if (ftype == ::apache::thrift::protocol::T_STRUCT) {
            xfer += this->io.read(iprot);
            this->__isset.io = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::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_scannerGetList_args::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::thrift::protocol::T_I32) {
            xfer += iprot->readI32(this->id);
            this->__isset.id = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::thrift::protocol::T_I32) {
            xfer += iprot->readI32(this->nbRows);
            this->__isset.nbRows = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  uint32_t Hbase_scannerGetList_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_scannerGetList_args");
  
    xfer += oprot->writeFieldBegin("id", ::apache::thrift::protocol::T_I32, 1);
    xfer += oprot->writeI32(this->id);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("nbRows", ::apache::thrift::protocol::T_I32, 2);
    xfer += oprot->writeI32(this->nbRows);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_scannerGetList_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_scannerGetList_pargs");
  
    xfer += oprot->writeFieldBegin("id", ::apache::thrift::protocol::T_I32, 1);
    xfer += oprot->writeI32((*(this->id)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("nbRows", ::apache::thrift::protocol::T_I32, 2);
    xfer += oprot->writeI32((*(this->nbRows)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_scannerGetList_result::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 0:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
              uint32_t _size547;
              ::apache::thrift::protocol::TType _etype550;
              xfer += iprot->readListBegin(_etype550, _size547);
              this->success.resize(_size547);
              uint32_t _i551;
              for (_i551 = 0; _i551 < _size547; ++_i551)
              {
                xfer += this->success[_i551].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 1:
          if (ftype == ::apache::thrift::protocol::T_STRUCT) {
            xfer += this->io.read(iprot);
            this->__isset.io = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::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_scannerGetList_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("Hbase_scannerGetList_result");
  
    if (this->__isset.success) {
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
      {
        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
        std::vector<TRowResult> ::const_iterator _iter552;
        for (_iter552 = this->success.begin(); _iter552 != this->success.end(); ++_iter552)
        {
          xfer += (*_iter552).write(oprot);
        }
        xfer += oprot->writeListEnd();
      }
      xfer += oprot->writeFieldEnd();
    } else if (this->__isset.io) {
      xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
      xfer += this->io.write(oprot);
      xfer += oprot->writeFieldEnd();
    } else if (this->__isset.ia) {
      xfer += oprot->writeFieldBegin("ia", ::apache::thrift::protocol::T_STRUCT, 2);
      xfer += this->ia.write(oprot);
      xfer += oprot->writeFieldEnd();
    }
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_scannerGetList_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 0:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
              uint32_t _size553;
              ::apache::thrift::protocol::TType _etype556;
              xfer += iprot->readListBegin(_etype556, _size553);
              (*(this->success)).resize(_size553);
              uint32_t _i557;
              for (_i557 = 0; _i557 < _size553; ++_i557)
              {
                xfer += (*(this->success))[_i557].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 1:
          if (ftype == ::apache::thrift::protocol::T_STRUCT) {
            xfer += this->io.read(iprot);
            this->__isset.io = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::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_args::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::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(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_scannerClose_args");
  
    xfer += oprot->writeFieldBegin("id", ::apache::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(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_scannerClose_pargs");
  
    xfer += oprot->writeFieldBegin("id", ::apache::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(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::thrift::protocol::T_STRUCT) {
            xfer += this->io.read(iprot);
            this->__isset.io = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::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(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("Hbase_scannerClose_result");
  
    if (this->__isset.io) {
      xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
      xfer += this->io.write(oprot);
      xfer += oprot->writeFieldEnd();
    } else if (this->__isset.ia) {
      xfer += oprot->writeFieldBegin("ia", ::apache::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(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::thrift::protocol::T_STRUCT) {
            xfer += this->io.read(iprot);
            this->__isset.io = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::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_getRowOrBefore_args::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->tableName);
            this->__isset.tableName = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->row);
            this->__isset.row = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 3:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->family);
            this->__isset.family = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  uint32_t Hbase_getRowOrBefore_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_getRowOrBefore_args");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary(this->tableName);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
    xfer += oprot->writeBinary(this->row);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("family", ::apache::thrift::protocol::T_STRING, 3);
    xfer += oprot->writeBinary(this->family);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_getRowOrBefore_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_getRowOrBefore_pargs");
  
    xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary((*(this->tableName)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
    xfer += oprot->writeBinary((*(this->row)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("family", ::apache::thrift::protocol::T_STRING, 3);
    xfer += oprot->writeBinary((*(this->family)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_getRowOrBefore_result::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 0:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
              uint32_t _size558;
              ::apache::thrift::protocol::TType _etype561;
              xfer += iprot->readListBegin(_etype561, _size558);
              this->success.resize(_size558);
              uint32_t _i562;
              for (_i562 = 0; _i562 < _size558; ++_i562)
              {
                xfer += this->success[_i562].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 1:
          if (ftype == ::apache::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_getRowOrBefore_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("Hbase_getRowOrBefore_result");
  
    if (this->__isset.success) {
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
      {
        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
        std::vector<TCell> ::const_iterator _iter563;
        for (_iter563 = this->success.begin(); _iter563 != this->success.end(); ++_iter563)
        {
          xfer += (*_iter563).write(oprot);
        }
        xfer += oprot->writeListEnd();
      }
      xfer += oprot->writeFieldEnd();
    } else if (this->__isset.io) {
      xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
      xfer += this->io.write(oprot);
      xfer += oprot->writeFieldEnd();
    }
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_getRowOrBefore_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 0:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
              uint32_t _size564;
              ::apache::thrift::protocol::TType _etype567;
              xfer += iprot->readListBegin(_etype567, _size564);
              (*(this->success)).resize(_size564);
              uint32_t _i568;
              for (_i568 = 0; _i568 < _size564; ++_i568)
              {
                xfer += (*(this->success))[_i568].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 1:
          if (ftype == ::apache::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_getRegionInfo_args::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 1:
          if (ftype == ::apache::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_getRegionInfo_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_getRegionInfo_args");
  
    xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary(this->row);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_getRegionInfo_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    xfer += oprot->writeStructBegin("Hbase_getRegionInfo_pargs");
  
    xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary((*(this->row)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_getRegionInfo_result::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 0:
          if (ftype == ::apache::thrift::protocol::T_STRUCT) {
            xfer += this->success.read(iprot);
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 1:
          if (ftype == ::apache::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_getRegionInfo_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("Hbase_getRegionInfo_result");
  
    if (this->__isset.success) {
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0);
      xfer += this->success.write(oprot);
      xfer += oprot->writeFieldEnd();
    } else if (this->__isset.io) {
      xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
      xfer += this->io.write(oprot);
      xfer += oprot->writeFieldEnd();
    }
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  uint32_t Hbase_getRegionInfo_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    uint32_t xfer = 0;
    std::string fname;
    ::apache::thrift::protocol::TType ftype;
    int16_t fid;
  
    xfer += iprot->readStructBegin(fname);
  
    using ::apache::thrift::protocol::TProtocolException;
  
  
    while (true)
    {
      xfer += iprot->readFieldBegin(fname, ftype, fid);
      if (ftype == ::apache::thrift::protocol::T_STOP) {
        break;
      }
      switch (fid)
      {
        case 0:
          if (ftype == ::apache::thrift::protocol::T_STRUCT) {
            xfer += (*(this->success)).read(iprot);
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 1:
          if (ftype == ::apache::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;
  }
  
  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", ::apache::thrift::protocol::T_CALL, cseqid);
  
    Hbase_enableTable_pargs args;
    args.tableName = &tableName;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  void HbaseClient::recv_enableTable()
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    iprot_->readMessageBegin(fname, mtype, rseqid);
    if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
      ::apache::thrift::TApplicationException x;
      x.read(iprot_);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
      throw x;
    }
    if (mtype != ::apache::thrift::protocol::T_REPLY) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    if (fname.compare("enableTable") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    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", ::apache::thrift::protocol::T_CALL, cseqid);
  
    Hbase_disableTable_pargs args;
    args.tableName = &tableName;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  void HbaseClient::recv_disableTable()
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    iprot_->readMessageBegin(fname, mtype, rseqid);
    if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
      ::apache::thrift::TApplicationException x;
      x.read(iprot_);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
      throw x;
    }
    if (mtype != ::apache::thrift::protocol::T_REPLY) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    if (fname.compare("disableTable") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    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", ::apache::thrift::protocol::T_CALL, cseqid);
  
    Hbase_isTableEnabled_pargs args;
    args.tableName = &tableName;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  bool HbaseClient::recv_isTableEnabled()
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    iprot_->readMessageBegin(fname, mtype, rseqid);
    if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
      ::apache::thrift::TApplicationException x;
      x.read(iprot_);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
      throw x;
    }
    if (mtype != ::apache::thrift::protocol::T_REPLY) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    if (fname.compare("isTableEnabled") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    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 ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "isTableEnabled failed: unknown result");
  }
  
  void HbaseClient::compact(const Bytes& tableNameOrRegionName)
  {
    send_compact(tableNameOrRegionName);
    recv_compact();
  }
  
  void HbaseClient::send_compact(const Bytes& tableNameOrRegionName)
  {
    int32_t cseqid = 0;
    oprot_->writeMessageBegin("compact", ::apache::thrift::protocol::T_CALL, cseqid);
  
    Hbase_compact_pargs args;
    args.tableNameOrRegionName = &tableNameOrRegionName;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  void HbaseClient::recv_compact()
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    iprot_->readMessageBegin(fname, mtype, rseqid);
    if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
      ::apache::thrift::TApplicationException x;
      x.read(iprot_);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
      throw x;
    }
    if (mtype != ::apache::thrift::protocol::T_REPLY) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    if (fname.compare("compact") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    Hbase_compact_presult result;
    result.read(iprot_);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
  
    if (result.__isset.io) {
      throw result.io;
    }
    return;
  }
  
  void HbaseClient::majorCompact(const Bytes& tableNameOrRegionName)
  {
    send_majorCompact(tableNameOrRegionName);
    recv_majorCompact();
  }
  
  void HbaseClient::send_majorCompact(const Bytes& tableNameOrRegionName)
  {
    int32_t cseqid = 0;
    oprot_->writeMessageBegin("majorCompact", ::apache::thrift::protocol::T_CALL, cseqid);
  
    Hbase_majorCompact_pargs args;
    args.tableNameOrRegionName = &tableNameOrRegionName;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  void HbaseClient::recv_majorCompact()
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    iprot_->readMessageBegin(fname, mtype, rseqid);
    if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
      ::apache::thrift::TApplicationException x;
      x.read(iprot_);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
      throw x;
    }
    if (mtype != ::apache::thrift::protocol::T_REPLY) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    if (fname.compare("majorCompact") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    Hbase_majorCompact_presult result;
    result.read(iprot_);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
  
    if (result.__isset.io) {
      throw result.io;
    }
    return;
  }
  
  void HbaseClient::getTableNames(std::vector<Text> & _return)
  {
    send_getTableNames();
    recv_getTableNames(_return);
  }
  
  void HbaseClient::send_getTableNames()
  {
    int32_t cseqid = 0;
    oprot_->writeMessageBegin("getTableNames", ::apache::thrift::protocol::T_CALL, cseqid);
  
    Hbase_getTableNames_pargs args;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  void HbaseClient::recv_getTableNames(std::vector<Text> & _return)
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    iprot_->readMessageBegin(fname, mtype, rseqid);
    if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
      ::apache::thrift::TApplicationException x;
      x.read(iprot_);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
      throw x;
    }
    if (mtype != ::apache::thrift::protocol::T_REPLY) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    if (fname.compare("getTableNames") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    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 ::apache::thrift::TApplicationException(::apache::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", ::apache::thrift::protocol::T_CALL, cseqid);
  
    Hbase_getColumnDescriptors_pargs args;
    args.tableName = &tableName;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  void HbaseClient::recv_getColumnDescriptors(std::map<Text, ColumnDescriptor> & _return)
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    iprot_->readMessageBegin(fname, mtype, rseqid);
    if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
      ::apache::thrift::TApplicationException x;
      x.read(iprot_);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
      throw x;
    }
    if (mtype != ::apache::thrift::protocol::T_REPLY) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    if (fname.compare("getColumnDescriptors") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    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 ::apache::thrift::TApplicationException(::apache::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", ::apache::thrift::protocol::T_CALL, cseqid);
  
    Hbase_getTableRegions_pargs args;
    args.tableName = &tableName;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  void HbaseClient::recv_getTableRegions(std::vector<TRegionInfo> & _return)
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    iprot_->readMessageBegin(fname, mtype, rseqid);
    if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
      ::apache::thrift::TApplicationException x;
      x.read(iprot_);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
      throw x;
    }
    if (mtype != ::apache::thrift::protocol::T_REPLY) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    if (fname.compare("getTableRegions") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    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 ::apache::thrift::TApplicationException(::apache::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", ::apache::thrift::protocol::T_CALL, cseqid);
  
    Hbase_createTable_pargs args;
    args.tableName = &tableName;
    args.columnFamilies = &columnFamilies;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  void HbaseClient::recv_createTable()
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    iprot_->readMessageBegin(fname, mtype, rseqid);
    if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
      ::apache::thrift::TApplicationException x;
      x.read(iprot_);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
      throw x;
    }
    if (mtype != ::apache::thrift::protocol::T_REPLY) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    if (fname.compare("createTable") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    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", ::apache::thrift::protocol::T_CALL, cseqid);
  
    Hbase_deleteTable_pargs args;
    args.tableName = &tableName;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  void HbaseClient::recv_deleteTable()
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    iprot_->readMessageBegin(fname, mtype, rseqid);
    if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
      ::apache::thrift::TApplicationException x;
      x.read(iprot_);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
      throw x;
    }
    if (mtype != ::apache::thrift::protocol::T_REPLY) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    if (fname.compare("deleteTable") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    Hbase_deleteTable_presult result;
    result.read(iprot_);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
  
    if (result.__isset.io) {
      throw result.io;
    }
    return;
  }
  
  void HbaseClient::get(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& column, const std::map<Text, Text> & attributes)
  {
    send_get(tableName, row, column, attributes);
    recv_get(_return);
  }
  
  void HbaseClient::send_get(const Text& tableName, const Text& row, const Text& column, const std::map<Text, Text> & attributes)
  {
    int32_t cseqid = 0;
    oprot_->writeMessageBegin("get", ::apache::thrift::protocol::T_CALL, cseqid);
  
    Hbase_get_pargs args;
    args.tableName = &tableName;
    args.row = &row;
    args.column = &column;
    args.attributes = &attributes;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  void HbaseClient::recv_get(std::vector<TCell> & _return)
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    iprot_->readMessageBegin(fname, mtype, rseqid);
    if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
      ::apache::thrift::TApplicationException x;
      x.read(iprot_);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
      throw x;
    }
    if (mtype != ::apache::thrift::protocol::T_REPLY) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    if (fname.compare("get") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    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;
    }
    throw ::apache::thrift::TApplicationException(::apache::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, const std::map<Text, Text> & attributes)
  {
    send_getVer(tableName, row, column, numVersions, attributes);
    recv_getVer(_return);
  }
  
  void HbaseClient::send_getVer(const Text& tableName, const Text& row, const Text& column, const int32_t numVersions, const std::map<Text, Text> & attributes)
  {
    int32_t cseqid = 0;
    oprot_->writeMessageBegin("getVer", ::apache::thrift::protocol::T_CALL, cseqid);
  
    Hbase_getVer_pargs args;
    args.tableName = &tableName;
    args.row = &row;
    args.column = &column;
    args.numVersions = &numVersions;
    args.attributes = &attributes;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  void HbaseClient::recv_getVer(std::vector<TCell> & _return)
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    iprot_->readMessageBegin(fname, mtype, rseqid);
    if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
      ::apache::thrift::TApplicationException x;
      x.read(iprot_);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
      throw x;
    }
    if (mtype != ::apache::thrift::protocol::T_REPLY) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    if (fname.compare("getVer") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    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;
    }
    throw ::apache::thrift::TApplicationException(::apache::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, const std::map<Text, Text> & attributes)
  {
    send_getVerTs(tableName, row, column, timestamp, numVersions, attributes);
    recv_getVerTs(_return);
  }
  
  void HbaseClient::send_getVerTs(const Text& tableName, const Text& row, const Text& column, const int64_t timestamp, const int32_t numVersions, const std::map<Text, Text> & attributes)
  {
    int32_t cseqid = 0;
    oprot_->writeMessageBegin("getVerTs", ::apache::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.attributes = &attributes;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  void HbaseClient::recv_getVerTs(std::vector<TCell> & _return)
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    iprot_->readMessageBegin(fname, mtype, rseqid);
    if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
      ::apache::thrift::TApplicationException x;
      x.read(iprot_);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
      throw x;
    }
    if (mtype != ::apache::thrift::protocol::T_REPLY) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    if (fname.compare("getVerTs") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    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;
    }
    throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getVerTs failed: unknown result");
  }
  
  void HbaseClient::getRow(std::vector<TRowResult> & _return, const Text& tableName, const Text& row, const std::map<Text, Text> & attributes)
  {
    send_getRow(tableName, row, attributes);
    recv_getRow(_return);
  }
  
  void HbaseClient::send_getRow(const Text& tableName, const Text& row, const std::map<Text, Text> & attributes)
  {
    int32_t cseqid = 0;
    oprot_->writeMessageBegin("getRow", ::apache::thrift::protocol::T_CALL, cseqid);
  
    Hbase_getRow_pargs args;
    args.tableName = &tableName;
    args.row = &row;
    args.attributes = &attributes;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  void HbaseClient::recv_getRow(std::vector<TRowResult> & _return)
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    iprot_->readMessageBegin(fname, mtype, rseqid);
    if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
      ::apache::thrift::TApplicationException x;
      x.read(iprot_);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
      throw x;
    }
    if (mtype != ::apache::thrift::protocol::T_REPLY) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    if (fname.compare("getRow") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    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 ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getRow failed: unknown result");
  }
  
  void HbaseClient::getRowWithColumns(std::vector<TRowResult> & _return, const Text& tableName, const Text& row, const std::vector<Text> & columns, const std::map<Text, Text> & attributes)
  {
    send_getRowWithColumns(tableName, row, columns, attributes);
    recv_getRowWithColumns(_return);
  }
  
  void HbaseClient::send_getRowWithColumns(const Text& tableName, const Text& row, const std::vector<Text> & columns, const std::map<Text, Text> & attributes)
  {
    int32_t cseqid = 0;
    oprot_->writeMessageBegin("getRowWithColumns", ::apache::thrift::protocol::T_CALL, cseqid);
  
    Hbase_getRowWithColumns_pargs args;
    args.tableName = &tableName;
    args.row = &row;
    args.columns = &columns;
    args.attributes = &attributes;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  void HbaseClient::recv_getRowWithColumns(std::vector<TRowResult> & _return)
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    iprot_->readMessageBegin(fname, mtype, rseqid);
    if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
      ::apache::thrift::TApplicationException x;
      x.read(iprot_);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
      throw x;
    }
    if (mtype != ::apache::thrift::protocol::T_REPLY) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    if (fname.compare("getRowWithColumns") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    Hbase_getRowWithColumns_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 ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getRowWithColumns failed: unknown result");
  }
  
  void HbaseClient::getRowTs(std::vector<TRowResult> & _return, const Text& tableName, const Text& row, const int64_t timestamp, const std::map<Text, Text> & attributes)
  {
    send_getRowTs(tableName, row, timestamp, attributes);
    recv_getRowTs(_return);
  }
  
  void HbaseClient::send_getRowTs(const Text& tableName, const Text& row, const int64_t timestamp, const std::map<Text, Text> & attributes)
  {
    int32_t cseqid = 0;
    oprot_->writeMessageBegin("getRowTs", ::apache::thrift::protocol::T_CALL, cseqid);
  
    Hbase_getRowTs_pargs args;
    args.tableName = &tableName;
    args.row = &row;
    args.timestamp = &timestamp;
    args.attributes = &attributes;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  void HbaseClient::recv_getRowTs(std::vector<TRowResult> & _return)
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    iprot_->readMessageBegin(fname, mtype, rseqid);
    if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
      ::apache::thrift::TApplicationException x;
      x.read(iprot_);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
      throw x;
    }
    if (mtype != ::apache::thrift::protocol::T_REPLY) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    if (fname.compare("getRowTs") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    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 ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getRowTs failed: unknown result");
  }
  
  void HbaseClient::getRowWithColumnsTs(std::vector<TRowResult> & _return, const Text& tableName, const Text& row, const std::vector<Text> & columns, const int64_t timestamp, const std::map<Text, Text> & attributes)
  {
    send_getRowWithColumnsTs(tableName, row, columns, timestamp, attributes);
    recv_getRowWithColumnsTs(_return);
  }
  
  void HbaseClient::send_getRowWithColumnsTs(const Text& tableName, const Text& row, const std::vector<Text> & columns, const int64_t timestamp, const std::map<Text, Text> & attributes)
  {
    int32_t cseqid = 0;
    oprot_->writeMessageBegin("getRowWithColumnsTs", ::apache::thrift::protocol::T_CALL, cseqid);
  
    Hbase_getRowWithColumnsTs_pargs args;
    args.tableName = &tableName;
    args.row = &row;
    args.columns = &columns;
    args.timestamp = &timestamp;
    args.attributes = &attributes;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  void HbaseClient::recv_getRowWithColumnsTs(std::vector<TRowResult> & _return)
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    iprot_->readMessageBegin(fname, mtype, rseqid);
    if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
      ::apache::thrift::TApplicationException x;
      x.read(iprot_);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
      throw x;
    }
    if (mtype != ::apache::thrift::protocol::T_REPLY) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    if (fname.compare("getRowWithColumnsTs") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    Hbase_getRowWithColumnsTs_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 ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getRowWithColumnsTs failed: unknown result");
  }
  
  void HbaseClient::getRows(std::vector<TRowResult> & _return, const Text& tableName, const std::vector<Text> & rows, const std::map<Text, Text> & attributes)
  {
    send_getRows(tableName, rows, attributes);
    recv_getRows(_return);
  }
  
  void HbaseClient::send_getRows(const Text& tableName, const std::vector<Text> & rows, const std::map<Text, Text> & attributes)
  {
    int32_t cseqid = 0;
    oprot_->writeMessageBegin("getRows", ::apache::thrift::protocol::T_CALL, cseqid);
  
    Hbase_getRows_pargs args;
    args.tableName = &tableName;
    args.rows = &rows;
    args.attributes = &attributes;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  void HbaseClient::recv_getRows(std::vector<TRowResult> & _return)
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    iprot_->readMessageBegin(fname, mtype, rseqid);
    if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
      ::apache::thrift::TApplicationException x;
      x.read(iprot_);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
      throw x;
    }
    if (mtype != ::apache::thrift::protocol::T_REPLY) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    if (fname.compare("getRows") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    Hbase_getRows_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 ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getRows failed: unknown result");
  }
  
  void HbaseClient::getRowsWithColumns(std::vector<TRowResult> & _return, const Text& tableName, const std::vector<Text> & rows, const std::vector<Text> & columns, const std::map<Text, Text> & attributes)
  {
    send_getRowsWithColumns(tableName, rows, columns, attributes);
    recv_getRowsWithColumns(_return);
  }
  
  void HbaseClient::send_getRowsWithColumns(const Text& tableName, const std::vector<Text> & rows, const std::vector<Text> & columns, const std::map<Text, Text> & attributes)
  {
    int32_t cseqid = 0;
    oprot_->writeMessageBegin("getRowsWithColumns", ::apache::thrift::protocol::T_CALL, cseqid);
  
    Hbase_getRowsWithColumns_pargs args;
    args.tableName = &tableName;
    args.rows = &rows;
    args.columns = &columns;
    args.attributes = &attributes;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  void HbaseClient::recv_getRowsWithColumns(std::vector<TRowResult> & _return)
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    iprot_->readMessageBegin(fname, mtype, rseqid);
    if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
      ::apache::thrift::TApplicationException x;
      x.read(iprot_);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
      throw x;
    }
    if (mtype != ::apache::thrift::protocol::T_REPLY) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    if (fname.compare("getRowsWithColumns") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    Hbase_getRowsWithColumns_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 ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getRowsWithColumns failed: unknown result");
  }
  
  void HbaseClient::getRowsTs(std::vector<TRowResult> & _return, const Text& tableName, const std::vector<Text> & rows, const int64_t timestamp, const std::map<Text, Text> & attributes)
  {
    send_getRowsTs(tableName, rows, timestamp, attributes);
    recv_getRowsTs(_return);
  }
  
  void HbaseClient::send_getRowsTs(const Text& tableName, const std::vector<Text> & rows, const int64_t timestamp, const std::map<Text, Text> & attributes)
  {
    int32_t cseqid = 0;
    oprot_->writeMessageBegin("getRowsTs", ::apache::thrift::protocol::T_CALL, cseqid);
  
    Hbase_getRowsTs_pargs args;
    args.tableName = &tableName;
    args.rows = &rows;
    args.timestamp = &timestamp;
    args.attributes = &attributes;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  void HbaseClient::recv_getRowsTs(std::vector<TRowResult> & _return)
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    iprot_->readMessageBegin(fname, mtype, rseqid);
    if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
      ::apache::thrift::TApplicationException x;
      x.read(iprot_);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
      throw x;
    }
    if (mtype != ::apache::thrift::protocol::T_REPLY) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    if (fname.compare("getRowsTs") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    Hbase_getRowsTs_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 ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getRowsTs failed: unknown result");
  }
  
  void HbaseClient::getRowsWithColumnsTs(std::vector<TRowResult> & _return, const Text& tableName, const std::vector<Text> & rows, const std::vector<Text> & columns, const int64_t timestamp, const std::map<Text, Text> & attributes)
  {
    send_getRowsWithColumnsTs(tableName, rows, columns, timestamp, attributes);
    recv_getRowsWithColumnsTs(_return);
  }
  
  void HbaseClient::send_getRowsWithColumnsTs(const Text& tableName, const std::vector<Text> & rows, const std::vector<Text> & columns, const int64_t timestamp, const std::map<Text, Text> & attributes)
  {
    int32_t cseqid = 0;
    oprot_->writeMessageBegin("getRowsWithColumnsTs", ::apache::thrift::protocol::T_CALL, cseqid);
  
    Hbase_getRowsWithColumnsTs_pargs args;
    args.tableName = &tableName;
    args.rows = &rows;
    args.columns = &columns;
    args.timestamp = &timestamp;
    args.attributes = &attributes;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  void HbaseClient::recv_getRowsWithColumnsTs(std::vector<TRowResult> & _return)
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    iprot_->readMessageBegin(fname, mtype, rseqid);
    if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
      ::apache::thrift::TApplicationException x;
      x.read(iprot_);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
      throw x;
    }
    if (mtype != ::apache::thrift::protocol::T_REPLY) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    if (fname.compare("getRowsWithColumnsTs") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    Hbase_getRowsWithColumnsTs_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 ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getRowsWithColumnsTs failed: unknown result");
  }
  
  void HbaseClient::mutateRow(const Text& tableName, const Text& row, const std::vector<Mutation> & mutations, const std::map<Text, Text> & attributes)
  {
    send_mutateRow(tableName, row, mutations, attributes);
    recv_mutateRow();
  }
  
  void HbaseClient::send_mutateRow(const Text& tableName, const Text& row, const std::vector<Mutation> & mutations, const std::map<Text, Text> & attributes)
  {
    int32_t cseqid = 0;
    oprot_->writeMessageBegin("mutateRow", ::apache::thrift::protocol::T_CALL, cseqid);
  
    Hbase_mutateRow_pargs args;
    args.tableName = &tableName;
    args.row = &row;
    args.mutations = &mutations;
    args.attributes = &attributes;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  void HbaseClient::recv_mutateRow()
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    iprot_->readMessageBegin(fname, mtype, rseqid);
    if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
      ::apache::thrift::TApplicationException x;
      x.read(iprot_);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
      throw x;
    }
    if (mtype != ::apache::thrift::protocol::T_REPLY) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    if (fname.compare("mutateRow") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    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, const std::map<Text, Text> & attributes)
  {
    send_mutateRowTs(tableName, row, mutations, timestamp, attributes);
    recv_mutateRowTs();
  }
  
  void HbaseClient::send_mutateRowTs(const Text& tableName, const Text& row, const std::vector<Mutation> & mutations, const int64_t timestamp, const std::map<Text, Text> & attributes)
  {
    int32_t cseqid = 0;
    oprot_->writeMessageBegin("mutateRowTs", ::apache::thrift::protocol::T_CALL, cseqid);
  
    Hbase_mutateRowTs_pargs args;
    args.tableName = &tableName;
    args.row = &row;
    args.mutations = &mutations;
    args.timestamp = &timestamp;
    args.attributes = &attributes;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  void HbaseClient::recv_mutateRowTs()
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    iprot_->readMessageBegin(fname, mtype, rseqid);
    if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
      ::apache::thrift::TApplicationException x;
      x.read(iprot_);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
      throw x;
    }
    if (mtype != ::apache::thrift::protocol::T_REPLY) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    if (fname.compare("mutateRowTs") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    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, const std::map<Text, Text> & attributes)
  {
    send_mutateRows(tableName, rowBatches, attributes);
    recv_mutateRows();
  }
  
  void HbaseClient::send_mutateRows(const Text& tableName, const std::vector<BatchMutation> & rowBatches, const std::map<Text, Text> & attributes)
  {
    int32_t cseqid = 0;
    oprot_->writeMessageBegin("mutateRows", ::apache::thrift::protocol::T_CALL, cseqid);
  
    Hbase_mutateRows_pargs args;
    args.tableName = &tableName;
    args.rowBatches = &rowBatches;
    args.attributes = &attributes;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  void HbaseClient::recv_mutateRows()
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    iprot_->readMessageBegin(fname, mtype, rseqid);
    if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
      ::apache::thrift::TApplicationException x;
      x.read(iprot_);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
      throw x;
    }
    if (mtype != ::apache::thrift::protocol::T_REPLY) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    if (fname.compare("mutateRows") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    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, const std::map<Text, Text> & attributes)
  {
    send_mutateRowsTs(tableName, rowBatches, timestamp, attributes);
    recv_mutateRowsTs();
  }
  
  void HbaseClient::send_mutateRowsTs(const Text& tableName, const std::vector<BatchMutation> & rowBatches, const int64_t timestamp, const std::map<Text, Text> & attributes)
  {
    int32_t cseqid = 0;
    oprot_->writeMessageBegin("mutateRowsTs", ::apache::thrift::protocol::T_CALL, cseqid);
  
    Hbase_mutateRowsTs_pargs args;
    args.tableName = &tableName;
    args.rowBatches = &rowBatches;
    args.timestamp = &timestamp;
    args.attributes = &attributes;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  void HbaseClient::recv_mutateRowsTs()
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    iprot_->readMessageBegin(fname, mtype, rseqid);
    if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
      ::apache::thrift::TApplicationException x;
      x.read(iprot_);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
      throw x;
    }
    if (mtype != ::apache::thrift::protocol::T_REPLY) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    if (fname.compare("mutateRowsTs") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    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;
  }
  
  int64_t HbaseClient::atomicIncrement(const Text& tableName, const Text& row, const Text& column, const int64_t value)
  {
    send_atomicIncrement(tableName, row, column, value);
    return recv_atomicIncrement();
  }
  
  void HbaseClient::send_atomicIncrement(const Text& tableName, const Text& row, const Text& column, const int64_t value)
  {
    int32_t cseqid = 0;
    oprot_->writeMessageBegin("atomicIncrement", ::apache::thrift::protocol::T_CALL, cseqid);
  
    Hbase_atomicIncrement_pargs args;
    args.tableName = &tableName;
    args.row = &row;
    args.column = &column;
    args.value = &value;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  int64_t HbaseClient::recv_atomicIncrement()
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    iprot_->readMessageBegin(fname, mtype, rseqid);
    if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
      ::apache::thrift::TApplicationException x;
      x.read(iprot_);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
      throw x;
    }
    if (mtype != ::apache::thrift::protocol::T_REPLY) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    if (fname.compare("atomicIncrement") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    int64_t _return;
    Hbase_atomicIncrement_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;
    }
    if (result.__isset.ia) {
      throw result.ia;
    }
    throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "atomicIncrement failed: unknown result");
  }
  
  void HbaseClient::deleteAll(const Text& tableName, const Text& row, const Text& column, const std::map<Text, Text> & attributes)
  {
    send_deleteAll(tableName, row, column, attributes);
    recv_deleteAll();
  }
  
  void HbaseClient::send_deleteAll(const Text& tableName, const Text& row, const Text& column, const std::map<Text, Text> & attributes)
  {
    int32_t cseqid = 0;
    oprot_->writeMessageBegin("deleteAll", ::apache::thrift::protocol::T_CALL, cseqid);
  
    Hbase_deleteAll_pargs args;
    args.tableName = &tableName;
    args.row = &row;
    args.column = &column;
    args.attributes = &attributes;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  void HbaseClient::recv_deleteAll()
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    iprot_->readMessageBegin(fname, mtype, rseqid);
    if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
      ::apache::thrift::TApplicationException x;
      x.read(iprot_);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
      throw x;
    }
    if (mtype != ::apache::thrift::protocol::T_REPLY) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    if (fname.compare("deleteAll") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    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, const std::map<Text, Text> & attributes)
  {
    send_deleteAllTs(tableName, row, column, timestamp, attributes);
    recv_deleteAllTs();
  }
  
  void HbaseClient::send_deleteAllTs(const Text& tableName, const Text& row, const Text& column, const int64_t timestamp, const std::map<Text, Text> & attributes)
  {
    int32_t cseqid = 0;
    oprot_->writeMessageBegin("deleteAllTs", ::apache::thrift::protocol::T_CALL, cseqid);
  
    Hbase_deleteAllTs_pargs args;
    args.tableName = &tableName;
    args.row = &row;
    args.column = &column;
    args.timestamp = &timestamp;
    args.attributes = &attributes;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  void HbaseClient::recv_deleteAllTs()
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    iprot_->readMessageBegin(fname, mtype, rseqid);
    if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
      ::apache::thrift::TApplicationException x;
      x.read(iprot_);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
      throw x;
    }
    if (mtype != ::apache::thrift::protocol::T_REPLY) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    if (fname.compare("deleteAllTs") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    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, const std::map<Text, Text> & attributes)
  {
    send_deleteAllRow(tableName, row, attributes);
    recv_deleteAllRow();
  }
  
  void HbaseClient::send_deleteAllRow(const Text& tableName, const Text& row, const std::map<Text, Text> & attributes)
  {
    int32_t cseqid = 0;
    oprot_->writeMessageBegin("deleteAllRow", ::apache::thrift::protocol::T_CALL, cseqid);
  
    Hbase_deleteAllRow_pargs args;
    args.tableName = &tableName;
    args.row = &row;
    args.attributes = &attributes;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  void HbaseClient::recv_deleteAllRow()
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    iprot_->readMessageBegin(fname, mtype, rseqid);
    if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
      ::apache::thrift::TApplicationException x;
      x.read(iprot_);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
      throw x;
    }
    if (mtype != ::apache::thrift::protocol::T_REPLY) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    if (fname.compare("deleteAllRow") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    Hbase_deleteAllRow_presult result;
    result.read(iprot_);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
  
    if (result.__isset.io) {
      throw result.io;
    }
    return;
  }
  
  void HbaseClient::increment(const TIncrement& increment)
  {
    send_increment(increment);
    recv_increment();
  }
  
  void HbaseClient::send_increment(const TIncrement& increment)
  {
    int32_t cseqid = 0;
    oprot_->writeMessageBegin("increment", ::apache::thrift::protocol::T_CALL, cseqid);
  
    Hbase_increment_pargs args;
    args.increment = &increment;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  void HbaseClient::recv_increment()
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    iprot_->readMessageBegin(fname, mtype, rseqid);
    if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
      ::apache::thrift::TApplicationException x;
      x.read(iprot_);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
      throw x;
    }
    if (mtype != ::apache::thrift::protocol::T_REPLY) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    if (fname.compare("increment") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    Hbase_increment_presult result;
    result.read(iprot_);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
  
    if (result.__isset.io) {
      throw result.io;
    }
    return;
  }
  
  void HbaseClient::incrementRows(const std::vector<TIncrement> & increments)
  {
    send_incrementRows(increments);
    recv_incrementRows();
  }
  
  void HbaseClient::send_incrementRows(const std::vector<TIncrement> & increments)
  {
    int32_t cseqid = 0;
    oprot_->writeMessageBegin("incrementRows", ::apache::thrift::protocol::T_CALL, cseqid);
  
    Hbase_incrementRows_pargs args;
    args.increments = &increments;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  void HbaseClient::recv_incrementRows()
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    iprot_->readMessageBegin(fname, mtype, rseqid);
    if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
      ::apache::thrift::TApplicationException x;
      x.read(iprot_);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
      throw x;
    }
    if (mtype != ::apache::thrift::protocol::T_REPLY) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    if (fname.compare("incrementRows") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    Hbase_incrementRows_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, const std::map<Text, Text> & attributes)
  {
    send_deleteAllRowTs(tableName, row, timestamp, attributes);
    recv_deleteAllRowTs();
  }
  
  void HbaseClient::send_deleteAllRowTs(const Text& tableName, const Text& row, const int64_t timestamp, const std::map<Text, Text> & attributes)
  {
    int32_t cseqid = 0;
    oprot_->writeMessageBegin("deleteAllRowTs", ::apache::thrift::protocol::T_CALL, cseqid);
  
    Hbase_deleteAllRowTs_pargs args;
    args.tableName = &tableName;
    args.row = &row;
    args.timestamp = &timestamp;
    args.attributes = &attributes;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  void HbaseClient::recv_deleteAllRowTs()
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    iprot_->readMessageBegin(fname, mtype, rseqid);
    if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
      ::apache::thrift::TApplicationException x;
      x.read(iprot_);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
      throw x;
    }
    if (mtype != ::apache::thrift::protocol::T_REPLY) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    if (fname.compare("deleteAllRowTs") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    Hbase_deleteAllRowTs_presult result;
    result.read(iprot_);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
  
    if (result.__isset.io) {
      throw result.io;
    }
    return;
  }
  
  ScannerID HbaseClient::scannerOpenWithScan(const Text& tableName, const TScan& scan, const std::map<Text, Text> & attributes)
  {
    send_scannerOpenWithScan(tableName, scan, attributes);
    return recv_scannerOpenWithScan();
  }
  
  void HbaseClient::send_scannerOpenWithScan(const Text& tableName, const TScan& scan, const std::map<Text, Text> & attributes)
  {
    int32_t cseqid = 0;
    oprot_->writeMessageBegin("scannerOpenWithScan", ::apache::thrift::protocol::T_CALL, cseqid);
  
    Hbase_scannerOpenWithScan_pargs args;
    args.tableName = &tableName;
    args.scan = &scan;
    args.attributes = &attributes;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  ScannerID HbaseClient::recv_scannerOpenWithScan()
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    iprot_->readMessageBegin(fname, mtype, rseqid);
    if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
      ::apache::thrift::TApplicationException x;
      x.read(iprot_);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
      throw x;
    }
    if (mtype != ::apache::thrift::protocol::T_REPLY) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    if (fname.compare("scannerOpenWithScan") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    ScannerID _return;
    Hbase_scannerOpenWithScan_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 ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "scannerOpenWithScan failed: unknown result");
  }
  
  ScannerID HbaseClient::scannerOpen(const Text& tableName, const Text& startRow, const std::vector<Text> & columns, const std::map<Text, Text> & attributes)
  {
    send_scannerOpen(tableName, startRow, columns, attributes);
    return recv_scannerOpen();
  }
  
  void HbaseClient::send_scannerOpen(const Text& tableName, const Text& startRow, const std::vector<Text> & columns, const std::map<Text, Text> & attributes)
  {
    int32_t cseqid = 0;
    oprot_->writeMessageBegin("scannerOpen", ::apache::thrift::protocol::T_CALL, cseqid);
  
    Hbase_scannerOpen_pargs args;
    args.tableName = &tableName;
    args.startRow = &startRow;
    args.columns = &columns;
    args.attributes = &attributes;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  ScannerID HbaseClient::recv_scannerOpen()
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    iprot_->readMessageBegin(fname, mtype, rseqid);
    if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
      ::apache::thrift::TApplicationException x;
      x.read(iprot_);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
      throw x;
    }
    if (mtype != ::apache::thrift::protocol::T_REPLY) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    if (fname.compare("scannerOpen") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    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 ::apache::thrift::TApplicationException(::apache::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, const std::map<Text, Text> & attributes)
  {
    send_scannerOpenWithStop(tableName, startRow, stopRow, columns, attributes);
    return recv_scannerOpenWithStop();
  }
  
  void HbaseClient::send_scannerOpenWithStop(const Text& tableName, const Text& startRow, const Text& stopRow, const std::vector<Text> & columns, const std::map<Text, Text> & attributes)
  {
    int32_t cseqid = 0;
    oprot_->writeMessageBegin("scannerOpenWithStop", ::apache::thrift::protocol::T_CALL, cseqid);
  
    Hbase_scannerOpenWithStop_pargs args;
    args.tableName = &tableName;
    args.startRow = &startRow;
    args.stopRow = &stopRow;
    args.columns = &columns;
    args.attributes = &attributes;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  ScannerID HbaseClient::recv_scannerOpenWithStop()
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    iprot_->readMessageBegin(fname, mtype, rseqid);
    if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
      ::apache::thrift::TApplicationException x;
      x.read(iprot_);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
      throw x;
    }
    if (mtype != ::apache::thrift::protocol::T_REPLY) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    if (fname.compare("scannerOpenWithStop") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    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 ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "scannerOpenWithStop failed: unknown result");
  }
  
  ScannerID HbaseClient::scannerOpenWithPrefix(const Text& tableName, const Text& startAndPrefix, const std::vector<Text> & columns, const std::map<Text, Text> & attributes)
  {
    send_scannerOpenWithPrefix(tableName, startAndPrefix, columns, attributes);
    return recv_scannerOpenWithPrefix();
  }
  
  void HbaseClient::send_scannerOpenWithPrefix(const Text& tableName, const Text& startAndPrefix, const std::vector<Text> & columns, const std::map<Text, Text> & attributes)
  {
    int32_t cseqid = 0;
    oprot_->writeMessageBegin("scannerOpenWithPrefix", ::apache::thrift::protocol::T_CALL, cseqid);
  
    Hbase_scannerOpenWithPrefix_pargs args;
    args.tableName = &tableName;
    args.startAndPrefix = &startAndPrefix;
    args.columns = &columns;
    args.attributes = &attributes;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  ScannerID HbaseClient::recv_scannerOpenWithPrefix()
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    iprot_->readMessageBegin(fname, mtype, rseqid);
    if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
      ::apache::thrift::TApplicationException x;
      x.read(iprot_);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
      throw x;
    }
    if (mtype != ::apache::thrift::protocol::T_REPLY) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    if (fname.compare("scannerOpenWithPrefix") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    ScannerID _return;
    Hbase_scannerOpenWithPrefix_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 ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "scannerOpenWithPrefix failed: unknown result");
  }
  
  ScannerID HbaseClient::scannerOpenTs(const Text& tableName, const Text& startRow, const std::vector<Text> & columns, const int64_t timestamp, const std::map<Text, Text> & attributes)
  {
    send_scannerOpenTs(tableName, startRow, columns, timestamp, attributes);
    return recv_scannerOpenTs();
  }
  
  void HbaseClient::send_scannerOpenTs(const Text& tableName, const Text& startRow, const std::vector<Text> & columns, const int64_t timestamp, const std::map<Text, Text> & attributes)
  {
    int32_t cseqid = 0;
    oprot_->writeMessageBegin("scannerOpenTs", ::apache::thrift::protocol::T_CALL, cseqid);
  
    Hbase_scannerOpenTs_pargs args;
    args.tableName = &tableName;
    args.startRow = &startRow;
    args.columns = &columns;
    args.timestamp = &timestamp;
    args.attributes = &attributes;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  ScannerID HbaseClient::recv_scannerOpenTs()
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    iprot_->readMessageBegin(fname, mtype, rseqid);
    if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
      ::apache::thrift::TApplicationException x;
      x.read(iprot_);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
      throw x;
    }
    if (mtype != ::apache::thrift::protocol::T_REPLY) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    if (fname.compare("scannerOpenTs") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    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 ::apache::thrift::TApplicationException(::apache::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, const std::map<Text, Text> & attributes)
  {
    send_scannerOpenWithStopTs(tableName, startRow, stopRow, columns, timestamp, attributes);
    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, const std::map<Text, Text> & attributes)
  {
    int32_t cseqid = 0;
    oprot_->writeMessageBegin("scannerOpenWithStopTs", ::apache::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.attributes = &attributes;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  ScannerID HbaseClient::recv_scannerOpenWithStopTs()
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    iprot_->readMessageBegin(fname, mtype, rseqid);
    if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
      ::apache::thrift::TApplicationException x;
      x.read(iprot_);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
      throw x;
    }
    if (mtype != ::apache::thrift::protocol::T_REPLY) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    if (fname.compare("scannerOpenWithStopTs") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    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 ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "scannerOpenWithStopTs failed: unknown result");
  }
  
  void HbaseClient::scannerGet(std::vector<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", ::apache::thrift::protocol::T_CALL, cseqid);
  
    Hbase_scannerGet_pargs args;
    args.id = &id;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  void HbaseClient::recv_scannerGet(std::vector<TRowResult> & _return)
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    iprot_->readMessageBegin(fname, mtype, rseqid);
    if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
      ::apache::thrift::TApplicationException x;
      x.read(iprot_);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
      throw x;
    }
    if (mtype != ::apache::thrift::protocol::T_REPLY) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    if (fname.compare("scannerGet") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    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;
    }
    throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "scannerGet failed: unknown result");
  }
  
  void HbaseClient::scannerGetList(std::vector<TRowResult> & _return, const ScannerID id, const int32_t nbRows)
  {
    send_scannerGetList(id, nbRows);
    recv_scannerGetList(_return);
  }
  
  void HbaseClient::send_scannerGetList(const ScannerID id, const int32_t nbRows)
  {
    int32_t cseqid = 0;
    oprot_->writeMessageBegin("scannerGetList", ::apache::thrift::protocol::T_CALL, cseqid);
  
    Hbase_scannerGetList_pargs args;
    args.id = &id;
    args.nbRows = &nbRows;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  void HbaseClient::recv_scannerGetList(std::vector<TRowResult> & _return)
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    iprot_->readMessageBegin(fname, mtype, rseqid);
    if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
      ::apache::thrift::TApplicationException x;
      x.read(iprot_);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
      throw x;
    }
    if (mtype != ::apache::thrift::protocol::T_REPLY) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    if (fname.compare("scannerGetList") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    Hbase_scannerGetList_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;
    }
    throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "scannerGetList 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", ::apache::thrift::protocol::T_CALL, cseqid);
  
    Hbase_scannerClose_pargs args;
    args.id = &id;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  void HbaseClient::recv_scannerClose()
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    iprot_->readMessageBegin(fname, mtype, rseqid);
    if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
      ::apache::thrift::TApplicationException x;
      x.read(iprot_);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
      throw x;
    }
    if (mtype != ::apache::thrift::protocol::T_REPLY) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    if (fname.compare("scannerClose") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    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;
  }
  
  void HbaseClient::getRowOrBefore(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& family)
  {
    send_getRowOrBefore(tableName, row, family);
    recv_getRowOrBefore(_return);
  }
  
  void HbaseClient::send_getRowOrBefore(const Text& tableName, const Text& row, const Text& family)
  {
    int32_t cseqid = 0;
    oprot_->writeMessageBegin("getRowOrBefore", ::apache::thrift::protocol::T_CALL, cseqid);
  
    Hbase_getRowOrBefore_pargs args;
    args.tableName = &tableName;
    args.row = &row;
    args.family = &family;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  void HbaseClient::recv_getRowOrBefore(std::vector<TCell> & _return)
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    iprot_->readMessageBegin(fname, mtype, rseqid);
    if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
      ::apache::thrift::TApplicationException x;
      x.read(iprot_);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
      throw x;
    }
    if (mtype != ::apache::thrift::protocol::T_REPLY) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    if (fname.compare("getRowOrBefore") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    Hbase_getRowOrBefore_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 ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getRowOrBefore failed: unknown result");
  }
  
  void HbaseClient::getRegionInfo(TRegionInfo& _return, const Text& row)
  {
    send_getRegionInfo(row);
    recv_getRegionInfo(_return);
  }
  
  void HbaseClient::send_getRegionInfo(const Text& row)
  {
    int32_t cseqid = 0;
    oprot_->writeMessageBegin("getRegionInfo", ::apache::thrift::protocol::T_CALL, cseqid);
  
    Hbase_getRegionInfo_pargs args;
    args.row = &row;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  void HbaseClient::recv_getRegionInfo(TRegionInfo& _return)
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    iprot_->readMessageBegin(fname, mtype, rseqid);
    if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
      ::apache::thrift::TApplicationException x;
      x.read(iprot_);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
      throw x;
    }
    if (mtype != ::apache::thrift::protocol::T_REPLY) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    if (fname.compare("getRegionInfo") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    Hbase_getRegionInfo_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 ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getRegionInfo failed: unknown result");
  }
  
  bool HbaseProcessor::dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext) {
    ProcessMap::iterator pfn;
    pfn = processMap_.find(fname);
    if (pfn == processMap_.end()) {
      iprot->skip(::apache::thrift::protocol::T_STRUCT);
      iprot->readMessageEnd();
      iprot->getTransport()->readEnd();
      ::apache::thrift::TApplicationException x(::apache::thrift::TApplicationException::UNKNOWN_METHOD, "Invalid method name: '"+fname+"'");
      oprot->writeMessageBegin(fname, ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return true;
    }
    (this->*(pfn->second))(seqid, iprot, oprot, callContext);
    return true;
  }
  
  void HbaseProcessor::process_enableTable(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = NULL;
    if (this->eventHandler_.get() != NULL) {
      ctx = this->eventHandler_->getContext("Hbase.enableTable", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.enableTable");
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preRead(ctx, "Hbase.enableTable");
    }
  
    Hbase_enableTable_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postRead(ctx, "Hbase.enableTable", bytes);
    }
  
    Hbase_enableTable_result result;
    try {
      iface_->enableTable(args.tableName);
    } catch (IOError &io) {
      result.io = io;
      result.__isset.io = true;
    } catch (const std::exception& e) {
      if (this->eventHandler_.get() != NULL) {
        this->eventHandler_->handlerError(ctx, "Hbase.enableTable");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("enableTable", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preWrite(ctx, "Hbase.enableTable");
    }
  
    oprot->writeMessageBegin("enableTable", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postWrite(ctx, "Hbase.enableTable", bytes);
    }
  }
  
  void HbaseProcessor::process_disableTable(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = NULL;
    if (this->eventHandler_.get() != NULL) {
      ctx = this->eventHandler_->getContext("Hbase.disableTable", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.disableTable");
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preRead(ctx, "Hbase.disableTable");
    }
  
    Hbase_disableTable_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postRead(ctx, "Hbase.disableTable", bytes);
    }
  
    Hbase_disableTable_result result;
    try {
      iface_->disableTable(args.tableName);
    } catch (IOError &io) {
      result.io = io;
      result.__isset.io = true;
    } catch (const std::exception& e) {
      if (this->eventHandler_.get() != NULL) {
        this->eventHandler_->handlerError(ctx, "Hbase.disableTable");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("disableTable", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preWrite(ctx, "Hbase.disableTable");
    }
  
    oprot->writeMessageBegin("disableTable", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postWrite(ctx, "Hbase.disableTable", bytes);
    }
  }
  
  void HbaseProcessor::process_isTableEnabled(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = NULL;
    if (this->eventHandler_.get() != NULL) {
      ctx = this->eventHandler_->getContext("Hbase.isTableEnabled", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.isTableEnabled");
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preRead(ctx, "Hbase.isTableEnabled");
    }
  
    Hbase_isTableEnabled_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postRead(ctx, "Hbase.isTableEnabled", bytes);
    }
  
    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) {
      if (this->eventHandler_.get() != NULL) {
        this->eventHandler_->handlerError(ctx, "Hbase.isTableEnabled");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("isTableEnabled", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preWrite(ctx, "Hbase.isTableEnabled");
    }
  
    oprot->writeMessageBegin("isTableEnabled", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postWrite(ctx, "Hbase.isTableEnabled", bytes);
    }
  }
  
  void HbaseProcessor::process_compact(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = NULL;
    if (this->eventHandler_.get() != NULL) {
      ctx = this->eventHandler_->getContext("Hbase.compact", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.compact");
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preRead(ctx, "Hbase.compact");
    }
  
    Hbase_compact_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postRead(ctx, "Hbase.compact", bytes);
    }
  
    Hbase_compact_result result;
    try {
      iface_->compact(args.tableNameOrRegionName);
    } catch (IOError &io) {
      result.io = io;
      result.__isset.io = true;
    } catch (const std::exception& e) {
      if (this->eventHandler_.get() != NULL) {
        this->eventHandler_->handlerError(ctx, "Hbase.compact");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("compact", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preWrite(ctx, "Hbase.compact");
    }
  
    oprot->writeMessageBegin("compact", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postWrite(ctx, "Hbase.compact", bytes);
    }
  }
  
  void HbaseProcessor::process_majorCompact(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = NULL;
    if (this->eventHandler_.get() != NULL) {
      ctx = this->eventHandler_->getContext("Hbase.majorCompact", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.majorCompact");
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preRead(ctx, "Hbase.majorCompact");
    }
  
    Hbase_majorCompact_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postRead(ctx, "Hbase.majorCompact", bytes);
    }
  
    Hbase_majorCompact_result result;
    try {
      iface_->majorCompact(args.tableNameOrRegionName);
    } catch (IOError &io) {
      result.io = io;
      result.__isset.io = true;
    } catch (const std::exception& e) {
      if (this->eventHandler_.get() != NULL) {
        this->eventHandler_->handlerError(ctx, "Hbase.majorCompact");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("majorCompact", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preWrite(ctx, "Hbase.majorCompact");
    }
  
    oprot->writeMessageBegin("majorCompact", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postWrite(ctx, "Hbase.majorCompact", bytes);
    }
  }
  
  void HbaseProcessor::process_getTableNames(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = NULL;
    if (this->eventHandler_.get() != NULL) {
      ctx = this->eventHandler_->getContext("Hbase.getTableNames", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.getTableNames");
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preRead(ctx, "Hbase.getTableNames");
    }
  
    Hbase_getTableNames_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postRead(ctx, "Hbase.getTableNames", bytes);
    }
  
    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) {
      if (this->eventHandler_.get() != NULL) {
        this->eventHandler_->handlerError(ctx, "Hbase.getTableNames");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("getTableNames", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preWrite(ctx, "Hbase.getTableNames");
    }
  
    oprot->writeMessageBegin("getTableNames", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postWrite(ctx, "Hbase.getTableNames", bytes);
    }
  }
  
  void HbaseProcessor::process_getColumnDescriptors(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = NULL;
    if (this->eventHandler_.get() != NULL) {
      ctx = this->eventHandler_->getContext("Hbase.getColumnDescriptors", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.getColumnDescriptors");
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preRead(ctx, "Hbase.getColumnDescriptors");
    }
  
    Hbase_getColumnDescriptors_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postRead(ctx, "Hbase.getColumnDescriptors", bytes);
    }
  
    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) {
      if (this->eventHandler_.get() != NULL) {
        this->eventHandler_->handlerError(ctx, "Hbase.getColumnDescriptors");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("getColumnDescriptors", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preWrite(ctx, "Hbase.getColumnDescriptors");
    }
  
    oprot->writeMessageBegin("getColumnDescriptors", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postWrite(ctx, "Hbase.getColumnDescriptors", bytes);
    }
  }
  
  void HbaseProcessor::process_getTableRegions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = NULL;
    if (this->eventHandler_.get() != NULL) {
      ctx = this->eventHandler_->getContext("Hbase.getTableRegions", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.getTableRegions");
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preRead(ctx, "Hbase.getTableRegions");
    }
  
    Hbase_getTableRegions_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postRead(ctx, "Hbase.getTableRegions", bytes);
    }
  
    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) {
      if (this->eventHandler_.get() != NULL) {
        this->eventHandler_->handlerError(ctx, "Hbase.getTableRegions");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("getTableRegions", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preWrite(ctx, "Hbase.getTableRegions");
    }
  
    oprot->writeMessageBegin("getTableRegions", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postWrite(ctx, "Hbase.getTableRegions", bytes);
    }
  }
  
  void HbaseProcessor::process_createTable(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = NULL;
    if (this->eventHandler_.get() != NULL) {
      ctx = this->eventHandler_->getContext("Hbase.createTable", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.createTable");
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preRead(ctx, "Hbase.createTable");
    }
  
    Hbase_createTable_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postRead(ctx, "Hbase.createTable", bytes);
    }
  
    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) {
      if (this->eventHandler_.get() != NULL) {
        this->eventHandler_->handlerError(ctx, "Hbase.createTable");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("createTable", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preWrite(ctx, "Hbase.createTable");
    }
  
    oprot->writeMessageBegin("createTable", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postWrite(ctx, "Hbase.createTable", bytes);
    }
  }
  
  void HbaseProcessor::process_deleteTable(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = NULL;
    if (this->eventHandler_.get() != NULL) {
      ctx = this->eventHandler_->getContext("Hbase.deleteTable", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.deleteTable");
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preRead(ctx, "Hbase.deleteTable");
    }
  
    Hbase_deleteTable_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postRead(ctx, "Hbase.deleteTable", bytes);
    }
  
    Hbase_deleteTable_result result;
    try {
      iface_->deleteTable(args.tableName);
    } catch (IOError &io) {
      result.io = io;
      result.__isset.io = true;
    } catch (const std::exception& e) {
      if (this->eventHandler_.get() != NULL) {
        this->eventHandler_->handlerError(ctx, "Hbase.deleteTable");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("deleteTable", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preWrite(ctx, "Hbase.deleteTable");
    }
  
    oprot->writeMessageBegin("deleteTable", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postWrite(ctx, "Hbase.deleteTable", bytes);
    }
  }
  
  void HbaseProcessor::process_get(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = NULL;
    if (this->eventHandler_.get() != NULL) {
      ctx = this->eventHandler_->getContext("Hbase.get", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.get");
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preRead(ctx, "Hbase.get");
    }
  
    Hbase_get_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postRead(ctx, "Hbase.get", bytes);
    }
  
    Hbase_get_result result;
    try {
      iface_->get(result.success, args.tableName, args.row, args.column, args.attributes);
      result.__isset.success = true;
    } catch (IOError &io) {
      result.io = io;
      result.__isset.io = true;
    } catch (const std::exception& e) {
      if (this->eventHandler_.get() != NULL) {
        this->eventHandler_->handlerError(ctx, "Hbase.get");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("get", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preWrite(ctx, "Hbase.get");
    }
  
    oprot->writeMessageBegin("get", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postWrite(ctx, "Hbase.get", bytes);
    }
  }
  
  void HbaseProcessor::process_getVer(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = NULL;
    if (this->eventHandler_.get() != NULL) {
      ctx = this->eventHandler_->getContext("Hbase.getVer", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.getVer");
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preRead(ctx, "Hbase.getVer");
    }
  
    Hbase_getVer_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postRead(ctx, "Hbase.getVer", bytes);
    }
  
    Hbase_getVer_result result;
    try {
      iface_->getVer(result.success, args.tableName, args.row, args.column, args.numVersions, args.attributes);
      result.__isset.success = true;
    } catch (IOError &io) {
      result.io = io;
      result.__isset.io = true;
    } catch (const std::exception& e) {
      if (this->eventHandler_.get() != NULL) {
        this->eventHandler_->handlerError(ctx, "Hbase.getVer");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("getVer", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preWrite(ctx, "Hbase.getVer");
    }
  
    oprot->writeMessageBegin("getVer", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postWrite(ctx, "Hbase.getVer", bytes);
    }
  }
  
  void HbaseProcessor::process_getVerTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = NULL;
    if (this->eventHandler_.get() != NULL) {
      ctx = this->eventHandler_->getContext("Hbase.getVerTs", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.getVerTs");
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preRead(ctx, "Hbase.getVerTs");
    }
  
    Hbase_getVerTs_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postRead(ctx, "Hbase.getVerTs", bytes);
    }
  
    Hbase_getVerTs_result result;
    try {
      iface_->getVerTs(result.success, args.tableName, args.row, args.column, args.timestamp, args.numVersions, args.attributes);
      result.__isset.success = true;
    } catch (IOError &io) {
      result.io = io;
      result.__isset.io = true;
    } catch (const std::exception& e) {
      if (this->eventHandler_.get() != NULL) {
        this->eventHandler_->handlerError(ctx, "Hbase.getVerTs");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("getVerTs", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preWrite(ctx, "Hbase.getVerTs");
    }
  
    oprot->writeMessageBegin("getVerTs", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postWrite(ctx, "Hbase.getVerTs", bytes);
    }
  }
  
  void HbaseProcessor::process_getRow(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = NULL;
    if (this->eventHandler_.get() != NULL) {
      ctx = this->eventHandler_->getContext("Hbase.getRow", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.getRow");
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preRead(ctx, "Hbase.getRow");
    }
  
    Hbase_getRow_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postRead(ctx, "Hbase.getRow", bytes);
    }
  
    Hbase_getRow_result result;
    try {
      iface_->getRow(result.success, args.tableName, args.row, args.attributes);
      result.__isset.success = true;
    } catch (IOError &io) {
      result.io = io;
      result.__isset.io = true;
    } catch (const std::exception& e) {
      if (this->eventHandler_.get() != NULL) {
        this->eventHandler_->handlerError(ctx, "Hbase.getRow");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("getRow", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preWrite(ctx, "Hbase.getRow");
    }
  
    oprot->writeMessageBegin("getRow", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postWrite(ctx, "Hbase.getRow", bytes);
    }
  }
  
  void HbaseProcessor::process_getRowWithColumns(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = NULL;
    if (this->eventHandler_.get() != NULL) {
      ctx = this->eventHandler_->getContext("Hbase.getRowWithColumns", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.getRowWithColumns");
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preRead(ctx, "Hbase.getRowWithColumns");
    }
  
    Hbase_getRowWithColumns_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postRead(ctx, "Hbase.getRowWithColumns", bytes);
    }
  
    Hbase_getRowWithColumns_result result;
    try {
      iface_->getRowWithColumns(result.success, args.tableName, args.row, args.columns, args.attributes);
      result.__isset.success = true;
    } catch (IOError &io) {
      result.io = io;
      result.__isset.io = true;
    } catch (const std::exception& e) {
      if (this->eventHandler_.get() != NULL) {
        this->eventHandler_->handlerError(ctx, "Hbase.getRowWithColumns");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("getRowWithColumns", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preWrite(ctx, "Hbase.getRowWithColumns");
    }
  
    oprot->writeMessageBegin("getRowWithColumns", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postWrite(ctx, "Hbase.getRowWithColumns", bytes);
    }
  }
  
  void HbaseProcessor::process_getRowTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = NULL;
    if (this->eventHandler_.get() != NULL) {
      ctx = this->eventHandler_->getContext("Hbase.getRowTs", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.getRowTs");
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preRead(ctx, "Hbase.getRowTs");
    }
  
    Hbase_getRowTs_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postRead(ctx, "Hbase.getRowTs", bytes);
    }
  
    Hbase_getRowTs_result result;
    try {
      iface_->getRowTs(result.success, args.tableName, args.row, args.timestamp, args.attributes);
      result.__isset.success = true;
    } catch (IOError &io) {
      result.io = io;
      result.__isset.io = true;
    } catch (const std::exception& e) {
      if (this->eventHandler_.get() != NULL) {
        this->eventHandler_->handlerError(ctx, "Hbase.getRowTs");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("getRowTs", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preWrite(ctx, "Hbase.getRowTs");
    }
  
    oprot->writeMessageBegin("getRowTs", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postWrite(ctx, "Hbase.getRowTs", bytes);
    }
  }
  
  void HbaseProcessor::process_getRowWithColumnsTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = NULL;
    if (this->eventHandler_.get() != NULL) {
      ctx = this->eventHandler_->getContext("Hbase.getRowWithColumnsTs", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.getRowWithColumnsTs");
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preRead(ctx, "Hbase.getRowWithColumnsTs");
    }
  
    Hbase_getRowWithColumnsTs_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postRead(ctx, "Hbase.getRowWithColumnsTs", bytes);
    }
  
    Hbase_getRowWithColumnsTs_result result;
    try {
      iface_->getRowWithColumnsTs(result.success, args.tableName, args.row, args.columns, args.timestamp, args.attributes);
      result.__isset.success = true;
    } catch (IOError &io) {
      result.io = io;
      result.__isset.io = true;
    } catch (const std::exception& e) {
      if (this->eventHandler_.get() != NULL) {
        this->eventHandler_->handlerError(ctx, "Hbase.getRowWithColumnsTs");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("getRowWithColumnsTs", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preWrite(ctx, "Hbase.getRowWithColumnsTs");
    }
  
    oprot->writeMessageBegin("getRowWithColumnsTs", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postWrite(ctx, "Hbase.getRowWithColumnsTs", bytes);
    }
  }
  
  void HbaseProcessor::process_getRows(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = NULL;
    if (this->eventHandler_.get() != NULL) {
      ctx = this->eventHandler_->getContext("Hbase.getRows", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.getRows");
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preRead(ctx, "Hbase.getRows");
    }
  
    Hbase_getRows_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postRead(ctx, "Hbase.getRows", bytes);
    }
  
    Hbase_getRows_result result;
    try {
      iface_->getRows(result.success, args.tableName, args.rows, args.attributes);
      result.__isset.success = true;
    } catch (IOError &io) {
      result.io = io;
      result.__isset.io = true;
    } catch (const std::exception& e) {
      if (this->eventHandler_.get() != NULL) {
        this->eventHandler_->handlerError(ctx, "Hbase.getRows");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("getRows", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preWrite(ctx, "Hbase.getRows");
    }
  
    oprot->writeMessageBegin("getRows", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postWrite(ctx, "Hbase.getRows", bytes);
    }
  }
  
  void HbaseProcessor::process_getRowsWithColumns(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = NULL;
    if (this->eventHandler_.get() != NULL) {
      ctx = this->eventHandler_->getContext("Hbase.getRowsWithColumns", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.getRowsWithColumns");
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preRead(ctx, "Hbase.getRowsWithColumns");
    }
  
    Hbase_getRowsWithColumns_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postRead(ctx, "Hbase.getRowsWithColumns", bytes);
    }
  
    Hbase_getRowsWithColumns_result result;
    try {
      iface_->getRowsWithColumns(result.success, args.tableName, args.rows, args.columns, args.attributes);
      result.__isset.success = true;
    } catch (IOError &io) {
      result.io = io;
      result.__isset.io = true;
    } catch (const std::exception& e) {
      if (this->eventHandler_.get() != NULL) {
        this->eventHandler_->handlerError(ctx, "Hbase.getRowsWithColumns");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("getRowsWithColumns", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preWrite(ctx, "Hbase.getRowsWithColumns");
    }
  
    oprot->writeMessageBegin("getRowsWithColumns", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postWrite(ctx, "Hbase.getRowsWithColumns", bytes);
    }
  }
  
  void HbaseProcessor::process_getRowsTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = NULL;
    if (this->eventHandler_.get() != NULL) {
      ctx = this->eventHandler_->getContext("Hbase.getRowsTs", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.getRowsTs");
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preRead(ctx, "Hbase.getRowsTs");
    }
  
    Hbase_getRowsTs_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postRead(ctx, "Hbase.getRowsTs", bytes);
    }
  
    Hbase_getRowsTs_result result;
    try {
      iface_->getRowsTs(result.success, args.tableName, args.rows, args.timestamp, args.attributes);
      result.__isset.success = true;
    } catch (IOError &io) {
      result.io = io;
      result.__isset.io = true;
    } catch (const std::exception& e) {
      if (this->eventHandler_.get() != NULL) {
        this->eventHandler_->handlerError(ctx, "Hbase.getRowsTs");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("getRowsTs", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preWrite(ctx, "Hbase.getRowsTs");
    }
  
    oprot->writeMessageBegin("getRowsTs", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postWrite(ctx, "Hbase.getRowsTs", bytes);
    }
  }
  
  void HbaseProcessor::process_getRowsWithColumnsTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = NULL;
    if (this->eventHandler_.get() != NULL) {
      ctx = this->eventHandler_->getContext("Hbase.getRowsWithColumnsTs", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.getRowsWithColumnsTs");
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preRead(ctx, "Hbase.getRowsWithColumnsTs");
    }
  
    Hbase_getRowsWithColumnsTs_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postRead(ctx, "Hbase.getRowsWithColumnsTs", bytes);
    }
  
    Hbase_getRowsWithColumnsTs_result result;
    try {
      iface_->getRowsWithColumnsTs(result.success, args.tableName, args.rows, args.columns, args.timestamp, args.attributes);
      result.__isset.success = true;
    } catch (IOError &io) {
      result.io = io;
      result.__isset.io = true;
    } catch (const std::exception& e) {
      if (this->eventHandler_.get() != NULL) {
        this->eventHandler_->handlerError(ctx, "Hbase.getRowsWithColumnsTs");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("getRowsWithColumnsTs", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preWrite(ctx, "Hbase.getRowsWithColumnsTs");
    }
  
    oprot->writeMessageBegin("getRowsWithColumnsTs", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postWrite(ctx, "Hbase.getRowsWithColumnsTs", bytes);
    }
  }
  
  void HbaseProcessor::process_mutateRow(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = NULL;
    if (this->eventHandler_.get() != NULL) {
      ctx = this->eventHandler_->getContext("Hbase.mutateRow", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.mutateRow");
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preRead(ctx, "Hbase.mutateRow");
    }
  
    Hbase_mutateRow_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postRead(ctx, "Hbase.mutateRow", bytes);
    }
  
    Hbase_mutateRow_result result;
    try {
      iface_->mutateRow(args.tableName, args.row, args.mutations, args.attributes);
    } 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) {
      if (this->eventHandler_.get() != NULL) {
        this->eventHandler_->handlerError(ctx, "Hbase.mutateRow");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("mutateRow", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preWrite(ctx, "Hbase.mutateRow");
    }
  
    oprot->writeMessageBegin("mutateRow", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postWrite(ctx, "Hbase.mutateRow", bytes);
    }
  }
  
  void HbaseProcessor::process_mutateRowTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = NULL;
    if (this->eventHandler_.get() != NULL) {
      ctx = this->eventHandler_->getContext("Hbase.mutateRowTs", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.mutateRowTs");
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preRead(ctx, "Hbase.mutateRowTs");
    }
  
    Hbase_mutateRowTs_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postRead(ctx, "Hbase.mutateRowTs", bytes);
    }
  
    Hbase_mutateRowTs_result result;
    try {
      iface_->mutateRowTs(args.tableName, args.row, args.mutations, args.timestamp, args.attributes);
    } 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) {
      if (this->eventHandler_.get() != NULL) {
        this->eventHandler_->handlerError(ctx, "Hbase.mutateRowTs");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("mutateRowTs", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preWrite(ctx, "Hbase.mutateRowTs");
    }
  
    oprot->writeMessageBegin("mutateRowTs", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postWrite(ctx, "Hbase.mutateRowTs", bytes);
    }
  }
  
  void HbaseProcessor::process_mutateRows(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = NULL;
    if (this->eventHandler_.get() != NULL) {
      ctx = this->eventHandler_->getContext("Hbase.mutateRows", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.mutateRows");
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preRead(ctx, "Hbase.mutateRows");
    }
  
    Hbase_mutateRows_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postRead(ctx, "Hbase.mutateRows", bytes);
    }
  
    Hbase_mutateRows_result result;
    try {
      iface_->mutateRows(args.tableName, args.rowBatches, args.attributes);
    } 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) {
      if (this->eventHandler_.get() != NULL) {
        this->eventHandler_->handlerError(ctx, "Hbase.mutateRows");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("mutateRows", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preWrite(ctx, "Hbase.mutateRows");
    }
  
    oprot->writeMessageBegin("mutateRows", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postWrite(ctx, "Hbase.mutateRows", bytes);
    }
  }
  
  void HbaseProcessor::process_mutateRowsTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = NULL;
    if (this->eventHandler_.get() != NULL) {
      ctx = this->eventHandler_->getContext("Hbase.mutateRowsTs", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.mutateRowsTs");
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preRead(ctx, "Hbase.mutateRowsTs");
    }
  
    Hbase_mutateRowsTs_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postRead(ctx, "Hbase.mutateRowsTs", bytes);
    }
  
    Hbase_mutateRowsTs_result result;
    try {
      iface_->mutateRowsTs(args.tableName, args.rowBatches, args.timestamp, args.attributes);
    } 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) {
      if (this->eventHandler_.get() != NULL) {
        this->eventHandler_->handlerError(ctx, "Hbase.mutateRowsTs");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("mutateRowsTs", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preWrite(ctx, "Hbase.mutateRowsTs");
    }
  
    oprot->writeMessageBegin("mutateRowsTs", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postWrite(ctx, "Hbase.mutateRowsTs", bytes);
    }
  }
  
  void HbaseProcessor::process_atomicIncrement(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = NULL;
    if (this->eventHandler_.get() != NULL) {
      ctx = this->eventHandler_->getContext("Hbase.atomicIncrement", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.atomicIncrement");
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preRead(ctx, "Hbase.atomicIncrement");
    }
  
    Hbase_atomicIncrement_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postRead(ctx, "Hbase.atomicIncrement", bytes);
    }
  
    Hbase_atomicIncrement_result result;
    try {
      result.success = iface_->atomicIncrement(args.tableName, args.row, args.column, args.value);
      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 (const std::exception& e) {
      if (this->eventHandler_.get() != NULL) {
        this->eventHandler_->handlerError(ctx, "Hbase.atomicIncrement");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("atomicIncrement", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preWrite(ctx, "Hbase.atomicIncrement");
    }
  
    oprot->writeMessageBegin("atomicIncrement", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postWrite(ctx, "Hbase.atomicIncrement", bytes);
    }
  }
  
  void HbaseProcessor::process_deleteAll(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = NULL;
    if (this->eventHandler_.get() != NULL) {
      ctx = this->eventHandler_->getContext("Hbase.deleteAll", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.deleteAll");
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preRead(ctx, "Hbase.deleteAll");
    }
  
    Hbase_deleteAll_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postRead(ctx, "Hbase.deleteAll", bytes);
    }
  
    Hbase_deleteAll_result result;
    try {
      iface_->deleteAll(args.tableName, args.row, args.column, args.attributes);
    } catch (IOError &io) {
      result.io = io;
      result.__isset.io = true;
    } catch (const std::exception& e) {
      if (this->eventHandler_.get() != NULL) {
        this->eventHandler_->handlerError(ctx, "Hbase.deleteAll");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("deleteAll", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preWrite(ctx, "Hbase.deleteAll");
    }
  
    oprot->writeMessageBegin("deleteAll", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postWrite(ctx, "Hbase.deleteAll", bytes);
    }
  }
  
  void HbaseProcessor::process_deleteAllTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = NULL;
    if (this->eventHandler_.get() != NULL) {
      ctx = this->eventHandler_->getContext("Hbase.deleteAllTs", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.deleteAllTs");
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preRead(ctx, "Hbase.deleteAllTs");
    }
  
    Hbase_deleteAllTs_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postRead(ctx, "Hbase.deleteAllTs", bytes);
    }
  
    Hbase_deleteAllTs_result result;
    try {
      iface_->deleteAllTs(args.tableName, args.row, args.column, args.timestamp, args.attributes);
    } catch (IOError &io) {
      result.io = io;
      result.__isset.io = true;
    } catch (const std::exception& e) {
      if (this->eventHandler_.get() != NULL) {
        this->eventHandler_->handlerError(ctx, "Hbase.deleteAllTs");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("deleteAllTs", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preWrite(ctx, "Hbase.deleteAllTs");
    }
  
    oprot->writeMessageBegin("deleteAllTs", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postWrite(ctx, "Hbase.deleteAllTs", bytes);
    }
  }
  
  void HbaseProcessor::process_deleteAllRow(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = NULL;
    if (this->eventHandler_.get() != NULL) {
      ctx = this->eventHandler_->getContext("Hbase.deleteAllRow", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.deleteAllRow");
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preRead(ctx, "Hbase.deleteAllRow");
    }
  
    Hbase_deleteAllRow_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postRead(ctx, "Hbase.deleteAllRow", bytes);
    }
  
    Hbase_deleteAllRow_result result;
    try {
      iface_->deleteAllRow(args.tableName, args.row, args.attributes);
    } catch (IOError &io) {
      result.io = io;
      result.__isset.io = true;
    } catch (const std::exception& e) {
      if (this->eventHandler_.get() != NULL) {
        this->eventHandler_->handlerError(ctx, "Hbase.deleteAllRow");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("deleteAllRow", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preWrite(ctx, "Hbase.deleteAllRow");
    }
  
    oprot->writeMessageBegin("deleteAllRow", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postWrite(ctx, "Hbase.deleteAllRow", bytes);
    }
  }
  
  void HbaseProcessor::process_increment(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = NULL;
    if (this->eventHandler_.get() != NULL) {
      ctx = this->eventHandler_->getContext("Hbase.increment", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.increment");
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preRead(ctx, "Hbase.increment");
    }
  
    Hbase_increment_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postRead(ctx, "Hbase.increment", bytes);
    }
  
    Hbase_increment_result result;
    try {
      iface_->increment(args.increment);
    } catch (IOError &io) {
      result.io = io;
      result.__isset.io = true;
    } catch (const std::exception& e) {
      if (this->eventHandler_.get() != NULL) {
        this->eventHandler_->handlerError(ctx, "Hbase.increment");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("increment", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preWrite(ctx, "Hbase.increment");
    }
  
    oprot->writeMessageBegin("increment", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postWrite(ctx, "Hbase.increment", bytes);
    }
  }
  
  void HbaseProcessor::process_incrementRows(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = NULL;
    if (this->eventHandler_.get() != NULL) {
      ctx = this->eventHandler_->getContext("Hbase.incrementRows", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.incrementRows");
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preRead(ctx, "Hbase.incrementRows");
    }
  
    Hbase_incrementRows_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postRead(ctx, "Hbase.incrementRows", bytes);
    }
  
    Hbase_incrementRows_result result;
    try {
      iface_->incrementRows(args.increments);
    } catch (IOError &io) {
      result.io = io;
      result.__isset.io = true;
    } catch (const std::exception& e) {
      if (this->eventHandler_.get() != NULL) {
        this->eventHandler_->handlerError(ctx, "Hbase.incrementRows");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("incrementRows", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preWrite(ctx, "Hbase.incrementRows");
    }
  
    oprot->writeMessageBegin("incrementRows", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postWrite(ctx, "Hbase.incrementRows", bytes);
    }
  }
  
  void HbaseProcessor::process_deleteAllRowTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = NULL;
    if (this->eventHandler_.get() != NULL) {
      ctx = this->eventHandler_->getContext("Hbase.deleteAllRowTs", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.deleteAllRowTs");
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preRead(ctx, "Hbase.deleteAllRowTs");
    }
  
    Hbase_deleteAllRowTs_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postRead(ctx, "Hbase.deleteAllRowTs", bytes);
    }
  
    Hbase_deleteAllRowTs_result result;
    try {
      iface_->deleteAllRowTs(args.tableName, args.row, args.timestamp, args.attributes);
    } catch (IOError &io) {
      result.io = io;
      result.__isset.io = true;
    } catch (const std::exception& e) {
      if (this->eventHandler_.get() != NULL) {
        this->eventHandler_->handlerError(ctx, "Hbase.deleteAllRowTs");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("deleteAllRowTs", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preWrite(ctx, "Hbase.deleteAllRowTs");
    }
  
    oprot->writeMessageBegin("deleteAllRowTs", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postWrite(ctx, "Hbase.deleteAllRowTs", bytes);
    }
  }
  
  void HbaseProcessor::process_scannerOpenWithScan(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = NULL;
    if (this->eventHandler_.get() != NULL) {
      ctx = this->eventHandler_->getContext("Hbase.scannerOpenWithScan", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.scannerOpenWithScan");
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preRead(ctx, "Hbase.scannerOpenWithScan");
    }
  
    Hbase_scannerOpenWithScan_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postRead(ctx, "Hbase.scannerOpenWithScan", bytes);
    }
  
    Hbase_scannerOpenWithScan_result result;
    try {
      result.success = iface_->scannerOpenWithScan(args.tableName, args.scan, args.attributes);
      result.__isset.success = true;
    } catch (IOError &io) {
      result.io = io;
      result.__isset.io = true;
    } catch (const std::exception& e) {
      if (this->eventHandler_.get() != NULL) {
        this->eventHandler_->handlerError(ctx, "Hbase.scannerOpenWithScan");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("scannerOpenWithScan", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preWrite(ctx, "Hbase.scannerOpenWithScan");
    }
  
    oprot->writeMessageBegin("scannerOpenWithScan", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postWrite(ctx, "Hbase.scannerOpenWithScan", bytes);
    }
  }
  
  void HbaseProcessor::process_scannerOpen(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = NULL;
    if (this->eventHandler_.get() != NULL) {
      ctx = this->eventHandler_->getContext("Hbase.scannerOpen", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.scannerOpen");
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preRead(ctx, "Hbase.scannerOpen");
    }
  
    Hbase_scannerOpen_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postRead(ctx, "Hbase.scannerOpen", bytes);
    }
  
    Hbase_scannerOpen_result result;
    try {
      result.success = iface_->scannerOpen(args.tableName, args.startRow, args.columns, args.attributes);
      result.__isset.success = true;
    } catch (IOError &io) {
      result.io = io;
      result.__isset.io = true;
    } catch (const std::exception& e) {
      if (this->eventHandler_.get() != NULL) {
        this->eventHandler_->handlerError(ctx, "Hbase.scannerOpen");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("scannerOpen", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preWrite(ctx, "Hbase.scannerOpen");
    }
  
    oprot->writeMessageBegin("scannerOpen", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postWrite(ctx, "Hbase.scannerOpen", bytes);
    }
  }
  
  void HbaseProcessor::process_scannerOpenWithStop(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = NULL;
    if (this->eventHandler_.get() != NULL) {
      ctx = this->eventHandler_->getContext("Hbase.scannerOpenWithStop", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.scannerOpenWithStop");
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preRead(ctx, "Hbase.scannerOpenWithStop");
    }
  
    Hbase_scannerOpenWithStop_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postRead(ctx, "Hbase.scannerOpenWithStop", bytes);
    }
  
    Hbase_scannerOpenWithStop_result result;
    try {
      result.success = iface_->scannerOpenWithStop(args.tableName, args.startRow, args.stopRow, args.columns, args.attributes);
      result.__isset.success = true;
    } catch (IOError &io) {
      result.io = io;
      result.__isset.io = true;
    } catch (const std::exception& e) {
      if (this->eventHandler_.get() != NULL) {
        this->eventHandler_->handlerError(ctx, "Hbase.scannerOpenWithStop");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("scannerOpenWithStop", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preWrite(ctx, "Hbase.scannerOpenWithStop");
    }
  
    oprot->writeMessageBegin("scannerOpenWithStop", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postWrite(ctx, "Hbase.scannerOpenWithStop", bytes);
    }
  }
  
  void HbaseProcessor::process_scannerOpenWithPrefix(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = NULL;
    if (this->eventHandler_.get() != NULL) {
      ctx = this->eventHandler_->getContext("Hbase.scannerOpenWithPrefix", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.scannerOpenWithPrefix");
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preRead(ctx, "Hbase.scannerOpenWithPrefix");
    }
  
    Hbase_scannerOpenWithPrefix_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postRead(ctx, "Hbase.scannerOpenWithPrefix", bytes);
    }
  
    Hbase_scannerOpenWithPrefix_result result;
    try {
      result.success = iface_->scannerOpenWithPrefix(args.tableName, args.startAndPrefix, args.columns, args.attributes);
      result.__isset.success = true;
    } catch (IOError &io) {
      result.io = io;
      result.__isset.io = true;
    } catch (const std::exception& e) {
      if (this->eventHandler_.get() != NULL) {
        this->eventHandler_->handlerError(ctx, "Hbase.scannerOpenWithPrefix");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("scannerOpenWithPrefix", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preWrite(ctx, "Hbase.scannerOpenWithPrefix");
    }
  
    oprot->writeMessageBegin("scannerOpenWithPrefix", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postWrite(ctx, "Hbase.scannerOpenWithPrefix", bytes);
    }
  }
  
  void HbaseProcessor::process_scannerOpenTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = NULL;
    if (this->eventHandler_.get() != NULL) {
      ctx = this->eventHandler_->getContext("Hbase.scannerOpenTs", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.scannerOpenTs");
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preRead(ctx, "Hbase.scannerOpenTs");
    }
  
    Hbase_scannerOpenTs_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postRead(ctx, "Hbase.scannerOpenTs", bytes);
    }
  
    Hbase_scannerOpenTs_result result;
    try {
      result.success = iface_->scannerOpenTs(args.tableName, args.startRow, args.columns, args.timestamp, args.attributes);
      result.__isset.success = true;
    } catch (IOError &io) {
      result.io = io;
      result.__isset.io = true;
    } catch (const std::exception& e) {
      if (this->eventHandler_.get() != NULL) {
        this->eventHandler_->handlerError(ctx, "Hbase.scannerOpenTs");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("scannerOpenTs", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preWrite(ctx, "Hbase.scannerOpenTs");
    }
  
    oprot->writeMessageBegin("scannerOpenTs", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postWrite(ctx, "Hbase.scannerOpenTs", bytes);
    }
  }
  
  void HbaseProcessor::process_scannerOpenWithStopTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = NULL;
    if (this->eventHandler_.get() != NULL) {
      ctx = this->eventHandler_->getContext("Hbase.scannerOpenWithStopTs", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.scannerOpenWithStopTs");
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preRead(ctx, "Hbase.scannerOpenWithStopTs");
    }
  
    Hbase_scannerOpenWithStopTs_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postRead(ctx, "Hbase.scannerOpenWithStopTs", bytes);
    }
  
    Hbase_scannerOpenWithStopTs_result result;
    try {
      result.success = iface_->scannerOpenWithStopTs(args.tableName, args.startRow, args.stopRow, args.columns, args.timestamp, args.attributes);
      result.__isset.success = true;
    } catch (IOError &io) {
      result.io = io;
      result.__isset.io = true;
    } catch (const std::exception& e) {
      if (this->eventHandler_.get() != NULL) {
        this->eventHandler_->handlerError(ctx, "Hbase.scannerOpenWithStopTs");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("scannerOpenWithStopTs", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preWrite(ctx, "Hbase.scannerOpenWithStopTs");
    }
  
    oprot->writeMessageBegin("scannerOpenWithStopTs", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postWrite(ctx, "Hbase.scannerOpenWithStopTs", bytes);
    }
  }
  
  void HbaseProcessor::process_scannerGet(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = NULL;
    if (this->eventHandler_.get() != NULL) {
      ctx = this->eventHandler_->getContext("Hbase.scannerGet", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.scannerGet");
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preRead(ctx, "Hbase.scannerGet");
    }
  
    Hbase_scannerGet_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postRead(ctx, "Hbase.scannerGet", bytes);
    }
  
    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 (const std::exception& e) {
      if (this->eventHandler_.get() != NULL) {
        this->eventHandler_->handlerError(ctx, "Hbase.scannerGet");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("scannerGet", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preWrite(ctx, "Hbase.scannerGet");
    }
  
    oprot->writeMessageBegin("scannerGet", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postWrite(ctx, "Hbase.scannerGet", bytes);
    }
  }
  
  void HbaseProcessor::process_scannerGetList(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = NULL;
    if (this->eventHandler_.get() != NULL) {
      ctx = this->eventHandler_->getContext("Hbase.scannerGetList", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.scannerGetList");
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preRead(ctx, "Hbase.scannerGetList");
    }
  
    Hbase_scannerGetList_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postRead(ctx, "Hbase.scannerGetList", bytes);
    }
  
    Hbase_scannerGetList_result result;
    try {
      iface_->scannerGetList(result.success, args.id, args.nbRows);
      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 (const std::exception& e) {
      if (this->eventHandler_.get() != NULL) {
        this->eventHandler_->handlerError(ctx, "Hbase.scannerGetList");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("scannerGetList", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preWrite(ctx, "Hbase.scannerGetList");
    }
  
    oprot->writeMessageBegin("scannerGetList", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postWrite(ctx, "Hbase.scannerGetList", bytes);
    }
  }
  
  void HbaseProcessor::process_scannerClose(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = NULL;
    if (this->eventHandler_.get() != NULL) {
      ctx = this->eventHandler_->getContext("Hbase.scannerClose", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.scannerClose");
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preRead(ctx, "Hbase.scannerClose");
    }
  
    Hbase_scannerClose_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postRead(ctx, "Hbase.scannerClose", bytes);
    }
  
    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) {
      if (this->eventHandler_.get() != NULL) {
        this->eventHandler_->handlerError(ctx, "Hbase.scannerClose");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("scannerClose", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preWrite(ctx, "Hbase.scannerClose");
    }
  
    oprot->writeMessageBegin("scannerClose", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postWrite(ctx, "Hbase.scannerClose", bytes);
    }
  }
  
  void HbaseProcessor::process_getRowOrBefore(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = NULL;
    if (this->eventHandler_.get() != NULL) {
      ctx = this->eventHandler_->getContext("Hbase.getRowOrBefore", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.getRowOrBefore");
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preRead(ctx, "Hbase.getRowOrBefore");
    }
  
    Hbase_getRowOrBefore_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postRead(ctx, "Hbase.getRowOrBefore", bytes);
    }
  
    Hbase_getRowOrBefore_result result;
    try {
      iface_->getRowOrBefore(result.success, args.tableName, args.row, args.family);
      result.__isset.success = true;
    } catch (IOError &io) {
      result.io = io;
      result.__isset.io = true;
    } catch (const std::exception& e) {
      if (this->eventHandler_.get() != NULL) {
        this->eventHandler_->handlerError(ctx, "Hbase.getRowOrBefore");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("getRowOrBefore", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preWrite(ctx, "Hbase.getRowOrBefore");
    }
  
    oprot->writeMessageBegin("getRowOrBefore", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postWrite(ctx, "Hbase.getRowOrBefore", bytes);
    }
  }
  
  void HbaseProcessor::process_getRegionInfo(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = NULL;
    if (this->eventHandler_.get() != NULL) {
      ctx = this->eventHandler_->getContext("Hbase.getRegionInfo", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.getRegionInfo");
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preRead(ctx, "Hbase.getRegionInfo");
    }
  
    Hbase_getRegionInfo_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postRead(ctx, "Hbase.getRegionInfo", bytes);
    }
  
    Hbase_getRegionInfo_result result;
    try {
      iface_->getRegionInfo(result.success, args.row);
      result.__isset.success = true;
    } catch (IOError &io) {
      result.io = io;
      result.__isset.io = true;
    } catch (const std::exception& e) {
      if (this->eventHandler_.get() != NULL) {
        this->eventHandler_->handlerError(ctx, "Hbase.getRegionInfo");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("getRegionInfo", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->preWrite(ctx, "Hbase.getRegionInfo");
    }
  
    oprot->writeMessageBegin("getRegionInfo", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != NULL) {
      this->eventHandler_->postWrite(ctx, "Hbase.getRegionInfo", bytes);
    }
  }
  
  std::shared_ptr< ::apache::thrift::TProcessor > HbaseProcessorFactory::getProcessor(const ::apache::thrift::TConnectionInfo& connInfo) {
    ::apache::thrift::ReleaseHandler< HbaseIfFactory > cleanup(handlerFactory_);
    std::shared_ptr< HbaseIf > handler(handlerFactory_->getHandler(connInfo), cleanup);
    std::shared_ptr< ::apache::thrift::TProcessor > processor(new HbaseProcessor(handler));
    return processor;
  }
  }}}} // namespace
  
  