text: /**
   * Autogenerated by Thrift Compiler (0.9.2)
   *
   * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
   *  @generated
   */
  #include "hbase_types.h"
  
  #include <algorithm>
  #include <ostream>
  
  #include <thrift/TToString.h>
  
  namespace apache { namespace hadoop { namespace hbase { namespace thrift {
  
  
  TCell::~TCell() throw() {
  }
  
  
  void TCell::__set_value(const Bytes& val) {
    this->value = val;
  }
  
  void TCell::__set_timestamp(const int64_t val) {
    this->timestamp = val;
  }
  
  const char* TCell::ascii_fingerprint = "1CCCF6FC31CFD1D61BBBB1BAF3590620";
  const uint8_t TCell::binary_fingerprint[16] = {0x1C,0xCC,0xF6,0xFC,0x31,0xCF,0xD1,0xD6,0x1B,0xBB,0xB1,0xBA,0xF3,0x59,0x06,0x20};
  
  uint32_t TCell::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->value);
            this->__isset.value = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::thrift::protocol::T_I64) {
            xfer += iprot->readI64(this->timestamp);
            this->__isset.timestamp = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  uint32_t TCell::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    oprot->incrementRecursionDepth();
    xfer += oprot->writeStructBegin("TCell");
  
    xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary(this->value);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 2);
    xfer += oprot->writeI64(this->timestamp);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    oprot->decrementRecursionDepth();
    return xfer;
  }
  
  void swap(TCell &a, TCell &b) {
    using ::std::swap;
    swap(a.value, b.value);
    swap(a.timestamp, b.timestamp);
    swap(a.__isset, b.__isset);
  }
  
  TCell::TCell(const TCell& other0) {
    value = other0.value;
    timestamp = other0.timestamp;
    __isset = other0.__isset;
  }
  TCell& TCell::operator=(const TCell& other1) {
    value = other1.value;
    timestamp = other1.timestamp;
    __isset = other1.__isset;
    return *this;
  }
  std::ostream& operator<<(std::ostream& out, const TCell& obj) {
    using apache::thrift::to_string;
    out << "TCell(";
    out << "value=" << to_string(obj.value);
    out << ", " << "timestamp=" << to_string(obj.timestamp);
    out << ")";
    return out;
  }
  
  
  ColumnDescriptor::~ColumnDescriptor() throw() {
  }
  
  
  void ColumnDescriptor::__set_name(const Text& val) {
    this->name = val;
  }
  
  void ColumnDescriptor::__set_maxVersions(const int32_t val) {
    this->maxVersions = val;
  }
  
  void ColumnDescriptor::__set_compression(const std::string& val) {
    this->compression = val;
  }
  
  void ColumnDescriptor::__set_inMemory(const bool val) {
    this->inMemory = val;
  }
  
  void ColumnDescriptor::__set_bloomFilterType(const std::string& val) {
    this->bloomFilterType = val;
  }
  
  void ColumnDescriptor::__set_bloomFilterVectorSize(const int32_t val) {
    this->bloomFilterVectorSize = val;
  }
  
  void ColumnDescriptor::__set_bloomFilterNbHashes(const int32_t val) {
    this->bloomFilterNbHashes = val;
  }
  
  void ColumnDescriptor::__set_blockCacheEnabled(const bool val) {
    this->blockCacheEnabled = val;
  }
  
  void ColumnDescriptor::__set_timeToLive(const int32_t val) {
    this->timeToLive = val;
  }
  
  const char* ColumnDescriptor::ascii_fingerprint = "3B18638852FDF9DD911BC1174265F92E";
  const uint8_t ColumnDescriptor::binary_fingerprint[16] = {0x3B,0x18,0x63,0x88,0x52,0xFD,0xF9,0xDD,0x91,0x1B,0xC1,0x17,0x42,0x65,0xF9,0x2E};
  
  uint32_t ColumnDescriptor::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->name);
            this->__isset.name = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::thrift::protocol::T_I32) {
            xfer += iprot->readI32(this->maxVersions);
            this->__isset.maxVersions = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 3:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readString(this->compression);
            this->__isset.compression = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 4:
          if (ftype == ::apache::thrift::protocol::T_BOOL) {
            xfer += iprot->readBool(this->inMemory);
            this->__isset.inMemory = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 5:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readString(this->bloomFilterType);
            this->__isset.bloomFilterType = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 6:
          if (ftype == ::apache::thrift::protocol::T_I32) {
            xfer += iprot->readI32(this->bloomFilterVectorSize);
            this->__isset.bloomFilterVectorSize = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 7:
          if (ftype == ::apache::thrift::protocol::T_I32) {
            xfer += iprot->readI32(this->bloomFilterNbHashes);
            this->__isset.bloomFilterNbHashes = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 8:
          if (ftype == ::apache::thrift::protocol::T_BOOL) {
            xfer += iprot->readBool(this->blockCacheEnabled);
            this->__isset.blockCacheEnabled = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 9:
          if (ftype == ::apache::thrift::protocol::T_I32) {
            xfer += iprot->readI32(this->timeToLive);
            this->__isset.timeToLive = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  uint32_t ColumnDescriptor::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    oprot->incrementRecursionDepth();
    xfer += oprot->writeStructBegin("ColumnDescriptor");
  
    xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary(this->name);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("maxVersions", ::apache::thrift::protocol::T_I32, 2);
    xfer += oprot->writeI32(this->maxVersions);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("compression", ::apache::thrift::protocol::T_STRING, 3);
    xfer += oprot->writeString(this->compression);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("inMemory", ::apache::thrift::protocol::T_BOOL, 4);
    xfer += oprot->writeBool(this->inMemory);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("bloomFilterType", ::apache::thrift::protocol::T_STRING, 5);
    xfer += oprot->writeString(this->bloomFilterType);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("bloomFilterVectorSize", ::apache::thrift::protocol::T_I32, 6);
    xfer += oprot->writeI32(this->bloomFilterVectorSize);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("bloomFilterNbHashes", ::apache::thrift::protocol::T_I32, 7);
    xfer += oprot->writeI32(this->bloomFilterNbHashes);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("blockCacheEnabled", ::apache::thrift::protocol::T_BOOL, 8);
    xfer += oprot->writeBool(this->blockCacheEnabled);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("timeToLive", ::apache::thrift::protocol::T_I32, 9);
    xfer += oprot->writeI32(this->timeToLive);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    oprot->decrementRecursionDepth();
    return xfer;
  }
  
  void swap(ColumnDescriptor &a, ColumnDescriptor &b) {
    using ::std::swap;
    swap(a.name, b.name);
    swap(a.maxVersions, b.maxVersions);
    swap(a.compression, b.compression);
    swap(a.inMemory, b.inMemory);
    swap(a.bloomFilterType, b.bloomFilterType);
    swap(a.bloomFilterVectorSize, b.bloomFilterVectorSize);
    swap(a.bloomFilterNbHashes, b.bloomFilterNbHashes);
    swap(a.blockCacheEnabled, b.blockCacheEnabled);
    swap(a.timeToLive, b.timeToLive);
    swap(a.__isset, b.__isset);
  }
  
  ColumnDescriptor::ColumnDescriptor(const ColumnDescriptor& other2) {
    name = other2.name;
    maxVersions = other2.maxVersions;
    compression = other2.compression;
    inMemory = other2.inMemory;
    bloomFilterType = other2.bloomFilterType;
    bloomFilterVectorSize = other2.bloomFilterVectorSize;
    bloomFilterNbHashes = other2.bloomFilterNbHashes;
    blockCacheEnabled = other2.blockCacheEnabled;
    timeToLive = other2.timeToLive;
    __isset = other2.__isset;
  }
  ColumnDescriptor& ColumnDescriptor::operator=(const ColumnDescriptor& other3) {
    name = other3.name;
    maxVersions = other3.maxVersions;
    compression = other3.compression;
    inMemory = other3.inMemory;
    bloomFilterType = other3.bloomFilterType;
    bloomFilterVectorSize = other3.bloomFilterVectorSize;
    bloomFilterNbHashes = other3.bloomFilterNbHashes;
    blockCacheEnabled = other3.blockCacheEnabled;
    timeToLive = other3.timeToLive;
    __isset = other3.__isset;
    return *this;
  }
  std::ostream& operator<<(std::ostream& out, const ColumnDescriptor& obj) {
    using apache::thrift::to_string;
    out << "ColumnDescriptor(";
    out << "name=" << to_string(obj.name);
    out << ", " << "maxVersions=" << to_string(obj.maxVersions);
    out << ", " << "compression=" << to_string(obj.compression);
    out << ", " << "inMemory=" << to_string(obj.inMemory);
    out << ", " << "bloomFilterType=" << to_string(obj.bloomFilterType);
    out << ", " << "bloomFilterVectorSize=" << to_string(obj.bloomFilterVectorSize);
    out << ", " << "bloomFilterNbHashes=" << to_string(obj.bloomFilterNbHashes);
    out << ", " << "blockCacheEnabled=" << to_string(obj.blockCacheEnabled);
    out << ", " << "timeToLive=" << to_string(obj.timeToLive);
    out << ")";
    return out;
  }
  
  
  TRegionInfo::~TRegionInfo() throw() {
  }
  
  
  void TRegionInfo::__set_startKey(const Text& val) {
    this->startKey = val;
  }
  
  void TRegionInfo::__set_endKey(const Text& val) {
    this->endKey = val;
  }
  
  void TRegionInfo::__set_id(const int64_t val) {
    this->id = val;
  }
  
  void TRegionInfo::__set_name(const Text& val) {
    this->name = val;
  }
  
  void TRegionInfo::__set_version(const int8_t val) {
    this->version = val;
  }
  
  void TRegionInfo::__set_serverName(const Text& val) {
    this->serverName = val;
  }
  
  void TRegionInfo::__set_port(const int32_t val) {
    this->port = val;
  }
  
  const char* TRegionInfo::ascii_fingerprint = "B58AB7A239831F8614F7B6709C89DC7B";
  const uint8_t TRegionInfo::binary_fingerprint[16] = {0xB5,0x8A,0xB7,0xA2,0x39,0x83,0x1F,0x86,0x14,0xF7,0xB6,0x70,0x9C,0x89,0xDC,0x7B};
  
  uint32_t TRegionInfo::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->startKey);
            this->__isset.startKey = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->endKey);
            this->__isset.endKey = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 3:
          if (ftype == ::apache::thrift::protocol::T_I64) {
            xfer += iprot->readI64(this->id);
            this->__isset.id = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 4:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->name);
            this->__isset.name = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 5:
          if (ftype == ::apache::thrift::protocol::T_BYTE) {
            xfer += iprot->readByte(this->version);
            this->__isset.version = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 6:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->serverName);
            this->__isset.serverName = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 7:
          if (ftype == ::apache::thrift::protocol::T_I32) {
            xfer += iprot->readI32(this->port);
            this->__isset.port = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  uint32_t TRegionInfo::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    oprot->incrementRecursionDepth();
    xfer += oprot->writeStructBegin("TRegionInfo");
  
    xfer += oprot->writeFieldBegin("startKey", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary(this->startKey);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("endKey", ::apache::thrift::protocol::T_STRING, 2);
    xfer += oprot->writeBinary(this->endKey);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("id", ::apache::thrift::protocol::T_I64, 3);
    xfer += oprot->writeI64(this->id);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 4);
    xfer += oprot->writeBinary(this->name);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("version", ::apache::thrift::protocol::T_BYTE, 5);
    xfer += oprot->writeByte(this->version);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("serverName", ::apache::thrift::protocol::T_STRING, 6);
    xfer += oprot->writeBinary(this->serverName);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("port", ::apache::thrift::protocol::T_I32, 7);
    xfer += oprot->writeI32(this->port);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    oprot->decrementRecursionDepth();
    return xfer;
  }
  
  void swap(TRegionInfo &a, TRegionInfo &b) {
    using ::std::swap;
    swap(a.startKey, b.startKey);
    swap(a.endKey, b.endKey);
    swap(a.id, b.id);
    swap(a.name, b.name);
    swap(a.version, b.version);
    swap(a.serverName, b.serverName);
    swap(a.port, b.port);
    swap(a.__isset, b.__isset);
  }
  
  TRegionInfo::TRegionInfo(const TRegionInfo& other4) {
    startKey = other4.startKey;
    endKey = other4.endKey;
    id = other4.id;
    name = other4.name;
    version = other4.version;
    serverName = other4.serverName;
    port = other4.port;
    __isset = other4.__isset;
  }
  TRegionInfo& TRegionInfo::operator=(const TRegionInfo& other5) {
    startKey = other5.startKey;
    endKey = other5.endKey;
    id = other5.id;
    name = other5.name;
    version = other5.version;
    serverName = other5.serverName;
    port = other5.port;
    __isset = other5.__isset;
    return *this;
  }
  std::ostream& operator<<(std::ostream& out, const TRegionInfo& obj) {
    using apache::thrift::to_string;
    out << "TRegionInfo(";
    out << "startKey=" << to_string(obj.startKey);
    out << ", " << "endKey=" << to_string(obj.endKey);
    out << ", " << "id=" << to_string(obj.id);
    out << ", " << "name=" << to_string(obj.name);
    out << ", " << "version=" << to_string(obj.version);
    out << ", " << "serverName=" << to_string(obj.serverName);
    out << ", " << "port=" << to_string(obj.port);
    out << ")";
    return out;
  }
  
  
  Mutation::~Mutation() throw() {
  }
  
  
  void Mutation::__set_isDelete(const bool val) {
    this->isDelete = val;
  }
  
  void Mutation::__set_column(const Text& val) {
    this->column = val;
  }
  
  void Mutation::__set_value(const Text& val) {
    this->value = val;
  }
  
  void Mutation::__set_writeToWAL(const bool val) {
    this->writeToWAL = val;
  }
  
  const char* Mutation::ascii_fingerprint = "CD9E9D4A6406AD402C90440434AE18A0";
  const uint8_t Mutation::binary_fingerprint[16] = {0xCD,0x9E,0x9D,0x4A,0x64,0x06,0xAD,0x40,0x2C,0x90,0x44,0x04,0x34,0xAE,0x18,0xA0};
  
  uint32_t Mutation::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_BOOL) {
            xfer += iprot->readBool(this->isDelete);
            this->__isset.isDelete = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->column);
            this->__isset.column = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 3:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->value);
            this->__isset.value = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 4:
          if (ftype == ::apache::thrift::protocol::T_BOOL) {
            xfer += iprot->readBool(this->writeToWAL);
            this->__isset.writeToWAL = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  uint32_t Mutation::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    oprot->incrementRecursionDepth();
    xfer += oprot->writeStructBegin("Mutation");
  
    xfer += oprot->writeFieldBegin("isDelete", ::apache::thrift::protocol::T_BOOL, 1);
    xfer += oprot->writeBool(this->isDelete);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRING, 2);
    xfer += oprot->writeBinary(this->column);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_STRING, 3);
    xfer += oprot->writeBinary(this->value);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("writeToWAL", ::apache::thrift::protocol::T_BOOL, 4);
    xfer += oprot->writeBool(this->writeToWAL);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    oprot->decrementRecursionDepth();
    return xfer;
  }
  
  void swap(Mutation &a, Mutation &b) {
    using ::std::swap;
    swap(a.isDelete, b.isDelete);
    swap(a.column, b.column);
    swap(a.value, b.value);
    swap(a.writeToWAL, b.writeToWAL);
    swap(a.__isset, b.__isset);
  }
  
  Mutation::Mutation(const Mutation& other6) {
    isDelete = other6.isDelete;
    column = other6.column;
    value = other6.value;
    writeToWAL = other6.writeToWAL;
    __isset = other6.__isset;
  }
  Mutation& Mutation::operator=(const Mutation& other7) {
    isDelete = other7.isDelete;
    column = other7.column;
    value = other7.value;
    writeToWAL = other7.writeToWAL;
    __isset = other7.__isset;
    return *this;
  }
  std::ostream& operator<<(std::ostream& out, const Mutation& obj) {
    using apache::thrift::to_string;
    out << "Mutation(";
    out << "isDelete=" << to_string(obj.isDelete);
    out << ", " << "column=" << to_string(obj.column);
    out << ", " << "value=" << to_string(obj.value);
    out << ", " << "writeToWAL=" << to_string(obj.writeToWAL);
    out << ")";
    return out;
  }
  
  
  BatchMutation::~BatchMutation() throw() {
  }
  
  
  void BatchMutation::__set_row(const Text& val) {
    this->row = val;
  }
  
  void BatchMutation::__set_mutations(const std::vector<Mutation> & val) {
    this->mutations = val;
  }
  
  const char* BatchMutation::ascii_fingerprint = "4B8A4A9E051CAFF532E1C0D54F6AD2AB";
  const uint8_t BatchMutation::binary_fingerprint[16] = {0x4B,0x8A,0x4A,0x9E,0x05,0x1C,0xAF,0xF5,0x32,0xE1,0xC0,0xD5,0x4F,0x6A,0xD2,0xAB};
  
  uint32_t BatchMutation::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;
        case 2:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->mutations.clear();
              uint32_t _size8;
              ::apache::thrift::protocol::TType _etype11;
              xfer += iprot->readListBegin(_etype11, _size8);
              this->mutations.resize(_size8);
              uint32_t _i12;
              for (_i12 = 0; _i12 < _size8; ++_i12)
              {
                xfer += this->mutations[_i12].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.mutations = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  uint32_t BatchMutation::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    oprot->incrementRecursionDepth();
    xfer += oprot->writeStructBegin("BatchMutation");
  
    xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary(this->row);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("mutations", ::apache::thrift::protocol::T_LIST, 2);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->mutations.size()));
      std::vector<Mutation> ::const_iterator _iter13;
      for (_iter13 = this->mutations.begin(); _iter13 != this->mutations.end(); ++_iter13)
      {
        xfer += (*_iter13).write(oprot);
      }
      xfer += oprot->writeListEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    oprot->decrementRecursionDepth();
    return xfer;
  }
  
  void swap(BatchMutation &a, BatchMutation &b) {
    using ::std::swap;
    swap(a.row, b.row);
    swap(a.mutations, b.mutations);
    swap(a.__isset, b.__isset);
  }
  
  BatchMutation::BatchMutation(const BatchMutation& other14) {
    row = other14.row;
    mutations = other14.mutations;
    __isset = other14.__isset;
  }
  BatchMutation& BatchMutation::operator=(const BatchMutation& other15) {
    row = other15.row;
    mutations = other15.mutations;
    __isset = other15.__isset;
    return *this;
  }
  std::ostream& operator<<(std::ostream& out, const BatchMutation& obj) {
    using apache::thrift::to_string;
    out << "BatchMutation(";
    out << "row=" << to_string(obj.row);
    out << ", " << "mutations=" << to_string(obj.mutations);
    out << ")";
    return out;
  }
  
  
  TIncrement::~TIncrement() throw() {
  }
  
  
  void TIncrement::__set_table(const Text& val) {
    this->table = val;
  }
  
  void TIncrement::__set_row(const Text& val) {
    this->row = val;
  }
  
  void TIncrement::__set_column(const Text& val) {
    this->column = val;
  }
  
  void TIncrement::__set_ammount(const int64_t val) {
    this->ammount = val;
  }
  
  const char* TIncrement::ascii_fingerprint = "5F9965D46A4F3845985AC0F9B81C3C69";
  const uint8_t TIncrement::binary_fingerprint[16] = {0x5F,0x99,0x65,0xD4,0x6A,0x4F,0x38,0x45,0x98,0x5A,0xC0,0xF9,0xB8,0x1C,0x3C,0x69};
  
  uint32_t TIncrement::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->table);
            this->__isset.table = 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->ammount);
            this->__isset.ammount = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  uint32_t TIncrement::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    oprot->incrementRecursionDepth();
    xfer += oprot->writeStructBegin("TIncrement");
  
    xfer += oprot->writeFieldBegin("table", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary(this->table);
    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("ammount", ::apache::thrift::protocol::T_I64, 4);
    xfer += oprot->writeI64(this->ammount);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    oprot->decrementRecursionDepth();
    return xfer;
  }
  
  void swap(TIncrement &a, TIncrement &b) {
    using ::std::swap;
    swap(a.table, b.table);
    swap(a.row, b.row);
    swap(a.column, b.column);
    swap(a.ammount, b.ammount);
    swap(a.__isset, b.__isset);
  }
  
  TIncrement::TIncrement(const TIncrement& other16) {
    table = other16.table;
    row = other16.row;
    column = other16.column;
    ammount = other16.ammount;
    __isset = other16.__isset;
  }
  TIncrement& TIncrement::operator=(const TIncrement& other17) {
    table = other17.table;
    row = other17.row;
    column = other17.column;
    ammount = other17.ammount;
    __isset = other17.__isset;
    return *this;
  }
  std::ostream& operator<<(std::ostream& out, const TIncrement& obj) {
    using apache::thrift::to_string;
    out << "TIncrement(";
    out << "table=" << to_string(obj.table);
    out << ", " << "row=" << to_string(obj.row);
    out << ", " << "column=" << to_string(obj.column);
    out << ", " << "ammount=" << to_string(obj.ammount);
    out << ")";
    return out;
  }
  
  
  TColumn::~TColumn() throw() {
  }
  
  
  void TColumn::__set_columnName(const Text& val) {
    this->columnName = val;
  }
  
  void TColumn::__set_cell(const TCell& val) {
    this->cell = val;
  }
  
  const char* TColumn::ascii_fingerprint = "53A78393C2EDF13B3E77589DF969E89A";
  const uint8_t TColumn::binary_fingerprint[16] = {0x53,0xA7,0x83,0x93,0xC2,0xED,0xF1,0x3B,0x3E,0x77,0x58,0x9D,0xF9,0x69,0xE8,0x9A};
  
  uint32_t TColumn::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->columnName);
            this->__isset.columnName = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::thrift::protocol::T_STRUCT) {
            xfer += this->cell.read(iprot);
            this->__isset.cell = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  uint32_t TColumn::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    oprot->incrementRecursionDepth();
    xfer += oprot->writeStructBegin("TColumn");
  
    xfer += oprot->writeFieldBegin("columnName", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary(this->columnName);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("cell", ::apache::thrift::protocol::T_STRUCT, 2);
    xfer += this->cell.write(oprot);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    oprot->decrementRecursionDepth();
    return xfer;
  }
  
  void swap(TColumn &a, TColumn &b) {
    using ::std::swap;
    swap(a.columnName, b.columnName);
    swap(a.cell, b.cell);
    swap(a.__isset, b.__isset);
  }
  
  TColumn::TColumn(const TColumn& other18) {
    columnName = other18.columnName;
    cell = other18.cell;
    __isset = other18.__isset;
  }
  TColumn& TColumn::operator=(const TColumn& other19) {
    columnName = other19.columnName;
    cell = other19.cell;
    __isset = other19.__isset;
    return *this;
  }
  std::ostream& operator<<(std::ostream& out, const TColumn& obj) {
    using apache::thrift::to_string;
    out << "TColumn(";
    out << "columnName=" << to_string(obj.columnName);
    out << ", " << "cell=" << to_string(obj.cell);
    out << ")";
    return out;
  }
  
  
  TRowResult::~TRowResult() throw() {
  }
  
  
  void TRowResult::__set_row(const Text& val) {
    this->row = val;
  }
  
  void TRowResult::__set_columns(const std::map<Text, TCell> & val) {
    this->columns = val;
  __isset.columns = true;
  }
  
  void TRowResult::__set_sortedColumns(const std::vector<TColumn> & val) {
    this->sortedColumns = val;
  __isset.sortedColumns = true;
  }
  
  const char* TRowResult::ascii_fingerprint = "9A5547565643A177300AFED9A6BD175D";
  const uint8_t TRowResult::binary_fingerprint[16] = {0x9A,0x55,0x47,0x56,0x56,0x43,0xA1,0x77,0x30,0x0A,0xFE,0xD9,0xA6,0xBD,0x17,0x5D};
  
  uint32_t TRowResult::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;
        case 2:
          if (ftype == ::apache::thrift::protocol::T_MAP) {
            {
              this->columns.clear();
              uint32_t _size20;
              ::apache::thrift::protocol::TType _ktype21;
              ::apache::thrift::protocol::TType _vtype22;
              xfer += iprot->readMapBegin(_ktype21, _vtype22, _size20);
              uint32_t _i24;
              for (_i24 = 0; _i24 < _size20; ++_i24)
              {
                Text _key25;
                xfer += iprot->readBinary(_key25);
                TCell& _val26 = this->columns[_key25];
                xfer += _val26.read(iprot);
              }
              xfer += iprot->readMapEnd();
            }
            this->__isset.columns = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 3:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->sortedColumns.clear();
              uint32_t _size27;
              ::apache::thrift::protocol::TType _etype30;
              xfer += iprot->readListBegin(_etype30, _size27);
              this->sortedColumns.resize(_size27);
              uint32_t _i31;
              for (_i31 = 0; _i31 < _size27; ++_i31)
              {
                xfer += this->sortedColumns[_i31].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.sortedColumns = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  uint32_t TRowResult::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    oprot->incrementRecursionDepth();
    xfer += oprot->writeStructBegin("TRowResult");
  
    xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary(this->row);
    xfer += oprot->writeFieldEnd();
  
    if (this->__isset.columns) {
      xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_MAP, 2);
      {
        xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->columns.size()));
        std::map<Text, TCell> ::const_iterator _iter32;
        for (_iter32 = this->columns.begin(); _iter32 != this->columns.end(); ++_iter32)
        {
          xfer += oprot->writeBinary(_iter32->first);
          xfer += _iter32->second.write(oprot);
        }
        xfer += oprot->writeMapEnd();
      }
      xfer += oprot->writeFieldEnd();
    }
    if (this->__isset.sortedColumns) {
      xfer += oprot->writeFieldBegin("sortedColumns", ::apache::thrift::protocol::T_LIST, 3);
      {
        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->sortedColumns.size()));
        std::vector<TColumn> ::const_iterator _iter33;
        for (_iter33 = this->sortedColumns.begin(); _iter33 != this->sortedColumns.end(); ++_iter33)
        {
          xfer += (*_iter33).write(oprot);
        }
        xfer += oprot->writeListEnd();
      }
      xfer += oprot->writeFieldEnd();
    }
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    oprot->decrementRecursionDepth();
    return xfer;
  }
  
  void swap(TRowResult &a, TRowResult &b) {
    using ::std::swap;
    swap(a.row, b.row);
    swap(a.columns, b.columns);
    swap(a.sortedColumns, b.sortedColumns);
    swap(a.__isset, b.__isset);
  }
  
  TRowResult::TRowResult(const TRowResult& other34) {
    row = other34.row;
    columns = other34.columns;
    sortedColumns = other34.sortedColumns;
    __isset = other34.__isset;
  }
  TRowResult& TRowResult::operator=(const TRowResult& other35) {
    row = other35.row;
    columns = other35.columns;
    sortedColumns = other35.sortedColumns;
    __isset = other35.__isset;
    return *this;
  }
  std::ostream& operator<<(std::ostream& out, const TRowResult& obj) {
    using apache::thrift::to_string;
    out << "TRowResult(";
    out << "row=" << to_string(obj.row);
    out << ", " << "columns="; (obj.__isset.columns ? (out << to_string(obj.columns)) : (out << "<null>"));
    out << ", " << "sortedColumns="; (obj.__isset.sortedColumns ? (out << to_string(obj.sortedColumns)) : (out << "<null>"));
    out << ")";
    return out;
  }
  
  
  TScan::~TScan() throw() {
  }
  
  
  void TScan::__set_startRow(const Text& val) {
    this->startRow = val;
  __isset.startRow = true;
  }
  
  void TScan::__set_stopRow(const Text& val) {
    this->stopRow = val;
  __isset.stopRow = true;
  }
  
  void TScan::__set_timestamp(const int64_t val) {
    this->timestamp = val;
  __isset.timestamp = true;
  }
  
  void TScan::__set_columns(const std::vector<Text> & val) {
    this->columns = val;
  __isset.columns = true;
  }
  
  void TScan::__set_caching(const int32_t val) {
    this->caching = val;
  __isset.caching = true;
  }
  
  void TScan::__set_filterString(const Text& val) {
    this->filterString = val;
  __isset.filterString = true;
  }
  
  void TScan::__set_batchSize(const int32_t val) {
    this->batchSize = val;
  __isset.batchSize = true;
  }
  
  void TScan::__set_sortColumns(const bool val) {
    this->sortColumns = val;
  __isset.sortColumns = true;
  }
  
  void TScan::__set_reversed(const bool val) {
    this->reversed = val;
  __isset.reversed = true;
  }
  
  const char* TScan::ascii_fingerprint = "CA3BE055C7BECB520D835464435A35B3";
  const uint8_t TScan::binary_fingerprint[16] = {0xCA,0x3B,0xE0,0x55,0xC7,0xBE,0xCB,0x52,0x0D,0x83,0x54,0x64,0x43,0x5A,0x35,0xB3};
  
  uint32_t TScan::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->startRow);
            this->__isset.startRow = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->stopRow);
            this->__isset.stopRow = 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_LIST) {
            {
              this->columns.clear();
              uint32_t _size36;
              ::apache::thrift::protocol::TType _etype39;
              xfer += iprot->readListBegin(_etype39, _size36);
              this->columns.resize(_size36);
              uint32_t _i40;
              for (_i40 = 0; _i40 < _size36; ++_i40)
              {
                xfer += iprot->readBinary(this->columns[_i40]);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.columns = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 5:
          if (ftype == ::apache::thrift::protocol::T_I32) {
            xfer += iprot->readI32(this->caching);
            this->__isset.caching = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 6:
          if (ftype == ::apache::thrift::protocol::T_STRING) {
            xfer += iprot->readBinary(this->filterString);
            this->__isset.filterString = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 7:
          if (ftype == ::apache::thrift::protocol::T_I32) {
            xfer += iprot->readI32(this->batchSize);
            this->__isset.batchSize = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 8:
          if (ftype == ::apache::thrift::protocol::T_BOOL) {
            xfer += iprot->readBool(this->sortColumns);
            this->__isset.sortColumns = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 9:
          if (ftype == ::apache::thrift::protocol::T_BOOL) {
            xfer += iprot->readBool(this->reversed);
            this->__isset.reversed = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  uint32_t TScan::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    oprot->incrementRecursionDepth();
    xfer += oprot->writeStructBegin("TScan");
  
    if (this->__isset.startRow) {
      xfer += oprot->writeFieldBegin("startRow", ::apache::thrift::protocol::T_STRING, 1);
      xfer += oprot->writeBinary(this->startRow);
      xfer += oprot->writeFieldEnd();
    }
    if (this->__isset.stopRow) {
      xfer += oprot->writeFieldBegin("stopRow", ::apache::thrift::protocol::T_STRING, 2);
      xfer += oprot->writeBinary(this->stopRow);
      xfer += oprot->writeFieldEnd();
    }
    if (this->__isset.timestamp) {
      xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 3);
      xfer += oprot->writeI64(this->timestamp);
      xfer += oprot->writeFieldEnd();
    }
    if (this->__isset.columns) {
      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 _iter41;
        for (_iter41 = this->columns.begin(); _iter41 != this->columns.end(); ++_iter41)
        {
          xfer += oprot->writeBinary((*_iter41));
        }
        xfer += oprot->writeListEnd();
      }
      xfer += oprot->writeFieldEnd();
    }
    if (this->__isset.caching) {
      xfer += oprot->writeFieldBegin("caching", ::apache::thrift::protocol::T_I32, 5);
      xfer += oprot->writeI32(this->caching);
      xfer += oprot->writeFieldEnd();
    }
    if (this->__isset.filterString) {
      xfer += oprot->writeFieldBegin("filterString", ::apache::thrift::protocol::T_STRING, 6);
      xfer += oprot->writeBinary(this->filterString);
      xfer += oprot->writeFieldEnd();
    }
    if (this->__isset.batchSize) {
      xfer += oprot->writeFieldBegin("batchSize", ::apache::thrift::protocol::T_I32, 7);
      xfer += oprot->writeI32(this->batchSize);
      xfer += oprot->writeFieldEnd();
    }
    if (this->__isset.sortColumns) {
      xfer += oprot->writeFieldBegin("sortColumns", ::apache::thrift::protocol::T_BOOL, 8);
      xfer += oprot->writeBool(this->sortColumns);
      xfer += oprot->writeFieldEnd();
    }
    if (this->__isset.reversed) {
      xfer += oprot->writeFieldBegin("reversed", ::apache::thrift::protocol::T_BOOL, 9);
      xfer += oprot->writeBool(this->reversed);
      xfer += oprot->writeFieldEnd();
    }
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    oprot->decrementRecursionDepth();
    return xfer;
  }
  
  void swap(TScan &a, TScan &b) {
    using ::std::swap;
    swap(a.startRow, b.startRow);
    swap(a.stopRow, b.stopRow);
    swap(a.timestamp, b.timestamp);
    swap(a.columns, b.columns);
    swap(a.caching, b.caching);
    swap(a.filterString, b.filterString);
    swap(a.batchSize, b.batchSize);
    swap(a.sortColumns, b.sortColumns);
    swap(a.reversed, b.reversed);
    swap(a.__isset, b.__isset);
  }
  
  TScan::TScan(const TScan& other42) {
    startRow = other42.startRow;
    stopRow = other42.stopRow;
    timestamp = other42.timestamp;
    columns = other42.columns;
    caching = other42.caching;
    filterString = other42.filterString;
    batchSize = other42.batchSize;
    sortColumns = other42.sortColumns;
    reversed = other42.reversed;
    __isset = other42.__isset;
  }
  TScan& TScan::operator=(const TScan& other43) {
    startRow = other43.startRow;
    stopRow = other43.stopRow;
    timestamp = other43.timestamp;
    columns = other43.columns;
    caching = other43.caching;
    filterString = other43.filterString;
    batchSize = other43.batchSize;
    sortColumns = other43.sortColumns;
    reversed = other43.reversed;
    __isset = other43.__isset;
    return *this;
  }
  std::ostream& operator<<(std::ostream& out, const TScan& obj) {
    using apache::thrift::to_string;
    out << "TScan(";
    out << "startRow="; (obj.__isset.startRow ? (out << to_string(obj.startRow)) : (out << "<null>"));
    out << ", " << "stopRow="; (obj.__isset.stopRow ? (out << to_string(obj.stopRow)) : (out << "<null>"));
    out << ", " << "timestamp="; (obj.__isset.timestamp ? (out << to_string(obj.timestamp)) : (out << "<null>"));
    out << ", " << "columns="; (obj.__isset.columns ? (out << to_string(obj.columns)) : (out << "<null>"));
    out << ", " << "caching="; (obj.__isset.caching ? (out << to_string(obj.caching)) : (out << "<null>"));
    out << ", " << "filterString="; (obj.__isset.filterString ? (out << to_string(obj.filterString)) : (out << "<null>"));
    out << ", " << "batchSize="; (obj.__isset.batchSize ? (out << to_string(obj.batchSize)) : (out << "<null>"));
    out << ", " << "sortColumns="; (obj.__isset.sortColumns ? (out << to_string(obj.sortColumns)) : (out << "<null>"));
    out << ", " << "reversed="; (obj.__isset.reversed ? (out << to_string(obj.reversed)) : (out << "<null>"));
    out << ")";
    return out;
  }
  
  
  TAppend::~TAppend() throw() {
  }
  
  
  void TAppend::__set_table(const Text& val) {
    this->table = val;
  }
  
  void TAppend::__set_row(const Text& val) {
    this->row = val;
  }
  
  void TAppend::__set_columns(const std::vector<Text> & val) {
    this->columns = val;
  }
  
  void TAppend::__set_values(const std::vector<Text> & val) {
    this->values = val;
  }
  
  const char* TAppend::ascii_fingerprint = "5F51D90BC323BCE4B704B7D98EDA0BD4";
  const uint8_t TAppend::binary_fingerprint[16] = {0x5F,0x51,0xD9,0x0B,0xC3,0x23,0xBC,0xE4,0xB7,0x04,0xB7,0xD9,0x8E,0xDA,0x0B,0xD4};
  
  uint32_t TAppend::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->table);
            this->__isset.table = 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 _size44;
              ::apache::thrift::protocol::TType _etype47;
              xfer += iprot->readListBegin(_etype47, _size44);
              this->columns.resize(_size44);
              uint32_t _i48;
              for (_i48 = 0; _i48 < _size44; ++_i48)
              {
                xfer += iprot->readBinary(this->columns[_i48]);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.columns = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 4:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->values.clear();
              uint32_t _size49;
              ::apache::thrift::protocol::TType _etype52;
              xfer += iprot->readListBegin(_etype52, _size49);
              this->values.resize(_size49);
              uint32_t _i53;
              for (_i53 = 0; _i53 < _size49; ++_i53)
              {
                xfer += iprot->readBinary(this->values[_i53]);
              }
              xfer += iprot->readListEnd();
            }
            this->__isset.values = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  uint32_t TAppend::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    oprot->incrementRecursionDepth();
    xfer += oprot->writeStructBegin("TAppend");
  
    xfer += oprot->writeFieldBegin("table", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeBinary(this->table);
    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 _iter54;
      for (_iter54 = this->columns.begin(); _iter54 != this->columns.end(); ++_iter54)
      {
        xfer += oprot->writeBinary((*_iter54));
      }
      xfer += oprot->writeListEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("values", ::apache::thrift::protocol::T_LIST, 4);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->values.size()));
      std::vector<Text> ::const_iterator _iter55;
      for (_iter55 = this->values.begin(); _iter55 != this->values.end(); ++_iter55)
      {
        xfer += oprot->writeBinary((*_iter55));
      }
      xfer += oprot->writeListEnd();
    }
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    oprot->decrementRecursionDepth();
    return xfer;
  }
  
  void swap(TAppend &a, TAppend &b) {
    using ::std::swap;
    swap(a.table, b.table);
    swap(a.row, b.row);
    swap(a.columns, b.columns);
    swap(a.values, b.values);
    swap(a.__isset, b.__isset);
  }
  
  TAppend::TAppend(const TAppend& other56) {
    table = other56.table;
    row = other56.row;
    columns = other56.columns;
    values = other56.values;
    __isset = other56.__isset;
  }
  TAppend& TAppend::operator=(const TAppend& other57) {
    table = other57.table;
    row = other57.row;
    columns = other57.columns;
    values = other57.values;
    __isset = other57.__isset;
    return *this;
  }
  std::ostream& operator<<(std::ostream& out, const TAppend& obj) {
    using apache::thrift::to_string;
    out << "TAppend(";
    out << "table=" << to_string(obj.table);
    out << ", " << "row=" << to_string(obj.row);
    out << ", " << "columns=" << to_string(obj.columns);
    out << ", " << "values=" << to_string(obj.values);
    out << ")";
    return out;
  }
  
  
  IOError::~IOError() throw() {
  }
  
  
  void IOError::__set_message(const std::string& val) {
    this->message = val;
  }
  
  const char* IOError::ascii_fingerprint = "EFB929595D312AC8F305D5A794CFEDA1";
  const uint8_t IOError::binary_fingerprint[16] = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
  
  uint32_t IOError::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->readString(this->message);
            this->__isset.message = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  uint32_t IOError::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    oprot->incrementRecursionDepth();
    xfer += oprot->writeStructBegin("IOError");
  
    xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeString(this->message);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    oprot->decrementRecursionDepth();
    return xfer;
  }
  
  void swap(IOError &a, IOError &b) {
    using ::std::swap;
    swap(a.message, b.message);
    swap(a.__isset, b.__isset);
  }
  
  IOError::IOError(const IOError& other58) : TException() {
    message = other58.message;
    __isset = other58.__isset;
  }
  IOError& IOError::operator=(const IOError& other59) {
    message = other59.message;
    __isset = other59.__isset;
    return *this;
  }
  std::ostream& operator<<(std::ostream& out, const IOError& obj) {
    using apache::thrift::to_string;
    out << "IOError(";
    out << "message=" << to_string(obj.message);
    out << ")";
    return out;
  }
  
  
  IllegalArgument::~IllegalArgument() throw() {
  }
  
  
  void IllegalArgument::__set_message(const std::string& val) {
    this->message = val;
  }
  
  const char* IllegalArgument::ascii_fingerprint = "EFB929595D312AC8F305D5A794CFEDA1";
  const uint8_t IllegalArgument::binary_fingerprint[16] = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
  
  uint32_t IllegalArgument::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->readString(this->message);
            this->__isset.message = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  uint32_t IllegalArgument::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    oprot->incrementRecursionDepth();
    xfer += oprot->writeStructBegin("IllegalArgument");
  
    xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeString(this->message);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    oprot->decrementRecursionDepth();
    return xfer;
  }
  
  void swap(IllegalArgument &a, IllegalArgument &b) {
    using ::std::swap;
    swap(a.message, b.message);
    swap(a.__isset, b.__isset);
  }
  
  IllegalArgument::IllegalArgument(const IllegalArgument& other60) : TException() {
    message = other60.message;
    __isset = other60.__isset;
  }
  IllegalArgument& IllegalArgument::operator=(const IllegalArgument& other61) {
    message = other61.message;
    __isset = other61.__isset;
    return *this;
  }
  std::ostream& operator<<(std::ostream& out, const IllegalArgument& obj) {
    using apache::thrift::to_string;
    out << "IllegalArgument(";
    out << "message=" << to_string(obj.message);
    out << ")";
    return out;
  }
  
  
  AlreadyExists::~AlreadyExists() throw() {
  }
  
  
  void AlreadyExists::__set_message(const std::string& val) {
    this->message = val;
  }
  
  const char* AlreadyExists::ascii_fingerprint = "EFB929595D312AC8F305D5A794CFEDA1";
  const uint8_t AlreadyExists::binary_fingerprint[16] = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
  
  uint32_t AlreadyExists::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->readString(this->message);
            this->__isset.message = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  uint32_t AlreadyExists::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    oprot->incrementRecursionDepth();
    xfer += oprot->writeStructBegin("AlreadyExists");
  
    xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeString(this->message);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    oprot->decrementRecursionDepth();
    return xfer;
  }
  
  void swap(AlreadyExists &a, AlreadyExists &b) {
    using ::std::swap;
    swap(a.message, b.message);
    swap(a.__isset, b.__isset);
  }
  
  AlreadyExists::AlreadyExists(const AlreadyExists& other62) : TException() {
    message = other62.message;
    __isset = other62.__isset;
  }
  AlreadyExists& AlreadyExists::operator=(const AlreadyExists& other63) {
    message = other63.message;
    __isset = other63.__isset;
    return *this;
  }
  std::ostream& operator<<(std::ostream& out, const AlreadyExists& obj) {
    using apache::thrift::to_string;
    out << "AlreadyExists(";
    out << "message=" << to_string(obj.message);
    out << ")";
    return out;
  }
  
  }}}} // namespace
  