text: /**
   * Autogenerated by Thrift Compiler (0.14.2)
   *
   * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
   *  @generated
   */
  #include "SeekRPC.h"
  
  namespace SeekRPC {
  
  
  SeekRPC_seekQuery_args::~SeekRPC_seekQuery_args() noexcept {
  }
  
  
  uint32_t SeekRPC_seekQuery_args::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    ::apache::thrift::protocol::TInputRecursionTracker tracker(*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->query.read(iprot);
            this->__isset.query = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  uint32_t SeekRPC_seekQuery_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
    xfer += oprot->writeStructBegin("SeekRPC_seekQuery_args");
  
    xfer += oprot->writeFieldBegin("query", ::apache::thrift::protocol::T_STRUCT, 1);
    xfer += this->query.write(oprot);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  
  SeekRPC_seekQuery_pargs::~SeekRPC_seekQuery_pargs() noexcept {
  }
  
  
  uint32_t SeekRPC_seekQuery_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
    xfer += oprot->writeStructBegin("SeekRPC_seekQuery_pargs");
  
    xfer += oprot->writeFieldBegin("query", ::apache::thrift::protocol::T_STRUCT, 1);
    xfer += (*(this->query)).write(oprot);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  
  SeekRPC_seekQuery_result::~SeekRPC_seekQuery_result() noexcept {
  }
  
  
  uint32_t SeekRPC_seekQuery_result::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    ::apache::thrift::protocol::TInputRecursionTracker tracker(*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;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  uint32_t SeekRPC_seekQuery_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("SeekRPC_seekQuery_result");
  
    if (this->__isset.success) {
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0);
      xfer += this->success.write(oprot);
      xfer += oprot->writeFieldEnd();
    }
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  
  SeekRPC_seekQuery_presult::~SeekRPC_seekQuery_presult() noexcept {
  }
  
  
  uint32_t SeekRPC_seekQuery_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    ::apache::thrift::protocol::TInputRecursionTracker tracker(*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;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  
  SeekRPC_seekQueryAsync_args::~SeekRPC_seekQueryAsync_args() noexcept {
  }
  
  
  uint32_t SeekRPC_seekQueryAsync_args::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    ::apache::thrift::protocol::TInputRecursionTracker tracker(*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->query.read(iprot);
            this->__isset.query = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  uint32_t SeekRPC_seekQueryAsync_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
    xfer += oprot->writeStructBegin("SeekRPC_seekQueryAsync_args");
  
    xfer += oprot->writeFieldBegin("query", ::apache::thrift::protocol::T_STRUCT, 1);
    xfer += this->query.write(oprot);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  
  SeekRPC_seekQueryAsync_pargs::~SeekRPC_seekQueryAsync_pargs() noexcept {
  }
  
  
  uint32_t SeekRPC_seekQueryAsync_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
    xfer += oprot->writeStructBegin("SeekRPC_seekQueryAsync_pargs");
  
    xfer += oprot->writeFieldBegin("query", ::apache::thrift::protocol::T_STRUCT, 1);
    xfer += (*(this->query)).write(oprot);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  
  SeekRPC_seekQueryAsync_result::~SeekRPC_seekQueryAsync_result() noexcept {
  }
  
  
  uint32_t SeekRPC_seekQueryAsync_result::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    ::apache::thrift::protocol::TInputRecursionTracker tracker(*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;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  uint32_t SeekRPC_seekQueryAsync_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("SeekRPC_seekQueryAsync_result");
  
    if (this->__isset.success) {
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I64, 0);
      xfer += oprot->writeI64(this->success);
      xfer += oprot->writeFieldEnd();
    }
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  
  SeekRPC_seekQueryAsync_presult::~SeekRPC_seekQueryAsync_presult() noexcept {
  }
  
  
  uint32_t SeekRPC_seekQueryAsync_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    ::apache::thrift::protocol::TInputRecursionTracker tracker(*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;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  
  SeekRPC_getSeekResult_args::~SeekRPC_getSeekResult_args() noexcept {
  }
  
  
  uint32_t SeekRPC_getSeekResult_args::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    ::apache::thrift::protocol::TInputRecursionTracker tracker(*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_I64) {
            xfer += iprot->readI64(this->taskId);
            this->__isset.taskId = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::thrift::protocol::T_BOOL) {
            xfer += iprot->readBool(this->block);
            this->__isset.block = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  uint32_t SeekRPC_getSeekResult_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
    xfer += oprot->writeStructBegin("SeekRPC_getSeekResult_args");
  
    xfer += oprot->writeFieldBegin("taskId", ::apache::thrift::protocol::T_I64, 1);
    xfer += oprot->writeI64(this->taskId);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("block", ::apache::thrift::protocol::T_BOOL, 2);
    xfer += oprot->writeBool(this->block);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  
  SeekRPC_getSeekResult_pargs::~SeekRPC_getSeekResult_pargs() noexcept {
  }
  
  
  uint32_t SeekRPC_getSeekResult_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
    xfer += oprot->writeStructBegin("SeekRPC_getSeekResult_pargs");
  
    xfer += oprot->writeFieldBegin("taskId", ::apache::thrift::protocol::T_I64, 1);
    xfer += oprot->writeI64((*(this->taskId)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("block", ::apache::thrift::protocol::T_BOOL, 2);
    xfer += oprot->writeBool((*(this->block)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  
  SeekRPC_getSeekResult_result::~SeekRPC_getSeekResult_result() noexcept {
  }
  
  
  uint32_t SeekRPC_getSeekResult_result::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    ::apache::thrift::protocol::TInputRecursionTracker tracker(*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;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  uint32_t SeekRPC_getSeekResult_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("SeekRPC_getSeekResult_result");
  
    if (this->__isset.success) {
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0);
      xfer += this->success.write(oprot);
      xfer += oprot->writeFieldEnd();
    }
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  
  SeekRPC_getSeekResult_presult::~SeekRPC_getSeekResult_presult() noexcept {
  }
  
  
  uint32_t SeekRPC_getSeekResult_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    ::apache::thrift::protocol::TInputRecursionTracker tracker(*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;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  
  SeekRPC_isQueryComplete_args::~SeekRPC_isQueryComplete_args() noexcept {
  }
  
  
  uint32_t SeekRPC_isQueryComplete_args::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    ::apache::thrift::protocol::TInputRecursionTracker tracker(*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_I64) {
            xfer += iprot->readI64(this->taskId);
            this->__isset.taskId = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  uint32_t SeekRPC_isQueryComplete_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
    xfer += oprot->writeStructBegin("SeekRPC_isQueryComplete_args");
  
    xfer += oprot->writeFieldBegin("taskId", ::apache::thrift::protocol::T_I64, 1);
    xfer += oprot->writeI64(this->taskId);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  
  SeekRPC_isQueryComplete_pargs::~SeekRPC_isQueryComplete_pargs() noexcept {
  }
  
  
  uint32_t SeekRPC_isQueryComplete_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
    xfer += oprot->writeStructBegin("SeekRPC_isQueryComplete_pargs");
  
    xfer += oprot->writeFieldBegin("taskId", ::apache::thrift::protocol::T_I64, 1);
    xfer += oprot->writeI64((*(this->taskId)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  
  SeekRPC_isQueryComplete_result::~SeekRPC_isQueryComplete_result() noexcept {
  }
  
  
  uint32_t SeekRPC_isQueryComplete_result::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    ::apache::thrift::protocol::TInputRecursionTracker tracker(*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;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  uint32_t SeekRPC_isQueryComplete_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("SeekRPC_isQueryComplete_result");
  
    if (this->__isset.success) {
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0);
      xfer += oprot->writeBool(this->success);
      xfer += oprot->writeFieldEnd();
    }
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  
  SeekRPC_isQueryComplete_presult::~SeekRPC_isQueryComplete_presult() noexcept {
  }
  
  
  uint32_t SeekRPC_isQueryComplete_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    ::apache::thrift::protocol::TInputRecursionTracker tracker(*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;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  
  SeekRPC_getProgressMessage_args::~SeekRPC_getProgressMessage_args() noexcept {
  }
  
  
  uint32_t SeekRPC_getProgressMessage_args::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    ::apache::thrift::protocol::TInputRecursionTracker tracker(*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_I64) {
            xfer += iprot->readI64(this->taskId);
            this->__isset.taskId = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  uint32_t SeekRPC_getProgressMessage_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
    xfer += oprot->writeStructBegin("SeekRPC_getProgressMessage_args");
  
    xfer += oprot->writeFieldBegin("taskId", ::apache::thrift::protocol::T_I64, 1);
    xfer += oprot->writeI64(this->taskId);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  
  SeekRPC_getProgressMessage_pargs::~SeekRPC_getProgressMessage_pargs() noexcept {
  }
  
  
  uint32_t SeekRPC_getProgressMessage_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
    xfer += oprot->writeStructBegin("SeekRPC_getProgressMessage_pargs");
  
    xfer += oprot->writeFieldBegin("taskId", ::apache::thrift::protocol::T_I64, 1);
    xfer += oprot->writeI64((*(this->taskId)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  
  SeekRPC_getProgressMessage_result::~SeekRPC_getProgressMessage_result() noexcept {
  }
  
  
  uint32_t SeekRPC_getProgressMessage_result::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    ::apache::thrift::protocol::TInputRecursionTracker tracker(*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_STRING) {
            xfer += iprot->readString(this->success);
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  uint32_t SeekRPC_getProgressMessage_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("SeekRPC_getProgressMessage_result");
  
    if (this->__isset.success) {
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRING, 0);
      xfer += oprot->writeString(this->success);
      xfer += oprot->writeFieldEnd();
    }
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  
  SeekRPC_getProgressMessage_presult::~SeekRPC_getProgressMessage_presult() noexcept {
  }
  
  
  uint32_t SeekRPC_getProgressMessage_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    ::apache::thrift::protocol::TInputRecursionTracker tracker(*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_STRING) {
            xfer += iprot->readString((*(this->success)));
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  
  SeekRPC_getRpcVersion_args::~SeekRPC_getRpcVersion_args() noexcept {
  }
  
  
  uint32_t SeekRPC_getRpcVersion_args::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    ::apache::thrift::protocol::TInputRecursionTracker tracker(*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 SeekRPC_getRpcVersion_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
    xfer += oprot->writeStructBegin("SeekRPC_getRpcVersion_args");
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  
  SeekRPC_getRpcVersion_pargs::~SeekRPC_getRpcVersion_pargs() noexcept {
  }
  
  
  uint32_t SeekRPC_getRpcVersion_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
    xfer += oprot->writeStructBegin("SeekRPC_getRpcVersion_pargs");
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  
  SeekRPC_getRpcVersion_result::~SeekRPC_getRpcVersion_result() noexcept {
  }
  
  
  uint32_t SeekRPC_getRpcVersion_result::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    ::apache::thrift::protocol::TInputRecursionTracker tracker(*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;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  uint32_t SeekRPC_getRpcVersion_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("SeekRPC_getRpcVersion_result");
  
    if (this->__isset.success) {
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I32, 0);
      xfer += oprot->writeI32(this->success);
      xfer += oprot->writeFieldEnd();
    }
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  
  SeekRPC_getRpcVersion_presult::~SeekRPC_getRpcVersion_presult() noexcept {
  }
  
  
  uint32_t SeekRPC_getRpcVersion_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    ::apache::thrift::protocol::TInputRecursionTracker tracker(*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;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  
  SeekRPC_ping_args::~SeekRPC_ping_args() noexcept {
  }
  
  
  uint32_t SeekRPC_ping_args::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    ::apache::thrift::protocol::TInputRecursionTracker tracker(*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 SeekRPC_ping_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
    xfer += oprot->writeStructBegin("SeekRPC_ping_args");
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  
  SeekRPC_ping_pargs::~SeekRPC_ping_pargs() noexcept {
  }
  
  
  uint32_t SeekRPC_ping_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
    xfer += oprot->writeStructBegin("SeekRPC_ping_pargs");
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  
  SeekRPC_ping_result::~SeekRPC_ping_result() noexcept {
  }
  
  
  uint32_t SeekRPC_ping_result::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    ::apache::thrift::protocol::TInputRecursionTracker tracker(*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;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  uint32_t SeekRPC_ping_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("SeekRPC_ping_result");
  
    if (this->__isset.success) {
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I32, 0);
      xfer += oprot->writeI32(this->success);
      xfer += oprot->writeFieldEnd();
    }
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  
  SeekRPC_ping_presult::~SeekRPC_ping_presult() noexcept {
  }
  
  
  uint32_t SeekRPC_ping_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    ::apache::thrift::protocol::TInputRecursionTracker tracker(*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;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  
  SeekRPC_pvalueGenes_args::~SeekRPC_pvalueGenes_args() noexcept {
  }
  
  
  uint32_t SeekRPC_pvalueGenes_args::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    ::apache::thrift::protocol::TInputRecursionTracker tracker(*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 SeekRPC_pvalueGenes_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
    xfer += oprot->writeStructBegin("SeekRPC_pvalueGenes_args");
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  
  SeekRPC_pvalueGenes_pargs::~SeekRPC_pvalueGenes_pargs() noexcept {
  }
  
  
  uint32_t SeekRPC_pvalueGenes_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
    xfer += oprot->writeStructBegin("SeekRPC_pvalueGenes_pargs");
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  
  SeekRPC_pvalueGenes_result::~SeekRPC_pvalueGenes_result() noexcept {
  }
  
  
  uint32_t SeekRPC_pvalueGenes_result::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    ::apache::thrift::protocol::TInputRecursionTracker tracker(*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;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  uint32_t SeekRPC_pvalueGenes_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("SeekRPC_pvalueGenes_result");
  
    if (this->__isset.success) {
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I32, 0);
      xfer += oprot->writeI32(this->success);
      xfer += oprot->writeFieldEnd();
    }
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  
  SeekRPC_pvalueGenes_presult::~SeekRPC_pvalueGenes_presult() noexcept {
  }
  
  
  uint32_t SeekRPC_pvalueGenes_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    ::apache::thrift::protocol::TInputRecursionTracker tracker(*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;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  
  SeekRPC_pvalueDatasets_args::~SeekRPC_pvalueDatasets_args() noexcept {
  }
  
  
  uint32_t SeekRPC_pvalueDatasets_args::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    ::apache::thrift::protocol::TInputRecursionTracker tracker(*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 SeekRPC_pvalueDatasets_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
    xfer += oprot->writeStructBegin("SeekRPC_pvalueDatasets_args");
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  
  SeekRPC_pvalueDatasets_pargs::~SeekRPC_pvalueDatasets_pargs() noexcept {
  }
  
  
  uint32_t SeekRPC_pvalueDatasets_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
    xfer += oprot->writeStructBegin("SeekRPC_pvalueDatasets_pargs");
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  
  SeekRPC_pvalueDatasets_result::~SeekRPC_pvalueDatasets_result() noexcept {
  }
  
  
  uint32_t SeekRPC_pvalueDatasets_result::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    ::apache::thrift::protocol::TInputRecursionTracker tracker(*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;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  uint32_t SeekRPC_pvalueDatasets_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("SeekRPC_pvalueDatasets_result");
  
    if (this->__isset.success) {
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I32, 0);
      xfer += oprot->writeI32(this->success);
      xfer += oprot->writeFieldEnd();
    }
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  
  SeekRPC_pvalueDatasets_presult::~SeekRPC_pvalueDatasets_presult() noexcept {
  }
  
  
  uint32_t SeekRPC_pvalueDatasets_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    ::apache::thrift::protocol::TInputRecursionTracker tracker(*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;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  
  SeekRPC_pclQuery_args::~SeekRPC_pclQuery_args() noexcept {
  }
  
  
  uint32_t SeekRPC_pclQuery_args::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    ::apache::thrift::protocol::TInputRecursionTracker tracker(*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->query.read(iprot);
            this->__isset.query = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  uint32_t SeekRPC_pclQuery_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
    xfer += oprot->writeStructBegin("SeekRPC_pclQuery_args");
  
    xfer += oprot->writeFieldBegin("query", ::apache::thrift::protocol::T_STRUCT, 1);
    xfer += this->query.write(oprot);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  
  SeekRPC_pclQuery_pargs::~SeekRPC_pclQuery_pargs() noexcept {
  }
  
  
  uint32_t SeekRPC_pclQuery_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
    xfer += oprot->writeStructBegin("SeekRPC_pclQuery_pargs");
  
    xfer += oprot->writeFieldBegin("query", ::apache::thrift::protocol::T_STRUCT, 1);
    xfer += (*(this->query)).write(oprot);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  
  SeekRPC_pclQuery_result::~SeekRPC_pclQuery_result() noexcept {
  }
  
  
  uint32_t SeekRPC_pclQuery_result::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    ::apache::thrift::protocol::TInputRecursionTracker tracker(*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;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  uint32_t SeekRPC_pclQuery_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("SeekRPC_pclQuery_result");
  
    if (this->__isset.success) {
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0);
      xfer += this->success.write(oprot);
      xfer += oprot->writeFieldEnd();
    }
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  
  SeekRPC_pclQuery_presult::~SeekRPC_pclQuery_presult() noexcept {
  }
  
  
  uint32_t SeekRPC_pclQuery_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    ::apache::thrift::protocol::TInputRecursionTracker tracker(*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;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  
  SeekRPC_pclQueryAsync_args::~SeekRPC_pclQueryAsync_args() noexcept {
  }
  
  
  uint32_t SeekRPC_pclQueryAsync_args::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    ::apache::thrift::protocol::TInputRecursionTracker tracker(*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->query.read(iprot);
            this->__isset.query = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  uint32_t SeekRPC_pclQueryAsync_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
    xfer += oprot->writeStructBegin("SeekRPC_pclQueryAsync_args");
  
    xfer += oprot->writeFieldBegin("query", ::apache::thrift::protocol::T_STRUCT, 1);
    xfer += this->query.write(oprot);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  
  SeekRPC_pclQueryAsync_pargs::~SeekRPC_pclQueryAsync_pargs() noexcept {
  }
  
  
  uint32_t SeekRPC_pclQueryAsync_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
    xfer += oprot->writeStructBegin("SeekRPC_pclQueryAsync_pargs");
  
    xfer += oprot->writeFieldBegin("query", ::apache::thrift::protocol::T_STRUCT, 1);
    xfer += (*(this->query)).write(oprot);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  
  SeekRPC_pclQueryAsync_result::~SeekRPC_pclQueryAsync_result() noexcept {
  }
  
  
  uint32_t SeekRPC_pclQueryAsync_result::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    ::apache::thrift::protocol::TInputRecursionTracker tracker(*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;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  uint32_t SeekRPC_pclQueryAsync_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("SeekRPC_pclQueryAsync_result");
  
    if (this->__isset.success) {
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I64, 0);
      xfer += oprot->writeI64(this->success);
      xfer += oprot->writeFieldEnd();
    }
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  
  SeekRPC_pclQueryAsync_presult::~SeekRPC_pclQueryAsync_presult() noexcept {
  }
  
  
  uint32_t SeekRPC_pclQueryAsync_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    ::apache::thrift::protocol::TInputRecursionTracker tracker(*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;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  
  SeekRPC_getPclResult_args::~SeekRPC_getPclResult_args() noexcept {
  }
  
  
  uint32_t SeekRPC_getPclResult_args::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    ::apache::thrift::protocol::TInputRecursionTracker tracker(*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_I64) {
            xfer += iprot->readI64(this->taskId);
            this->__isset.taskId = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        case 2:
          if (ftype == ::apache::thrift::protocol::T_BOOL) {
            xfer += iprot->readBool(this->block);
            this->__isset.block = true;
          } else {
            xfer += iprot->skip(ftype);
          }
          break;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  uint32_t SeekRPC_getPclResult_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
    xfer += oprot->writeStructBegin("SeekRPC_getPclResult_args");
  
    xfer += oprot->writeFieldBegin("taskId", ::apache::thrift::protocol::T_I64, 1);
    xfer += oprot->writeI64(this->taskId);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("block", ::apache::thrift::protocol::T_BOOL, 2);
    xfer += oprot->writeBool(this->block);
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  
  SeekRPC_getPclResult_pargs::~SeekRPC_getPclResult_pargs() noexcept {
  }
  
  
  uint32_t SeekRPC_getPclResult_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
    ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
    xfer += oprot->writeStructBegin("SeekRPC_getPclResult_pargs");
  
    xfer += oprot->writeFieldBegin("taskId", ::apache::thrift::protocol::T_I64, 1);
    xfer += oprot->writeI64((*(this->taskId)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldBegin("block", ::apache::thrift::protocol::T_BOOL, 2);
    xfer += oprot->writeBool((*(this->block)));
    xfer += oprot->writeFieldEnd();
  
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  
  SeekRPC_getPclResult_result::~SeekRPC_getPclResult_result() noexcept {
  }
  
  
  uint32_t SeekRPC_getPclResult_result::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    ::apache::thrift::protocol::TInputRecursionTracker tracker(*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;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  uint32_t SeekRPC_getPclResult_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
  
    uint32_t xfer = 0;
  
    xfer += oprot->writeStructBegin("SeekRPC_getPclResult_result");
  
    if (this->__isset.success) {
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0);
      xfer += this->success.write(oprot);
      xfer += oprot->writeFieldEnd();
    }
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }
  
  
  SeekRPC_getPclResult_presult::~SeekRPC_getPclResult_presult() noexcept {
  }
  
  
  uint32_t SeekRPC_getPclResult_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
  
    ::apache::thrift::protocol::TInputRecursionTracker tracker(*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;
        default:
          xfer += iprot->skip(ftype);
          break;
      }
      xfer += iprot->readFieldEnd();
    }
  
    xfer += iprot->readStructEnd();
  
    return xfer;
  }
  
  void SeekRPCClient::seekQuery(SeekResult& _return, const SeekQueryArgs& query)
  {
    send_seekQuery(query);
    recv_seekQuery(_return);
  }
  
  void SeekRPCClient::send_seekQuery(const SeekQueryArgs& query)
  {
    int32_t cseqid = 0;
    oprot_->writeMessageBegin("seekQuery", ::apache::thrift::protocol::T_CALL, cseqid);
  
    SeekRPC_seekQuery_pargs args;
    args.query = &query;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  void SeekRPCClient::recv_seekQuery(SeekResult& _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("seekQuery") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    SeekRPC_seekQuery_presult result;
    result.success = &_return;
    result.read(iprot_);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
  
    if (result.__isset.success) {
      // _return pointer has now been filled
      return;
    }
    throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "seekQuery failed: unknown result");
  }
  
  int64_t SeekRPCClient::seekQueryAsync(const SeekQueryArgs& query)
  {
    send_seekQueryAsync(query);
    return recv_seekQueryAsync();
  }
  
  void SeekRPCClient::send_seekQueryAsync(const SeekQueryArgs& query)
  {
    int32_t cseqid = 0;
    oprot_->writeMessageBegin("seekQueryAsync", ::apache::thrift::protocol::T_CALL, cseqid);
  
    SeekRPC_seekQueryAsync_pargs args;
    args.query = &query;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  int64_t SeekRPCClient::recv_seekQueryAsync()
  {
  
    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("seekQueryAsync") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    int64_t _return;
    SeekRPC_seekQueryAsync_presult result;
    result.success = &_return;
    result.read(iprot_);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
  
    if (result.__isset.success) {
      return _return;
    }
    throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "seekQueryAsync failed: unknown result");
  }
  
  void SeekRPCClient::getSeekResult(SeekResult& _return, const int64_t taskId, const bool block)
  {
    send_getSeekResult(taskId, block);
    recv_getSeekResult(_return);
  }
  
  void SeekRPCClient::send_getSeekResult(const int64_t taskId, const bool block)
  {
    int32_t cseqid = 0;
    oprot_->writeMessageBegin("getSeekResult", ::apache::thrift::protocol::T_CALL, cseqid);
  
    SeekRPC_getSeekResult_pargs args;
    args.taskId = &taskId;
    args.block = &block;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  void SeekRPCClient::recv_getSeekResult(SeekResult& _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("getSeekResult") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    SeekRPC_getSeekResult_presult result;
    result.success = &_return;
    result.read(iprot_);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
  
    if (result.__isset.success) {
      // _return pointer has now been filled
      return;
    }
    throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getSeekResult failed: unknown result");
  }
  
  bool SeekRPCClient::isQueryComplete(const int64_t taskId)
  {
    send_isQueryComplete(taskId);
    return recv_isQueryComplete();
  }
  
  void SeekRPCClient::send_isQueryComplete(const int64_t taskId)
  {
    int32_t cseqid = 0;
    oprot_->writeMessageBegin("isQueryComplete", ::apache::thrift::protocol::T_CALL, cseqid);
  
    SeekRPC_isQueryComplete_pargs args;
    args.taskId = &taskId;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  bool SeekRPCClient::recv_isQueryComplete()
  {
  
    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("isQueryComplete") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    bool _return;
    SeekRPC_isQueryComplete_presult result;
    result.success = &_return;
    result.read(iprot_);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
  
    if (result.__isset.success) {
      return _return;
    }
    throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "isQueryComplete failed: unknown result");
  }
  
  void SeekRPCClient::getProgressMessage(std::string& _return, const int64_t taskId)
  {
    send_getProgressMessage(taskId);
    recv_getProgressMessage(_return);
  }
  
  void SeekRPCClient::send_getProgressMessage(const int64_t taskId)
  {
    int32_t cseqid = 0;
    oprot_->writeMessageBegin("getProgressMessage", ::apache::thrift::protocol::T_CALL, cseqid);
  
    SeekRPC_getProgressMessage_pargs args;
    args.taskId = &taskId;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  void SeekRPCClient::recv_getProgressMessage(std::string& _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("getProgressMessage") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    SeekRPC_getProgressMessage_presult result;
    result.success = &_return;
    result.read(iprot_);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
  
    if (result.__isset.success) {
      // _return pointer has now been filled
      return;
    }
    throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getProgressMessage failed: unknown result");
  }
  
  int32_t SeekRPCClient::getRpcVersion()
  {
    send_getRpcVersion();
    return recv_getRpcVersion();
  }
  
  void SeekRPCClient::send_getRpcVersion()
  {
    int32_t cseqid = 0;
    oprot_->writeMessageBegin("getRpcVersion", ::apache::thrift::protocol::T_CALL, cseqid);
  
    SeekRPC_getRpcVersion_pargs args;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  int32_t SeekRPCClient::recv_getRpcVersion()
  {
  
    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("getRpcVersion") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    int32_t _return;
    SeekRPC_getRpcVersion_presult result;
    result.success = &_return;
    result.read(iprot_);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
  
    if (result.__isset.success) {
      return _return;
    }
    throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getRpcVersion failed: unknown result");
  }
  
  int32_t SeekRPCClient::ping()
  {
    send_ping();
    return recv_ping();
  }
  
  void SeekRPCClient::send_ping()
  {
    int32_t cseqid = 0;
    oprot_->writeMessageBegin("ping", ::apache::thrift::protocol::T_CALL, cseqid);
  
    SeekRPC_ping_pargs args;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  int32_t SeekRPCClient::recv_ping()
  {
  
    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("ping") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    int32_t _return;
    SeekRPC_ping_presult result;
    result.success = &_return;
    result.read(iprot_);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
  
    if (result.__isset.success) {
      return _return;
    }
    throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "ping failed: unknown result");
  }
  
  int32_t SeekRPCClient::pvalueGenes()
  {
    send_pvalueGenes();
    return recv_pvalueGenes();
  }
  
  void SeekRPCClient::send_pvalueGenes()
  {
    int32_t cseqid = 0;
    oprot_->writeMessageBegin("pvalueGenes", ::apache::thrift::protocol::T_CALL, cseqid);
  
    SeekRPC_pvalueGenes_pargs args;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  int32_t SeekRPCClient::recv_pvalueGenes()
  {
  
    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("pvalueGenes") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    int32_t _return;
    SeekRPC_pvalueGenes_presult result;
    result.success = &_return;
    result.read(iprot_);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
  
    if (result.__isset.success) {
      return _return;
    }
    throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "pvalueGenes failed: unknown result");
  }
  
  int32_t SeekRPCClient::pvalueDatasets()
  {
    send_pvalueDatasets();
    return recv_pvalueDatasets();
  }
  
  void SeekRPCClient::send_pvalueDatasets()
  {
    int32_t cseqid = 0;
    oprot_->writeMessageBegin("pvalueDatasets", ::apache::thrift::protocol::T_CALL, cseqid);
  
    SeekRPC_pvalueDatasets_pargs args;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  int32_t SeekRPCClient::recv_pvalueDatasets()
  {
  
    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("pvalueDatasets") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    int32_t _return;
    SeekRPC_pvalueDatasets_presult result;
    result.success = &_return;
    result.read(iprot_);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
  
    if (result.__isset.success) {
      return _return;
    }
    throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "pvalueDatasets failed: unknown result");
  }
  
  void SeekRPCClient::pclQuery(PclResult& _return, const PclQueryArgs& query)
  {
    send_pclQuery(query);
    recv_pclQuery(_return);
  }
  
  void SeekRPCClient::send_pclQuery(const PclQueryArgs& query)
  {
    int32_t cseqid = 0;
    oprot_->writeMessageBegin("pclQuery", ::apache::thrift::protocol::T_CALL, cseqid);
  
    SeekRPC_pclQuery_pargs args;
    args.query = &query;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  void SeekRPCClient::recv_pclQuery(PclResult& _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("pclQuery") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    SeekRPC_pclQuery_presult result;
    result.success = &_return;
    result.read(iprot_);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
  
    if (result.__isset.success) {
      // _return pointer has now been filled
      return;
    }
    throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "pclQuery failed: unknown result");
  }
  
  int64_t SeekRPCClient::pclQueryAsync(const PclQueryArgs& query)
  {
    send_pclQueryAsync(query);
    return recv_pclQueryAsync();
  }
  
  void SeekRPCClient::send_pclQueryAsync(const PclQueryArgs& query)
  {
    int32_t cseqid = 0;
    oprot_->writeMessageBegin("pclQueryAsync", ::apache::thrift::protocol::T_CALL, cseqid);
  
    SeekRPC_pclQueryAsync_pargs args;
    args.query = &query;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  int64_t SeekRPCClient::recv_pclQueryAsync()
  {
  
    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("pclQueryAsync") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    int64_t _return;
    SeekRPC_pclQueryAsync_presult result;
    result.success = &_return;
    result.read(iprot_);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
  
    if (result.__isset.success) {
      return _return;
    }
    throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "pclQueryAsync failed: unknown result");
  }
  
  void SeekRPCClient::getPclResult(PclResult& _return, const int64_t taskId, const bool block)
  {
    send_getPclResult(taskId, block);
    recv_getPclResult(_return);
  }
  
  void SeekRPCClient::send_getPclResult(const int64_t taskId, const bool block)
  {
    int32_t cseqid = 0;
    oprot_->writeMessageBegin("getPclResult", ::apache::thrift::protocol::T_CALL, cseqid);
  
    SeekRPC_getPclResult_pargs args;
    args.taskId = &taskId;
    args.block = &block;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  }
  
  void SeekRPCClient::recv_getPclResult(PclResult& _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("getPclResult") != 0) {
      iprot_->skip(::apache::thrift::protocol::T_STRUCT);
      iprot_->readMessageEnd();
      iprot_->getTransport()->readEnd();
    }
    SeekRPC_getPclResult_presult result;
    result.success = &_return;
    result.read(iprot_);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
  
    if (result.__isset.success) {
      // _return pointer has now been filled
      return;
    }
    throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getPclResult failed: unknown result");
  }
  
  bool SeekRPCProcessor::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 SeekRPCProcessor::process_seekQuery(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = nullptr;
    if (this->eventHandler_.get() != nullptr) {
      ctx = this->eventHandler_->getContext("SeekRPC.seekQuery", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "SeekRPC.seekQuery");
  
    if (this->eventHandler_.get() != nullptr) {
      this->eventHandler_->preRead(ctx, "SeekRPC.seekQuery");
    }
  
    SeekRPC_seekQuery_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != nullptr) {
      this->eventHandler_->postRead(ctx, "SeekRPC.seekQuery", bytes);
    }
  
    SeekRPC_seekQuery_result result;
    try {
      iface_->seekQuery(result.success, args.query);
      result.__isset.success = true;
    } catch (const std::exception& e) {
      if (this->eventHandler_.get() != nullptr) {
        this->eventHandler_->handlerError(ctx, "SeekRPC.seekQuery");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("seekQuery", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != nullptr) {
      this->eventHandler_->preWrite(ctx, "SeekRPC.seekQuery");
    }
  
    oprot->writeMessageBegin("seekQuery", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != nullptr) {
      this->eventHandler_->postWrite(ctx, "SeekRPC.seekQuery", bytes);
    }
  }
  
  void SeekRPCProcessor::process_seekQueryAsync(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = nullptr;
    if (this->eventHandler_.get() != nullptr) {
      ctx = this->eventHandler_->getContext("SeekRPC.seekQueryAsync", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "SeekRPC.seekQueryAsync");
  
    if (this->eventHandler_.get() != nullptr) {
      this->eventHandler_->preRead(ctx, "SeekRPC.seekQueryAsync");
    }
  
    SeekRPC_seekQueryAsync_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != nullptr) {
      this->eventHandler_->postRead(ctx, "SeekRPC.seekQueryAsync", bytes);
    }
  
    SeekRPC_seekQueryAsync_result result;
    try {
      result.success = iface_->seekQueryAsync(args.query);
      result.__isset.success = true;
    } catch (const std::exception& e) {
      if (this->eventHandler_.get() != nullptr) {
        this->eventHandler_->handlerError(ctx, "SeekRPC.seekQueryAsync");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("seekQueryAsync", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != nullptr) {
      this->eventHandler_->preWrite(ctx, "SeekRPC.seekQueryAsync");
    }
  
    oprot->writeMessageBegin("seekQueryAsync", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != nullptr) {
      this->eventHandler_->postWrite(ctx, "SeekRPC.seekQueryAsync", bytes);
    }
  }
  
  void SeekRPCProcessor::process_getSeekResult(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = nullptr;
    if (this->eventHandler_.get() != nullptr) {
      ctx = this->eventHandler_->getContext("SeekRPC.getSeekResult", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "SeekRPC.getSeekResult");
  
    if (this->eventHandler_.get() != nullptr) {
      this->eventHandler_->preRead(ctx, "SeekRPC.getSeekResult");
    }
  
    SeekRPC_getSeekResult_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != nullptr) {
      this->eventHandler_->postRead(ctx, "SeekRPC.getSeekResult", bytes);
    }
  
    SeekRPC_getSeekResult_result result;
    try {
      iface_->getSeekResult(result.success, args.taskId, args.block);
      result.__isset.success = true;
    } catch (const std::exception& e) {
      if (this->eventHandler_.get() != nullptr) {
        this->eventHandler_->handlerError(ctx, "SeekRPC.getSeekResult");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("getSeekResult", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != nullptr) {
      this->eventHandler_->preWrite(ctx, "SeekRPC.getSeekResult");
    }
  
    oprot->writeMessageBegin("getSeekResult", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != nullptr) {
      this->eventHandler_->postWrite(ctx, "SeekRPC.getSeekResult", bytes);
    }
  }
  
  void SeekRPCProcessor::process_isQueryComplete(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = nullptr;
    if (this->eventHandler_.get() != nullptr) {
      ctx = this->eventHandler_->getContext("SeekRPC.isQueryComplete", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "SeekRPC.isQueryComplete");
  
    if (this->eventHandler_.get() != nullptr) {
      this->eventHandler_->preRead(ctx, "SeekRPC.isQueryComplete");
    }
  
    SeekRPC_isQueryComplete_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != nullptr) {
      this->eventHandler_->postRead(ctx, "SeekRPC.isQueryComplete", bytes);
    }
  
    SeekRPC_isQueryComplete_result result;
    try {
      result.success = iface_->isQueryComplete(args.taskId);
      result.__isset.success = true;
    } catch (const std::exception& e) {
      if (this->eventHandler_.get() != nullptr) {
        this->eventHandler_->handlerError(ctx, "SeekRPC.isQueryComplete");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("isQueryComplete", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != nullptr) {
      this->eventHandler_->preWrite(ctx, "SeekRPC.isQueryComplete");
    }
  
    oprot->writeMessageBegin("isQueryComplete", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != nullptr) {
      this->eventHandler_->postWrite(ctx, "SeekRPC.isQueryComplete", bytes);
    }
  }
  
  void SeekRPCProcessor::process_getProgressMessage(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = nullptr;
    if (this->eventHandler_.get() != nullptr) {
      ctx = this->eventHandler_->getContext("SeekRPC.getProgressMessage", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "SeekRPC.getProgressMessage");
  
    if (this->eventHandler_.get() != nullptr) {
      this->eventHandler_->preRead(ctx, "SeekRPC.getProgressMessage");
    }
  
    SeekRPC_getProgressMessage_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != nullptr) {
      this->eventHandler_->postRead(ctx, "SeekRPC.getProgressMessage", bytes);
    }
  
    SeekRPC_getProgressMessage_result result;
    try {
      iface_->getProgressMessage(result.success, args.taskId);
      result.__isset.success = true;
    } catch (const std::exception& e) {
      if (this->eventHandler_.get() != nullptr) {
        this->eventHandler_->handlerError(ctx, "SeekRPC.getProgressMessage");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("getProgressMessage", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != nullptr) {
      this->eventHandler_->preWrite(ctx, "SeekRPC.getProgressMessage");
    }
  
    oprot->writeMessageBegin("getProgressMessage", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != nullptr) {
      this->eventHandler_->postWrite(ctx, "SeekRPC.getProgressMessage", bytes);
    }
  }
  
  void SeekRPCProcessor::process_getRpcVersion(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = nullptr;
    if (this->eventHandler_.get() != nullptr) {
      ctx = this->eventHandler_->getContext("SeekRPC.getRpcVersion", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "SeekRPC.getRpcVersion");
  
    if (this->eventHandler_.get() != nullptr) {
      this->eventHandler_->preRead(ctx, "SeekRPC.getRpcVersion");
    }
  
    SeekRPC_getRpcVersion_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != nullptr) {
      this->eventHandler_->postRead(ctx, "SeekRPC.getRpcVersion", bytes);
    }
  
    SeekRPC_getRpcVersion_result result;
    try {
      result.success = iface_->getRpcVersion();
      result.__isset.success = true;
    } catch (const std::exception& e) {
      if (this->eventHandler_.get() != nullptr) {
        this->eventHandler_->handlerError(ctx, "SeekRPC.getRpcVersion");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("getRpcVersion", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != nullptr) {
      this->eventHandler_->preWrite(ctx, "SeekRPC.getRpcVersion");
    }
  
    oprot->writeMessageBegin("getRpcVersion", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != nullptr) {
      this->eventHandler_->postWrite(ctx, "SeekRPC.getRpcVersion", bytes);
    }
  }
  
  void SeekRPCProcessor::process_ping(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = nullptr;
    if (this->eventHandler_.get() != nullptr) {
      ctx = this->eventHandler_->getContext("SeekRPC.ping", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "SeekRPC.ping");
  
    if (this->eventHandler_.get() != nullptr) {
      this->eventHandler_->preRead(ctx, "SeekRPC.ping");
    }
  
    SeekRPC_ping_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != nullptr) {
      this->eventHandler_->postRead(ctx, "SeekRPC.ping", bytes);
    }
  
    SeekRPC_ping_result result;
    try {
      result.success = iface_->ping();
      result.__isset.success = true;
    } catch (const std::exception& e) {
      if (this->eventHandler_.get() != nullptr) {
        this->eventHandler_->handlerError(ctx, "SeekRPC.ping");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("ping", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != nullptr) {
      this->eventHandler_->preWrite(ctx, "SeekRPC.ping");
    }
  
    oprot->writeMessageBegin("ping", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != nullptr) {
      this->eventHandler_->postWrite(ctx, "SeekRPC.ping", bytes);
    }
  }
  
  void SeekRPCProcessor::process_pvalueGenes(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = nullptr;
    if (this->eventHandler_.get() != nullptr) {
      ctx = this->eventHandler_->getContext("SeekRPC.pvalueGenes", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "SeekRPC.pvalueGenes");
  
    if (this->eventHandler_.get() != nullptr) {
      this->eventHandler_->preRead(ctx, "SeekRPC.pvalueGenes");
    }
  
    SeekRPC_pvalueGenes_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != nullptr) {
      this->eventHandler_->postRead(ctx, "SeekRPC.pvalueGenes", bytes);
    }
  
    SeekRPC_pvalueGenes_result result;
    try {
      result.success = iface_->pvalueGenes();
      result.__isset.success = true;
    } catch (const std::exception& e) {
      if (this->eventHandler_.get() != nullptr) {
        this->eventHandler_->handlerError(ctx, "SeekRPC.pvalueGenes");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("pvalueGenes", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != nullptr) {
      this->eventHandler_->preWrite(ctx, "SeekRPC.pvalueGenes");
    }
  
    oprot->writeMessageBegin("pvalueGenes", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != nullptr) {
      this->eventHandler_->postWrite(ctx, "SeekRPC.pvalueGenes", bytes);
    }
  }
  
  void SeekRPCProcessor::process_pvalueDatasets(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = nullptr;
    if (this->eventHandler_.get() != nullptr) {
      ctx = this->eventHandler_->getContext("SeekRPC.pvalueDatasets", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "SeekRPC.pvalueDatasets");
  
    if (this->eventHandler_.get() != nullptr) {
      this->eventHandler_->preRead(ctx, "SeekRPC.pvalueDatasets");
    }
  
    SeekRPC_pvalueDatasets_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != nullptr) {
      this->eventHandler_->postRead(ctx, "SeekRPC.pvalueDatasets", bytes);
    }
  
    SeekRPC_pvalueDatasets_result result;
    try {
      result.success = iface_->pvalueDatasets();
      result.__isset.success = true;
    } catch (const std::exception& e) {
      if (this->eventHandler_.get() != nullptr) {
        this->eventHandler_->handlerError(ctx, "SeekRPC.pvalueDatasets");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("pvalueDatasets", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != nullptr) {
      this->eventHandler_->preWrite(ctx, "SeekRPC.pvalueDatasets");
    }
  
    oprot->writeMessageBegin("pvalueDatasets", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != nullptr) {
      this->eventHandler_->postWrite(ctx, "SeekRPC.pvalueDatasets", bytes);
    }
  }
  
  void SeekRPCProcessor::process_pclQuery(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = nullptr;
    if (this->eventHandler_.get() != nullptr) {
      ctx = this->eventHandler_->getContext("SeekRPC.pclQuery", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "SeekRPC.pclQuery");
  
    if (this->eventHandler_.get() != nullptr) {
      this->eventHandler_->preRead(ctx, "SeekRPC.pclQuery");
    }
  
    SeekRPC_pclQuery_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != nullptr) {
      this->eventHandler_->postRead(ctx, "SeekRPC.pclQuery", bytes);
    }
  
    SeekRPC_pclQuery_result result;
    try {
      iface_->pclQuery(result.success, args.query);
      result.__isset.success = true;
    } catch (const std::exception& e) {
      if (this->eventHandler_.get() != nullptr) {
        this->eventHandler_->handlerError(ctx, "SeekRPC.pclQuery");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("pclQuery", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != nullptr) {
      this->eventHandler_->preWrite(ctx, "SeekRPC.pclQuery");
    }
  
    oprot->writeMessageBegin("pclQuery", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != nullptr) {
      this->eventHandler_->postWrite(ctx, "SeekRPC.pclQuery", bytes);
    }
  }
  
  void SeekRPCProcessor::process_pclQueryAsync(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = nullptr;
    if (this->eventHandler_.get() != nullptr) {
      ctx = this->eventHandler_->getContext("SeekRPC.pclQueryAsync", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "SeekRPC.pclQueryAsync");
  
    if (this->eventHandler_.get() != nullptr) {
      this->eventHandler_->preRead(ctx, "SeekRPC.pclQueryAsync");
    }
  
    SeekRPC_pclQueryAsync_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != nullptr) {
      this->eventHandler_->postRead(ctx, "SeekRPC.pclQueryAsync", bytes);
    }
  
    SeekRPC_pclQueryAsync_result result;
    try {
      result.success = iface_->pclQueryAsync(args.query);
      result.__isset.success = true;
    } catch (const std::exception& e) {
      if (this->eventHandler_.get() != nullptr) {
        this->eventHandler_->handlerError(ctx, "SeekRPC.pclQueryAsync");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("pclQueryAsync", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != nullptr) {
      this->eventHandler_->preWrite(ctx, "SeekRPC.pclQueryAsync");
    }
  
    oprot->writeMessageBegin("pclQueryAsync", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != nullptr) {
      this->eventHandler_->postWrite(ctx, "SeekRPC.pclQueryAsync", bytes);
    }
  }
  
  void SeekRPCProcessor::process_getPclResult(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
  {
    void* ctx = nullptr;
    if (this->eventHandler_.get() != nullptr) {
      ctx = this->eventHandler_->getContext("SeekRPC.getPclResult", callContext);
    }
    ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "SeekRPC.getPclResult");
  
    if (this->eventHandler_.get() != nullptr) {
      this->eventHandler_->preRead(ctx, "SeekRPC.getPclResult");
    }
  
    SeekRPC_getPclResult_args args;
    args.read(iprot);
    iprot->readMessageEnd();
    uint32_t bytes = iprot->getTransport()->readEnd();
  
    if (this->eventHandler_.get() != nullptr) {
      this->eventHandler_->postRead(ctx, "SeekRPC.getPclResult", bytes);
    }
  
    SeekRPC_getPclResult_result result;
    try {
      iface_->getPclResult(result.success, args.taskId, args.block);
      result.__isset.success = true;
    } catch (const std::exception& e) {
      if (this->eventHandler_.get() != nullptr) {
        this->eventHandler_->handlerError(ctx, "SeekRPC.getPclResult");
      }
  
      ::apache::thrift::TApplicationException x(e.what());
      oprot->writeMessageBegin("getPclResult", ::apache::thrift::protocol::T_EXCEPTION, seqid);
      x.write(oprot);
      oprot->writeMessageEnd();
      oprot->getTransport()->writeEnd();
      oprot->getTransport()->flush();
      return;
    }
  
    if (this->eventHandler_.get() != nullptr) {
      this->eventHandler_->preWrite(ctx, "SeekRPC.getPclResult");
    }
  
    oprot->writeMessageBegin("getPclResult", ::apache::thrift::protocol::T_REPLY, seqid);
    result.write(oprot);
    oprot->writeMessageEnd();
    bytes = oprot->getTransport()->writeEnd();
    oprot->getTransport()->flush();
  
    if (this->eventHandler_.get() != nullptr) {
      this->eventHandler_->postWrite(ctx, "SeekRPC.getPclResult", bytes);
    }
  }
  
  ::std::shared_ptr< ::apache::thrift::TProcessor > SeekRPCProcessorFactory::getProcessor(const ::apache::thrift::TConnectionInfo& connInfo) {
    ::apache::thrift::ReleaseHandler< SeekRPCIfFactory > cleanup(handlerFactory_);
    ::std::shared_ptr< SeekRPCIf > handler(handlerFactory_->getHandler(connInfo), cleanup);
    ::std::shared_ptr< ::apache::thrift::TProcessor > processor(new SeekRPCProcessor(handler));
    return processor;
  }
  
  void SeekRPCConcurrentClient::seekQuery(SeekResult& _return, const SeekQueryArgs& query)
  {
    int32_t seqid = send_seekQuery(query);
    recv_seekQuery(_return, seqid);
  }
  
  int32_t SeekRPCConcurrentClient::send_seekQuery(const SeekQueryArgs& query)
  {
    int32_t cseqid = this->sync_->generateSeqId();
    ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get());
    oprot_->writeMessageBegin("seekQuery", ::apache::thrift::protocol::T_CALL, cseqid);
  
    SeekRPC_seekQuery_pargs args;
    args.query = &query;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  
    sentry.commit();
    return cseqid;
  }
  
  void SeekRPCConcurrentClient::recv_seekQuery(SeekResult& _return, const int32_t seqid)
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    // the read mutex gets dropped and reacquired as part of waitForWork()
    // The destructor of this sentry wakes up other clients
    ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid);
  
    while(true) {
      if(!this->sync_->getPending(fname, mtype, rseqid)) {
        iprot_->readMessageBegin(fname, mtype, rseqid);
      }
      if(seqid == rseqid) {
        if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
          ::apache::thrift::TApplicationException x;
          x.read(iprot_);
          iprot_->readMessageEnd();
          iprot_->getTransport()->readEnd();
          sentry.commit();
          throw x;
        }
        if (mtype != ::apache::thrift::protocol::T_REPLY) {
          iprot_->skip(::apache::thrift::protocol::T_STRUCT);
          iprot_->readMessageEnd();
          iprot_->getTransport()->readEnd();
        }
        if (fname.compare("seekQuery") != 0) {
          iprot_->skip(::apache::thrift::protocol::T_STRUCT);
          iprot_->readMessageEnd();
          iprot_->getTransport()->readEnd();
  
          // in a bad state, don't commit
          using ::apache::thrift::protocol::TProtocolException;
          throw TProtocolException(TProtocolException::INVALID_DATA);
        }
        SeekRPC_seekQuery_presult result;
        result.success = &_return;
        result.read(iprot_);
        iprot_->readMessageEnd();
        iprot_->getTransport()->readEnd();
  
        if (result.__isset.success) {
          // _return pointer has now been filled
          sentry.commit();
          return;
        }
        // in a bad state, don't commit
        throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "seekQuery failed: unknown result");
      }
      // seqid != rseqid
      this->sync_->updatePending(fname, mtype, rseqid);
  
      // this will temporarily unlock the readMutex, and let other clients get work done
      this->sync_->waitForWork(seqid);
    } // end while(true)
  }
  
  int64_t SeekRPCConcurrentClient::seekQueryAsync(const SeekQueryArgs& query)
  {
    int32_t seqid = send_seekQueryAsync(query);
    return recv_seekQueryAsync(seqid);
  }
  
  int32_t SeekRPCConcurrentClient::send_seekQueryAsync(const SeekQueryArgs& query)
  {
    int32_t cseqid = this->sync_->generateSeqId();
    ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get());
    oprot_->writeMessageBegin("seekQueryAsync", ::apache::thrift::protocol::T_CALL, cseqid);
  
    SeekRPC_seekQueryAsync_pargs args;
    args.query = &query;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  
    sentry.commit();
    return cseqid;
  }
  
  int64_t SeekRPCConcurrentClient::recv_seekQueryAsync(const int32_t seqid)
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    // the read mutex gets dropped and reacquired as part of waitForWork()
    // The destructor of this sentry wakes up other clients
    ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid);
  
    while(true) {
      if(!this->sync_->getPending(fname, mtype, rseqid)) {
        iprot_->readMessageBegin(fname, mtype, rseqid);
      }
      if(seqid == rseqid) {
        if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
          ::apache::thrift::TApplicationException x;
          x.read(iprot_);
          iprot_->readMessageEnd();
          iprot_->getTransport()->readEnd();
          sentry.commit();
          throw x;
        }
        if (mtype != ::apache::thrift::protocol::T_REPLY) {
          iprot_->skip(::apache::thrift::protocol::T_STRUCT);
          iprot_->readMessageEnd();
          iprot_->getTransport()->readEnd();
        }
        if (fname.compare("seekQueryAsync") != 0) {
          iprot_->skip(::apache::thrift::protocol::T_STRUCT);
          iprot_->readMessageEnd();
          iprot_->getTransport()->readEnd();
  
          // in a bad state, don't commit
          using ::apache::thrift::protocol::TProtocolException;
          throw TProtocolException(TProtocolException::INVALID_DATA);
        }
        int64_t _return;
        SeekRPC_seekQueryAsync_presult result;
        result.success = &_return;
        result.read(iprot_);
        iprot_->readMessageEnd();
        iprot_->getTransport()->readEnd();
  
        if (result.__isset.success) {
          sentry.commit();
          return _return;
        }
        // in a bad state, don't commit
        throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "seekQueryAsync failed: unknown result");
      }
      // seqid != rseqid
      this->sync_->updatePending(fname, mtype, rseqid);
  
      // this will temporarily unlock the readMutex, and let other clients get work done
      this->sync_->waitForWork(seqid);
    } // end while(true)
  }
  
  void SeekRPCConcurrentClient::getSeekResult(SeekResult& _return, const int64_t taskId, const bool block)
  {
    int32_t seqid = send_getSeekResult(taskId, block);
    recv_getSeekResult(_return, seqid);
  }
  
  int32_t SeekRPCConcurrentClient::send_getSeekResult(const int64_t taskId, const bool block)
  {
    int32_t cseqid = this->sync_->generateSeqId();
    ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get());
    oprot_->writeMessageBegin("getSeekResult", ::apache::thrift::protocol::T_CALL, cseqid);
  
    SeekRPC_getSeekResult_pargs args;
    args.taskId = &taskId;
    args.block = &block;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  
    sentry.commit();
    return cseqid;
  }
  
  void SeekRPCConcurrentClient::recv_getSeekResult(SeekResult& _return, const int32_t seqid)
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    // the read mutex gets dropped and reacquired as part of waitForWork()
    // The destructor of this sentry wakes up other clients
    ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid);
  
    while(true) {
      if(!this->sync_->getPending(fname, mtype, rseqid)) {
        iprot_->readMessageBegin(fname, mtype, rseqid);
      }
      if(seqid == rseqid) {
        if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
          ::apache::thrift::TApplicationException x;
          x.read(iprot_);
          iprot_->readMessageEnd();
          iprot_->getTransport()->readEnd();
          sentry.commit();
          throw x;
        }
        if (mtype != ::apache::thrift::protocol::T_REPLY) {
          iprot_->skip(::apache::thrift::protocol::T_STRUCT);
          iprot_->readMessageEnd();
          iprot_->getTransport()->readEnd();
        }
        if (fname.compare("getSeekResult") != 0) {
          iprot_->skip(::apache::thrift::protocol::T_STRUCT);
          iprot_->readMessageEnd();
          iprot_->getTransport()->readEnd();
  
          // in a bad state, don't commit
          using ::apache::thrift::protocol::TProtocolException;
          throw TProtocolException(TProtocolException::INVALID_DATA);
        }
        SeekRPC_getSeekResult_presult result;
        result.success = &_return;
        result.read(iprot_);
        iprot_->readMessageEnd();
        iprot_->getTransport()->readEnd();
  
        if (result.__isset.success) {
          // _return pointer has now been filled
          sentry.commit();
          return;
        }
        // in a bad state, don't commit
        throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getSeekResult failed: unknown result");
      }
      // seqid != rseqid
      this->sync_->updatePending(fname, mtype, rseqid);
  
      // this will temporarily unlock the readMutex, and let other clients get work done
      this->sync_->waitForWork(seqid);
    } // end while(true)
  }
  
  bool SeekRPCConcurrentClient::isQueryComplete(const int64_t taskId)
  {
    int32_t seqid = send_isQueryComplete(taskId);
    return recv_isQueryComplete(seqid);
  }
  
  int32_t SeekRPCConcurrentClient::send_isQueryComplete(const int64_t taskId)
  {
    int32_t cseqid = this->sync_->generateSeqId();
    ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get());
    oprot_->writeMessageBegin("isQueryComplete", ::apache::thrift::protocol::T_CALL, cseqid);
  
    SeekRPC_isQueryComplete_pargs args;
    args.taskId = &taskId;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  
    sentry.commit();
    return cseqid;
  }
  
  bool SeekRPCConcurrentClient::recv_isQueryComplete(const int32_t seqid)
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    // the read mutex gets dropped and reacquired as part of waitForWork()
    // The destructor of this sentry wakes up other clients
    ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid);
  
    while(true) {
      if(!this->sync_->getPending(fname, mtype, rseqid)) {
        iprot_->readMessageBegin(fname, mtype, rseqid);
      }
      if(seqid == rseqid) {
        if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
          ::apache::thrift::TApplicationException x;
          x.read(iprot_);
          iprot_->readMessageEnd();
          iprot_->getTransport()->readEnd();
          sentry.commit();
          throw x;
        }
        if (mtype != ::apache::thrift::protocol::T_REPLY) {
          iprot_->skip(::apache::thrift::protocol::T_STRUCT);
          iprot_->readMessageEnd();
          iprot_->getTransport()->readEnd();
        }
        if (fname.compare("isQueryComplete") != 0) {
          iprot_->skip(::apache::thrift::protocol::T_STRUCT);
          iprot_->readMessageEnd();
          iprot_->getTransport()->readEnd();
  
          // in a bad state, don't commit
          using ::apache::thrift::protocol::TProtocolException;
          throw TProtocolException(TProtocolException::INVALID_DATA);
        }
        bool _return;
        SeekRPC_isQueryComplete_presult result;
        result.success = &_return;
        result.read(iprot_);
        iprot_->readMessageEnd();
        iprot_->getTransport()->readEnd();
  
        if (result.__isset.success) {
          sentry.commit();
          return _return;
        }
        // in a bad state, don't commit
        throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "isQueryComplete failed: unknown result");
      }
      // seqid != rseqid
      this->sync_->updatePending(fname, mtype, rseqid);
  
      // this will temporarily unlock the readMutex, and let other clients get work done
      this->sync_->waitForWork(seqid);
    } // end while(true)
  }
  
  void SeekRPCConcurrentClient::getProgressMessage(std::string& _return, const int64_t taskId)
  {
    int32_t seqid = send_getProgressMessage(taskId);
    recv_getProgressMessage(_return, seqid);
  }
  
  int32_t SeekRPCConcurrentClient::send_getProgressMessage(const int64_t taskId)
  {
    int32_t cseqid = this->sync_->generateSeqId();
    ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get());
    oprot_->writeMessageBegin("getProgressMessage", ::apache::thrift::protocol::T_CALL, cseqid);
  
    SeekRPC_getProgressMessage_pargs args;
    args.taskId = &taskId;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  
    sentry.commit();
    return cseqid;
  }
  
  void SeekRPCConcurrentClient::recv_getProgressMessage(std::string& _return, const int32_t seqid)
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    // the read mutex gets dropped and reacquired as part of waitForWork()
    // The destructor of this sentry wakes up other clients
    ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid);
  
    while(true) {
      if(!this->sync_->getPending(fname, mtype, rseqid)) {
        iprot_->readMessageBegin(fname, mtype, rseqid);
      }
      if(seqid == rseqid) {
        if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
          ::apache::thrift::TApplicationException x;
          x.read(iprot_);
          iprot_->readMessageEnd();
          iprot_->getTransport()->readEnd();
          sentry.commit();
          throw x;
        }
        if (mtype != ::apache::thrift::protocol::T_REPLY) {
          iprot_->skip(::apache::thrift::protocol::T_STRUCT);
          iprot_->readMessageEnd();
          iprot_->getTransport()->readEnd();
        }
        if (fname.compare("getProgressMessage") != 0) {
          iprot_->skip(::apache::thrift::protocol::T_STRUCT);
          iprot_->readMessageEnd();
          iprot_->getTransport()->readEnd();
  
          // in a bad state, don't commit
          using ::apache::thrift::protocol::TProtocolException;
          throw TProtocolException(TProtocolException::INVALID_DATA);
        }
        SeekRPC_getProgressMessage_presult result;
        result.success = &_return;
        result.read(iprot_);
        iprot_->readMessageEnd();
        iprot_->getTransport()->readEnd();
  
        if (result.__isset.success) {
          // _return pointer has now been filled
          sentry.commit();
          return;
        }
        // in a bad state, don't commit
        throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getProgressMessage failed: unknown result");
      }
      // seqid != rseqid
      this->sync_->updatePending(fname, mtype, rseqid);
  
      // this will temporarily unlock the readMutex, and let other clients get work done
      this->sync_->waitForWork(seqid);
    } // end while(true)
  }
  
  int32_t SeekRPCConcurrentClient::getRpcVersion()
  {
    int32_t seqid = send_getRpcVersion();
    return recv_getRpcVersion(seqid);
  }
  
  int32_t SeekRPCConcurrentClient::send_getRpcVersion()
  {
    int32_t cseqid = this->sync_->generateSeqId();
    ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get());
    oprot_->writeMessageBegin("getRpcVersion", ::apache::thrift::protocol::T_CALL, cseqid);
  
    SeekRPC_getRpcVersion_pargs args;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  
    sentry.commit();
    return cseqid;
  }
  
  int32_t SeekRPCConcurrentClient::recv_getRpcVersion(const int32_t seqid)
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    // the read mutex gets dropped and reacquired as part of waitForWork()
    // The destructor of this sentry wakes up other clients
    ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid);
  
    while(true) {
      if(!this->sync_->getPending(fname, mtype, rseqid)) {
        iprot_->readMessageBegin(fname, mtype, rseqid);
      }
      if(seqid == rseqid) {
        if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
          ::apache::thrift::TApplicationException x;
          x.read(iprot_);
          iprot_->readMessageEnd();
          iprot_->getTransport()->readEnd();
          sentry.commit();
          throw x;
        }
        if (mtype != ::apache::thrift::protocol::T_REPLY) {
          iprot_->skip(::apache::thrift::protocol::T_STRUCT);
          iprot_->readMessageEnd();
          iprot_->getTransport()->readEnd();
        }
        if (fname.compare("getRpcVersion") != 0) {
          iprot_->skip(::apache::thrift::protocol::T_STRUCT);
          iprot_->readMessageEnd();
          iprot_->getTransport()->readEnd();
  
          // in a bad state, don't commit
          using ::apache::thrift::protocol::TProtocolException;
          throw TProtocolException(TProtocolException::INVALID_DATA);
        }
        int32_t _return;
        SeekRPC_getRpcVersion_presult result;
        result.success = &_return;
        result.read(iprot_);
        iprot_->readMessageEnd();
        iprot_->getTransport()->readEnd();
  
        if (result.__isset.success) {
          sentry.commit();
          return _return;
        }
        // in a bad state, don't commit
        throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getRpcVersion failed: unknown result");
      }
      // seqid != rseqid
      this->sync_->updatePending(fname, mtype, rseqid);
  
      // this will temporarily unlock the readMutex, and let other clients get work done
      this->sync_->waitForWork(seqid);
    } // end while(true)
  }
  
  int32_t SeekRPCConcurrentClient::ping()
  {
    int32_t seqid = send_ping();
    return recv_ping(seqid);
  }
  
  int32_t SeekRPCConcurrentClient::send_ping()
  {
    int32_t cseqid = this->sync_->generateSeqId();
    ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get());
    oprot_->writeMessageBegin("ping", ::apache::thrift::protocol::T_CALL, cseqid);
  
    SeekRPC_ping_pargs args;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  
    sentry.commit();
    return cseqid;
  }
  
  int32_t SeekRPCConcurrentClient::recv_ping(const int32_t seqid)
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    // the read mutex gets dropped and reacquired as part of waitForWork()
    // The destructor of this sentry wakes up other clients
    ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid);
  
    while(true) {
      if(!this->sync_->getPending(fname, mtype, rseqid)) {
        iprot_->readMessageBegin(fname, mtype, rseqid);
      }
      if(seqid == rseqid) {
        if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
          ::apache::thrift::TApplicationException x;
          x.read(iprot_);
          iprot_->readMessageEnd();
          iprot_->getTransport()->readEnd();
          sentry.commit();
          throw x;
        }
        if (mtype != ::apache::thrift::protocol::T_REPLY) {
          iprot_->skip(::apache::thrift::protocol::T_STRUCT);
          iprot_->readMessageEnd();
          iprot_->getTransport()->readEnd();
        }
        if (fname.compare("ping") != 0) {
          iprot_->skip(::apache::thrift::protocol::T_STRUCT);
          iprot_->readMessageEnd();
          iprot_->getTransport()->readEnd();
  
          // in a bad state, don't commit
          using ::apache::thrift::protocol::TProtocolException;
          throw TProtocolException(TProtocolException::INVALID_DATA);
        }
        int32_t _return;
        SeekRPC_ping_presult result;
        result.success = &_return;
        result.read(iprot_);
        iprot_->readMessageEnd();
        iprot_->getTransport()->readEnd();
  
        if (result.__isset.success) {
          sentry.commit();
          return _return;
        }
        // in a bad state, don't commit
        throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "ping failed: unknown result");
      }
      // seqid != rseqid
      this->sync_->updatePending(fname, mtype, rseqid);
  
      // this will temporarily unlock the readMutex, and let other clients get work done
      this->sync_->waitForWork(seqid);
    } // end while(true)
  }
  
  int32_t SeekRPCConcurrentClient::pvalueGenes()
  {
    int32_t seqid = send_pvalueGenes();
    return recv_pvalueGenes(seqid);
  }
  
  int32_t SeekRPCConcurrentClient::send_pvalueGenes()
  {
    int32_t cseqid = this->sync_->generateSeqId();
    ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get());
    oprot_->writeMessageBegin("pvalueGenes", ::apache::thrift::protocol::T_CALL, cseqid);
  
    SeekRPC_pvalueGenes_pargs args;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  
    sentry.commit();
    return cseqid;
  }
  
  int32_t SeekRPCConcurrentClient::recv_pvalueGenes(const int32_t seqid)
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    // the read mutex gets dropped and reacquired as part of waitForWork()
    // The destructor of this sentry wakes up other clients
    ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid);
  
    while(true) {
      if(!this->sync_->getPending(fname, mtype, rseqid)) {
        iprot_->readMessageBegin(fname, mtype, rseqid);
      }
      if(seqid == rseqid) {
        if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
          ::apache::thrift::TApplicationException x;
          x.read(iprot_);
          iprot_->readMessageEnd();
          iprot_->getTransport()->readEnd();
          sentry.commit();
          throw x;
        }
        if (mtype != ::apache::thrift::protocol::T_REPLY) {
          iprot_->skip(::apache::thrift::protocol::T_STRUCT);
          iprot_->readMessageEnd();
          iprot_->getTransport()->readEnd();
        }
        if (fname.compare("pvalueGenes") != 0) {
          iprot_->skip(::apache::thrift::protocol::T_STRUCT);
          iprot_->readMessageEnd();
          iprot_->getTransport()->readEnd();
  
          // in a bad state, don't commit
          using ::apache::thrift::protocol::TProtocolException;
          throw TProtocolException(TProtocolException::INVALID_DATA);
        }
        int32_t _return;
        SeekRPC_pvalueGenes_presult result;
        result.success = &_return;
        result.read(iprot_);
        iprot_->readMessageEnd();
        iprot_->getTransport()->readEnd();
  
        if (result.__isset.success) {
          sentry.commit();
          return _return;
        }
        // in a bad state, don't commit
        throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "pvalueGenes failed: unknown result");
      }
      // seqid != rseqid
      this->sync_->updatePending(fname, mtype, rseqid);
  
      // this will temporarily unlock the readMutex, and let other clients get work done
      this->sync_->waitForWork(seqid);
    } // end while(true)
  }
  
  int32_t SeekRPCConcurrentClient::pvalueDatasets()
  {
    int32_t seqid = send_pvalueDatasets();
    return recv_pvalueDatasets(seqid);
  }
  
  int32_t SeekRPCConcurrentClient::send_pvalueDatasets()
  {
    int32_t cseqid = this->sync_->generateSeqId();
    ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get());
    oprot_->writeMessageBegin("pvalueDatasets", ::apache::thrift::protocol::T_CALL, cseqid);
  
    SeekRPC_pvalueDatasets_pargs args;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  
    sentry.commit();
    return cseqid;
  }
  
  int32_t SeekRPCConcurrentClient::recv_pvalueDatasets(const int32_t seqid)
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    // the read mutex gets dropped and reacquired as part of waitForWork()
    // The destructor of this sentry wakes up other clients
    ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid);
  
    while(true) {
      if(!this->sync_->getPending(fname, mtype, rseqid)) {
        iprot_->readMessageBegin(fname, mtype, rseqid);
      }
      if(seqid == rseqid) {
        if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
          ::apache::thrift::TApplicationException x;
          x.read(iprot_);
          iprot_->readMessageEnd();
          iprot_->getTransport()->readEnd();
          sentry.commit();
          throw x;
        }
        if (mtype != ::apache::thrift::protocol::T_REPLY) {
          iprot_->skip(::apache::thrift::protocol::T_STRUCT);
          iprot_->readMessageEnd();
          iprot_->getTransport()->readEnd();
        }
        if (fname.compare("pvalueDatasets") != 0) {
          iprot_->skip(::apache::thrift::protocol::T_STRUCT);
          iprot_->readMessageEnd();
          iprot_->getTransport()->readEnd();
  
          // in a bad state, don't commit
          using ::apache::thrift::protocol::TProtocolException;
          throw TProtocolException(TProtocolException::INVALID_DATA);
        }
        int32_t _return;
        SeekRPC_pvalueDatasets_presult result;
        result.success = &_return;
        result.read(iprot_);
        iprot_->readMessageEnd();
        iprot_->getTransport()->readEnd();
  
        if (result.__isset.success) {
          sentry.commit();
          return _return;
        }
        // in a bad state, don't commit
        throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "pvalueDatasets failed: unknown result");
      }
      // seqid != rseqid
      this->sync_->updatePending(fname, mtype, rseqid);
  
      // this will temporarily unlock the readMutex, and let other clients get work done
      this->sync_->waitForWork(seqid);
    } // end while(true)
  }
  
  void SeekRPCConcurrentClient::pclQuery(PclResult& _return, const PclQueryArgs& query)
  {
    int32_t seqid = send_pclQuery(query);
    recv_pclQuery(_return, seqid);
  }
  
  int32_t SeekRPCConcurrentClient::send_pclQuery(const PclQueryArgs& query)
  {
    int32_t cseqid = this->sync_->generateSeqId();
    ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get());
    oprot_->writeMessageBegin("pclQuery", ::apache::thrift::protocol::T_CALL, cseqid);
  
    SeekRPC_pclQuery_pargs args;
    args.query = &query;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  
    sentry.commit();
    return cseqid;
  }
  
  void SeekRPCConcurrentClient::recv_pclQuery(PclResult& _return, const int32_t seqid)
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    // the read mutex gets dropped and reacquired as part of waitForWork()
    // The destructor of this sentry wakes up other clients
    ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid);
  
    while(true) {
      if(!this->sync_->getPending(fname, mtype, rseqid)) {
        iprot_->readMessageBegin(fname, mtype, rseqid);
      }
      if(seqid == rseqid) {
        if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
          ::apache::thrift::TApplicationException x;
          x.read(iprot_);
          iprot_->readMessageEnd();
          iprot_->getTransport()->readEnd();
          sentry.commit();
          throw x;
        }
        if (mtype != ::apache::thrift::protocol::T_REPLY) {
          iprot_->skip(::apache::thrift::protocol::T_STRUCT);
          iprot_->readMessageEnd();
          iprot_->getTransport()->readEnd();
        }
        if (fname.compare("pclQuery") != 0) {
          iprot_->skip(::apache::thrift::protocol::T_STRUCT);
          iprot_->readMessageEnd();
          iprot_->getTransport()->readEnd();
  
          // in a bad state, don't commit
          using ::apache::thrift::protocol::TProtocolException;
          throw TProtocolException(TProtocolException::INVALID_DATA);
        }
        SeekRPC_pclQuery_presult result;
        result.success = &_return;
        result.read(iprot_);
        iprot_->readMessageEnd();
        iprot_->getTransport()->readEnd();
  
        if (result.__isset.success) {
          // _return pointer has now been filled
          sentry.commit();
          return;
        }
        // in a bad state, don't commit
        throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "pclQuery failed: unknown result");
      }
      // seqid != rseqid
      this->sync_->updatePending(fname, mtype, rseqid);
  
      // this will temporarily unlock the readMutex, and let other clients get work done
      this->sync_->waitForWork(seqid);
    } // end while(true)
  }
  
  int64_t SeekRPCConcurrentClient::pclQueryAsync(const PclQueryArgs& query)
  {
    int32_t seqid = send_pclQueryAsync(query);
    return recv_pclQueryAsync(seqid);
  }
  
  int32_t SeekRPCConcurrentClient::send_pclQueryAsync(const PclQueryArgs& query)
  {
    int32_t cseqid = this->sync_->generateSeqId();
    ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get());
    oprot_->writeMessageBegin("pclQueryAsync", ::apache::thrift::protocol::T_CALL, cseqid);
  
    SeekRPC_pclQueryAsync_pargs args;
    args.query = &query;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  
    sentry.commit();
    return cseqid;
  }
  
  int64_t SeekRPCConcurrentClient::recv_pclQueryAsync(const int32_t seqid)
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    // the read mutex gets dropped and reacquired as part of waitForWork()
    // The destructor of this sentry wakes up other clients
    ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid);
  
    while(true) {
      if(!this->sync_->getPending(fname, mtype, rseqid)) {
        iprot_->readMessageBegin(fname, mtype, rseqid);
      }
      if(seqid == rseqid) {
        if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
          ::apache::thrift::TApplicationException x;
          x.read(iprot_);
          iprot_->readMessageEnd();
          iprot_->getTransport()->readEnd();
          sentry.commit();
          throw x;
        }
        if (mtype != ::apache::thrift::protocol::T_REPLY) {
          iprot_->skip(::apache::thrift::protocol::T_STRUCT);
          iprot_->readMessageEnd();
          iprot_->getTransport()->readEnd();
        }
        if (fname.compare("pclQueryAsync") != 0) {
          iprot_->skip(::apache::thrift::protocol::T_STRUCT);
          iprot_->readMessageEnd();
          iprot_->getTransport()->readEnd();
  
          // in a bad state, don't commit
          using ::apache::thrift::protocol::TProtocolException;
          throw TProtocolException(TProtocolException::INVALID_DATA);
        }
        int64_t _return;
        SeekRPC_pclQueryAsync_presult result;
        result.success = &_return;
        result.read(iprot_);
        iprot_->readMessageEnd();
        iprot_->getTransport()->readEnd();
  
        if (result.__isset.success) {
          sentry.commit();
          return _return;
        }
        // in a bad state, don't commit
        throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "pclQueryAsync failed: unknown result");
      }
      // seqid != rseqid
      this->sync_->updatePending(fname, mtype, rseqid);
  
      // this will temporarily unlock the readMutex, and let other clients get work done
      this->sync_->waitForWork(seqid);
    } // end while(true)
  }
  
  void SeekRPCConcurrentClient::getPclResult(PclResult& _return, const int64_t taskId, const bool block)
  {
    int32_t seqid = send_getPclResult(taskId, block);
    recv_getPclResult(_return, seqid);
  }
  
  int32_t SeekRPCConcurrentClient::send_getPclResult(const int64_t taskId, const bool block)
  {
    int32_t cseqid = this->sync_->generateSeqId();
    ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get());
    oprot_->writeMessageBegin("getPclResult", ::apache::thrift::protocol::T_CALL, cseqid);
  
    SeekRPC_getPclResult_pargs args;
    args.taskId = &taskId;
    args.block = &block;
    args.write(oprot_);
  
    oprot_->writeMessageEnd();
    oprot_->getTransport()->writeEnd();
    oprot_->getTransport()->flush();
  
    sentry.commit();
    return cseqid;
  }
  
  void SeekRPCConcurrentClient::recv_getPclResult(PclResult& _return, const int32_t seqid)
  {
  
    int32_t rseqid = 0;
    std::string fname;
    ::apache::thrift::protocol::TMessageType mtype;
  
    // the read mutex gets dropped and reacquired as part of waitForWork()
    // The destructor of this sentry wakes up other clients
    ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid);
  
    while(true) {
      if(!this->sync_->getPending(fname, mtype, rseqid)) {
        iprot_->readMessageBegin(fname, mtype, rseqid);
      }
      if(seqid == rseqid) {
        if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
          ::apache::thrift::TApplicationException x;
          x.read(iprot_);
          iprot_->readMessageEnd();
          iprot_->getTransport()->readEnd();
          sentry.commit();
          throw x;
        }
        if (mtype != ::apache::thrift::protocol::T_REPLY) {
          iprot_->skip(::apache::thrift::protocol::T_STRUCT);
          iprot_->readMessageEnd();
          iprot_->getTransport()->readEnd();
        }
        if (fname.compare("getPclResult") != 0) {
          iprot_->skip(::apache::thrift::protocol::T_STRUCT);
          iprot_->readMessageEnd();
          iprot_->getTransport()->readEnd();
  
          // in a bad state, don't commit
          using ::apache::thrift::protocol::TProtocolException;
          throw TProtocolException(TProtocolException::INVALID_DATA);
        }
        SeekRPC_getPclResult_presult result;
        result.success = &_return;
        result.read(iprot_);
        iprot_->readMessageEnd();
        iprot_->getTransport()->readEnd();
  
        if (result.__isset.success) {
          // _return pointer has now been filled
          sentry.commit();
          return;
        }
        // in a bad state, don't commit
        throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getPclResult failed: unknown result");
      }
      // seqid != rseqid
      this->sync_->updatePending(fname, mtype, rseqid);
  
      // this will temporarily unlock the readMutex, and let other clients get work done
      this->sync_->waitForWork(seqid);
    } // end while(true)
  }
  
  } // namespace
  
  