Summary: First draft. Unit tests pass. Test Plan: unit tests attached Reviewers: heyongqiang Reviewed By: heyongqiang Differential Revision: https://reviews.facebook.net/D3969
4162 lines
121 KiB
C++
4162 lines
121 KiB
C++
/**
|
|
* Autogenerated by Thrift
|
|
*
|
|
* DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
|
|
* @generated
|
|
*/
|
|
#include "DB.h"
|
|
|
|
namespace Tleveldb {
|
|
|
|
uint32_t DB_Open_args::read(apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 1:
|
|
if (ftype == apache::thrift::protocol::T_STRING) {
|
|
xfer += iprot->readBinary(this->dbname);
|
|
this->__isset.dbname = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
case 2:
|
|
if (ftype == apache::thrift::protocol::T_STRUCT) {
|
|
xfer += this->dboptions.read(iprot);
|
|
this->__isset.dboptions = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_Open_args::write(apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("DB_Open_args");
|
|
xfer += oprot->writeFieldBegin("dbname", apache::thrift::protocol::T_STRING, 1);
|
|
xfer += oprot->writeBinary(this->dbname);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("dboptions", apache::thrift::protocol::T_STRUCT, 2);
|
|
xfer += this->dboptions.write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_Open_pargs::write(apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("DB_Open_pargs");
|
|
xfer += oprot->writeFieldBegin("dbname", apache::thrift::protocol::T_STRING, 1);
|
|
xfer += oprot->writeBinary((*(this->dbname)));
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("dboptions", apache::thrift::protocol::T_STRUCT, 2);
|
|
xfer += (*(this->dboptions)).write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_Open_result::read(apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == apache::thrift::protocol::T_STRUCT) {
|
|
xfer += this->success.read(iprot);
|
|
this->__isset.success = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
case 1:
|
|
if (ftype == apache::thrift::protocol::T_STRUCT) {
|
|
xfer += this->se.read(iprot);
|
|
this->__isset.se = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_Open_result::write(apache::thrift::protocol::TProtocol* oprot) const {
|
|
|
|
uint32_t xfer = 0;
|
|
|
|
xfer += oprot->writeStructBegin("DB_Open_result");
|
|
|
|
if (this->__isset.success) {
|
|
xfer += oprot->writeFieldBegin("success", apache::thrift::protocol::T_STRUCT, 0);
|
|
xfer += this->success.write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
} else if (this->__isset.se) {
|
|
xfer += oprot->writeFieldBegin("se", apache::thrift::protocol::T_STRUCT, 1);
|
|
xfer += this->se.write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
}
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_Open_presult::read(apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == apache::thrift::protocol::T_STRUCT) {
|
|
xfer += (*(this->success)).read(iprot);
|
|
this->__isset.success = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
case 1:
|
|
if (ftype == apache::thrift::protocol::T_STRUCT) {
|
|
xfer += this->se.read(iprot);
|
|
this->__isset.se = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_Close_args::read(apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 1:
|
|
if (ftype == apache::thrift::protocol::T_STRUCT) {
|
|
xfer += this->dbhandle.read(iprot);
|
|
this->__isset.dbhandle = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
case 2:
|
|
if (ftype == apache::thrift::protocol::T_STRING) {
|
|
xfer += iprot->readBinary(this->dbname);
|
|
this->__isset.dbname = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_Close_args::write(apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("DB_Close_args");
|
|
xfer += oprot->writeFieldBegin("dbhandle", apache::thrift::protocol::T_STRUCT, 1);
|
|
xfer += this->dbhandle.write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("dbname", apache::thrift::protocol::T_STRING, 2);
|
|
xfer += oprot->writeBinary(this->dbname);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_Close_pargs::write(apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("DB_Close_pargs");
|
|
xfer += oprot->writeFieldBegin("dbhandle", apache::thrift::protocol::T_STRUCT, 1);
|
|
xfer += (*(this->dbhandle)).write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("dbname", apache::thrift::protocol::T_STRING, 2);
|
|
xfer += oprot->writeBinary((*(this->dbname)));
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_Close_result::read(apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == apache::thrift::protocol::T_I32) {
|
|
int32_t ecast6;
|
|
xfer += iprot->readI32(ecast6);
|
|
this->success = (Code)ecast6;
|
|
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 DB_Close_result::write(apache::thrift::protocol::TProtocol* oprot) const {
|
|
|
|
uint32_t xfer = 0;
|
|
|
|
xfer += oprot->writeStructBegin("DB_Close_result");
|
|
|
|
if (this->__isset.success) {
|
|
xfer += oprot->writeFieldBegin("success", apache::thrift::protocol::T_I32, 0);
|
|
xfer += oprot->writeI32((int32_t)this->success);
|
|
xfer += oprot->writeFieldEnd();
|
|
}
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_Close_presult::read(apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == apache::thrift::protocol::T_I32) {
|
|
int32_t ecast7;
|
|
xfer += iprot->readI32(ecast7);
|
|
(*(this->success)) = (Code)ecast7;
|
|
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 DB_Put_args::read(apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 1:
|
|
if (ftype == apache::thrift::protocol::T_STRUCT) {
|
|
xfer += this->dbhandle.read(iprot);
|
|
this->__isset.dbhandle = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
case 2:
|
|
if (ftype == apache::thrift::protocol::T_STRUCT) {
|
|
xfer += this->keyvalue.read(iprot);
|
|
this->__isset.keyvalue = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
case 3:
|
|
if (ftype == apache::thrift::protocol::T_STRUCT) {
|
|
xfer += this->options.read(iprot);
|
|
this->__isset.options = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_Put_args::write(apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("DB_Put_args");
|
|
xfer += oprot->writeFieldBegin("dbhandle", apache::thrift::protocol::T_STRUCT, 1);
|
|
xfer += this->dbhandle.write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("keyvalue", apache::thrift::protocol::T_STRUCT, 2);
|
|
xfer += this->keyvalue.write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("options", apache::thrift::protocol::T_STRUCT, 3);
|
|
xfer += this->options.write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_Put_pargs::write(apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("DB_Put_pargs");
|
|
xfer += oprot->writeFieldBegin("dbhandle", apache::thrift::protocol::T_STRUCT, 1);
|
|
xfer += (*(this->dbhandle)).write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("keyvalue", apache::thrift::protocol::T_STRUCT, 2);
|
|
xfer += (*(this->keyvalue)).write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("options", apache::thrift::protocol::T_STRUCT, 3);
|
|
xfer += (*(this->options)).write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_Put_result::read(apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == apache::thrift::protocol::T_I32) {
|
|
int32_t ecast8;
|
|
xfer += iprot->readI32(ecast8);
|
|
this->success = (Code)ecast8;
|
|
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 DB_Put_result::write(apache::thrift::protocol::TProtocol* oprot) const {
|
|
|
|
uint32_t xfer = 0;
|
|
|
|
xfer += oprot->writeStructBegin("DB_Put_result");
|
|
|
|
if (this->__isset.success) {
|
|
xfer += oprot->writeFieldBegin("success", apache::thrift::protocol::T_I32, 0);
|
|
xfer += oprot->writeI32((int32_t)this->success);
|
|
xfer += oprot->writeFieldEnd();
|
|
}
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_Put_presult::read(apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == apache::thrift::protocol::T_I32) {
|
|
int32_t ecast9;
|
|
xfer += iprot->readI32(ecast9);
|
|
(*(this->success)) = (Code)ecast9;
|
|
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 DB_Delete_args::read(apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 1:
|
|
if (ftype == apache::thrift::protocol::T_STRUCT) {
|
|
xfer += this->dbhandle.read(iprot);
|
|
this->__isset.dbhandle = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
case 2:
|
|
if (ftype == apache::thrift::protocol::T_STRUCT) {
|
|
xfer += this->key.read(iprot);
|
|
this->__isset.key = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
case 3:
|
|
if (ftype == apache::thrift::protocol::T_STRUCT) {
|
|
xfer += this->options.read(iprot);
|
|
this->__isset.options = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_Delete_args::write(apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("DB_Delete_args");
|
|
xfer += oprot->writeFieldBegin("dbhandle", apache::thrift::protocol::T_STRUCT, 1);
|
|
xfer += this->dbhandle.write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("key", apache::thrift::protocol::T_STRUCT, 2);
|
|
xfer += this->key.write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("options", apache::thrift::protocol::T_STRUCT, 3);
|
|
xfer += this->options.write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_Delete_pargs::write(apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("DB_Delete_pargs");
|
|
xfer += oprot->writeFieldBegin("dbhandle", apache::thrift::protocol::T_STRUCT, 1);
|
|
xfer += (*(this->dbhandle)).write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("key", apache::thrift::protocol::T_STRUCT, 2);
|
|
xfer += (*(this->key)).write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("options", apache::thrift::protocol::T_STRUCT, 3);
|
|
xfer += (*(this->options)).write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_Delete_result::read(apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == apache::thrift::protocol::T_I32) {
|
|
int32_t ecast10;
|
|
xfer += iprot->readI32(ecast10);
|
|
this->success = (Code)ecast10;
|
|
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 DB_Delete_result::write(apache::thrift::protocol::TProtocol* oprot) const {
|
|
|
|
uint32_t xfer = 0;
|
|
|
|
xfer += oprot->writeStructBegin("DB_Delete_result");
|
|
|
|
if (this->__isset.success) {
|
|
xfer += oprot->writeFieldBegin("success", apache::thrift::protocol::T_I32, 0);
|
|
xfer += oprot->writeI32((int32_t)this->success);
|
|
xfer += oprot->writeFieldEnd();
|
|
}
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_Delete_presult::read(apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == apache::thrift::protocol::T_I32) {
|
|
int32_t ecast11;
|
|
xfer += iprot->readI32(ecast11);
|
|
(*(this->success)) = (Code)ecast11;
|
|
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 DB_Write_args::read(apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 1:
|
|
if (ftype == apache::thrift::protocol::T_STRUCT) {
|
|
xfer += this->dbhandle.read(iprot);
|
|
this->__isset.dbhandle = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
case 2:
|
|
if (ftype == apache::thrift::protocol::T_LIST) {
|
|
{
|
|
this->batch.clear();
|
|
uint32_t _size12;
|
|
apache::thrift::protocol::TType _etype15;
|
|
xfer += iprot->readListBegin(_etype15, _size12);
|
|
this->batch.resize(_size12);
|
|
uint32_t _i16;
|
|
for (_i16 = 0; _i16 < _size12; ++_i16)
|
|
{
|
|
xfer += this->batch[_i16].read(iprot);
|
|
}
|
|
xfer += iprot->readListEnd();
|
|
}
|
|
this->__isset.batch = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
case 3:
|
|
if (ftype == apache::thrift::protocol::T_STRUCT) {
|
|
xfer += this->options.read(iprot);
|
|
this->__isset.options = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_Write_args::write(apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("DB_Write_args");
|
|
xfer += oprot->writeFieldBegin("dbhandle", apache::thrift::protocol::T_STRUCT, 1);
|
|
xfer += this->dbhandle.write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("batch", apache::thrift::protocol::T_LIST, 2);
|
|
{
|
|
xfer += oprot->writeListBegin(apache::thrift::protocol::T_STRUCT, this->batch.size());
|
|
std::vector<kv> ::const_iterator _iter17;
|
|
for (_iter17 = this->batch.begin(); _iter17 != this->batch.end(); ++_iter17)
|
|
{
|
|
xfer += (*_iter17).write(oprot);
|
|
}
|
|
xfer += oprot->writeListEnd();
|
|
}
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("options", apache::thrift::protocol::T_STRUCT, 3);
|
|
xfer += this->options.write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_Write_pargs::write(apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("DB_Write_pargs");
|
|
xfer += oprot->writeFieldBegin("dbhandle", apache::thrift::protocol::T_STRUCT, 1);
|
|
xfer += (*(this->dbhandle)).write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("batch", apache::thrift::protocol::T_LIST, 2);
|
|
{
|
|
xfer += oprot->writeListBegin(apache::thrift::protocol::T_STRUCT, (*(this->batch)).size());
|
|
std::vector<kv> ::const_iterator _iter18;
|
|
for (_iter18 = (*(this->batch)).begin(); _iter18 != (*(this->batch)).end(); ++_iter18)
|
|
{
|
|
xfer += (*_iter18).write(oprot);
|
|
}
|
|
xfer += oprot->writeListEnd();
|
|
}
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("options", apache::thrift::protocol::T_STRUCT, 3);
|
|
xfer += (*(this->options)).write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_Write_result::read(apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == apache::thrift::protocol::T_I32) {
|
|
int32_t ecast19;
|
|
xfer += iprot->readI32(ecast19);
|
|
this->success = (Code)ecast19;
|
|
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 DB_Write_result::write(apache::thrift::protocol::TProtocol* oprot) const {
|
|
|
|
uint32_t xfer = 0;
|
|
|
|
xfer += oprot->writeStructBegin("DB_Write_result");
|
|
|
|
if (this->__isset.success) {
|
|
xfer += oprot->writeFieldBegin("success", apache::thrift::protocol::T_I32, 0);
|
|
xfer += oprot->writeI32((int32_t)this->success);
|
|
xfer += oprot->writeFieldEnd();
|
|
}
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_Write_presult::read(apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == apache::thrift::protocol::T_I32) {
|
|
int32_t ecast20;
|
|
xfer += iprot->readI32(ecast20);
|
|
(*(this->success)) = (Code)ecast20;
|
|
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 DB_Get_args::read(apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 1:
|
|
if (ftype == apache::thrift::protocol::T_STRUCT) {
|
|
xfer += this->dbhandle.read(iprot);
|
|
this->__isset.dbhandle = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
case 2:
|
|
if (ftype == apache::thrift::protocol::T_STRUCT) {
|
|
xfer += this->inputkey.read(iprot);
|
|
this->__isset.inputkey = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
case 3:
|
|
if (ftype == apache::thrift::protocol::T_STRUCT) {
|
|
xfer += this->options.read(iprot);
|
|
this->__isset.options = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_Get_args::write(apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("DB_Get_args");
|
|
xfer += oprot->writeFieldBegin("dbhandle", apache::thrift::protocol::T_STRUCT, 1);
|
|
xfer += this->dbhandle.write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("inputkey", apache::thrift::protocol::T_STRUCT, 2);
|
|
xfer += this->inputkey.write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("options", apache::thrift::protocol::T_STRUCT, 3);
|
|
xfer += this->options.write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_Get_pargs::write(apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("DB_Get_pargs");
|
|
xfer += oprot->writeFieldBegin("dbhandle", apache::thrift::protocol::T_STRUCT, 1);
|
|
xfer += (*(this->dbhandle)).write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("inputkey", apache::thrift::protocol::T_STRUCT, 2);
|
|
xfer += (*(this->inputkey)).write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("options", apache::thrift::protocol::T_STRUCT, 3);
|
|
xfer += (*(this->options)).write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_Get_result::read(apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == apache::thrift::protocol::T_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 DB_Get_result::write(apache::thrift::protocol::TProtocol* oprot) const {
|
|
|
|
uint32_t xfer = 0;
|
|
|
|
xfer += oprot->writeStructBegin("DB_Get_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;
|
|
}
|
|
|
|
uint32_t DB_Get_presult::read(apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == apache::thrift::protocol::T_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 DB_NewIterator_args::read(apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 1:
|
|
if (ftype == apache::thrift::protocol::T_STRUCT) {
|
|
xfer += this->dbhandle.read(iprot);
|
|
this->__isset.dbhandle = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
case 2:
|
|
if (ftype == apache::thrift::protocol::T_STRUCT) {
|
|
xfer += this->options.read(iprot);
|
|
this->__isset.options = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
case 3:
|
|
if (ftype == apache::thrift::protocol::T_I32) {
|
|
int32_t ecast21;
|
|
xfer += iprot->readI32(ecast21);
|
|
this->iteratorType = (IteratorType)ecast21;
|
|
this->__isset.iteratorType = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
case 4:
|
|
if (ftype == apache::thrift::protocol::T_STRUCT) {
|
|
xfer += this->target.read(iprot);
|
|
this->__isset.target = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_NewIterator_args::write(apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("DB_NewIterator_args");
|
|
xfer += oprot->writeFieldBegin("dbhandle", apache::thrift::protocol::T_STRUCT, 1);
|
|
xfer += this->dbhandle.write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("options", apache::thrift::protocol::T_STRUCT, 2);
|
|
xfer += this->options.write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("iteratorType", apache::thrift::protocol::T_I32, 3);
|
|
xfer += oprot->writeI32((int32_t)this->iteratorType);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("target", apache::thrift::protocol::T_STRUCT, 4);
|
|
xfer += this->target.write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_NewIterator_pargs::write(apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("DB_NewIterator_pargs");
|
|
xfer += oprot->writeFieldBegin("dbhandle", apache::thrift::protocol::T_STRUCT, 1);
|
|
xfer += (*(this->dbhandle)).write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("options", apache::thrift::protocol::T_STRUCT, 2);
|
|
xfer += (*(this->options)).write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("iteratorType", apache::thrift::protocol::T_I32, 3);
|
|
xfer += oprot->writeI32((int32_t)(*(this->iteratorType)));
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("target", apache::thrift::protocol::T_STRUCT, 4);
|
|
xfer += (*(this->target)).write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_NewIterator_result::read(apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == apache::thrift::protocol::T_STRUCT) {
|
|
xfer += this->success.read(iprot);
|
|
this->__isset.success = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_NewIterator_result::write(apache::thrift::protocol::TProtocol* oprot) const {
|
|
|
|
uint32_t xfer = 0;
|
|
|
|
xfer += oprot->writeStructBegin("DB_NewIterator_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;
|
|
}
|
|
|
|
uint32_t DB_NewIterator_presult::read(apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == apache::thrift::protocol::T_STRUCT) {
|
|
xfer += (*(this->success)).read(iprot);
|
|
this->__isset.success = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_DeleteIterator_args::read(apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 1:
|
|
if (ftype == apache::thrift::protocol::T_STRUCT) {
|
|
xfer += this->dbhandle.read(iprot);
|
|
this->__isset.dbhandle = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
case 2:
|
|
if (ftype == apache::thrift::protocol::T_STRUCT) {
|
|
xfer += this->iterator.read(iprot);
|
|
this->__isset.iterator = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_DeleteIterator_args::write(apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("DB_DeleteIterator_args");
|
|
xfer += oprot->writeFieldBegin("dbhandle", apache::thrift::protocol::T_STRUCT, 1);
|
|
xfer += this->dbhandle.write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("iterator", apache::thrift::protocol::T_STRUCT, 2);
|
|
xfer += this->iterator.write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_DeleteIterator_pargs::write(apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("DB_DeleteIterator_pargs");
|
|
xfer += oprot->writeFieldBegin("dbhandle", apache::thrift::protocol::T_STRUCT, 1);
|
|
xfer += (*(this->dbhandle)).write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("iterator", apache::thrift::protocol::T_STRUCT, 2);
|
|
xfer += (*(this->iterator)).write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_DeleteIterator_result::read(apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == apache::thrift::protocol::T_I32) {
|
|
int32_t ecast22;
|
|
xfer += iprot->readI32(ecast22);
|
|
this->success = (Code)ecast22;
|
|
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 DB_DeleteIterator_result::write(apache::thrift::protocol::TProtocol* oprot) const {
|
|
|
|
uint32_t xfer = 0;
|
|
|
|
xfer += oprot->writeStructBegin("DB_DeleteIterator_result");
|
|
|
|
if (this->__isset.success) {
|
|
xfer += oprot->writeFieldBegin("success", apache::thrift::protocol::T_I32, 0);
|
|
xfer += oprot->writeI32((int32_t)this->success);
|
|
xfer += oprot->writeFieldEnd();
|
|
}
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_DeleteIterator_presult::read(apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == apache::thrift::protocol::T_I32) {
|
|
int32_t ecast23;
|
|
xfer += iprot->readI32(ecast23);
|
|
(*(this->success)) = (Code)ecast23;
|
|
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 DB_GetNext_args::read(apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 1:
|
|
if (ftype == apache::thrift::protocol::T_STRUCT) {
|
|
xfer += this->dbhandle.read(iprot);
|
|
this->__isset.dbhandle = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
case 2:
|
|
if (ftype == apache::thrift::protocol::T_STRUCT) {
|
|
xfer += this->iterator.read(iprot);
|
|
this->__isset.iterator = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_GetNext_args::write(apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("DB_GetNext_args");
|
|
xfer += oprot->writeFieldBegin("dbhandle", apache::thrift::protocol::T_STRUCT, 1);
|
|
xfer += this->dbhandle.write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("iterator", apache::thrift::protocol::T_STRUCT, 2);
|
|
xfer += this->iterator.write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_GetNext_pargs::write(apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("DB_GetNext_pargs");
|
|
xfer += oprot->writeFieldBegin("dbhandle", apache::thrift::protocol::T_STRUCT, 1);
|
|
xfer += (*(this->dbhandle)).write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("iterator", apache::thrift::protocol::T_STRUCT, 2);
|
|
xfer += (*(this->iterator)).write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_GetNext_result::read(apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == apache::thrift::protocol::T_STRUCT) {
|
|
xfer += this->success.read(iprot);
|
|
this->__isset.success = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_GetNext_result::write(apache::thrift::protocol::TProtocol* oprot) const {
|
|
|
|
uint32_t xfer = 0;
|
|
|
|
xfer += oprot->writeStructBegin("DB_GetNext_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;
|
|
}
|
|
|
|
uint32_t DB_GetNext_presult::read(apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == apache::thrift::protocol::T_STRUCT) {
|
|
xfer += (*(this->success)).read(iprot);
|
|
this->__isset.success = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_GetPrev_args::read(apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 1:
|
|
if (ftype == apache::thrift::protocol::T_STRUCT) {
|
|
xfer += this->dbhandle.read(iprot);
|
|
this->__isset.dbhandle = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
case 2:
|
|
if (ftype == apache::thrift::protocol::T_STRUCT) {
|
|
xfer += this->iterator.read(iprot);
|
|
this->__isset.iterator = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_GetPrev_args::write(apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("DB_GetPrev_args");
|
|
xfer += oprot->writeFieldBegin("dbhandle", apache::thrift::protocol::T_STRUCT, 1);
|
|
xfer += this->dbhandle.write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("iterator", apache::thrift::protocol::T_STRUCT, 2);
|
|
xfer += this->iterator.write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_GetPrev_pargs::write(apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("DB_GetPrev_pargs");
|
|
xfer += oprot->writeFieldBegin("dbhandle", apache::thrift::protocol::T_STRUCT, 1);
|
|
xfer += (*(this->dbhandle)).write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("iterator", apache::thrift::protocol::T_STRUCT, 2);
|
|
xfer += (*(this->iterator)).write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_GetPrev_result::read(apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == apache::thrift::protocol::T_STRUCT) {
|
|
xfer += this->success.read(iprot);
|
|
this->__isset.success = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_GetPrev_result::write(apache::thrift::protocol::TProtocol* oprot) const {
|
|
|
|
uint32_t xfer = 0;
|
|
|
|
xfer += oprot->writeStructBegin("DB_GetPrev_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;
|
|
}
|
|
|
|
uint32_t DB_GetPrev_presult::read(apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == apache::thrift::protocol::T_STRUCT) {
|
|
xfer += (*(this->success)).read(iprot);
|
|
this->__isset.success = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_GetSnapshot_args::read(apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 1:
|
|
if (ftype == apache::thrift::protocol::T_STRUCT) {
|
|
xfer += this->dbhandle.read(iprot);
|
|
this->__isset.dbhandle = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_GetSnapshot_args::write(apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("DB_GetSnapshot_args");
|
|
xfer += oprot->writeFieldBegin("dbhandle", apache::thrift::protocol::T_STRUCT, 1);
|
|
xfer += this->dbhandle.write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_GetSnapshot_pargs::write(apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("DB_GetSnapshot_pargs");
|
|
xfer += oprot->writeFieldBegin("dbhandle", apache::thrift::protocol::T_STRUCT, 1);
|
|
xfer += (*(this->dbhandle)).write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_GetSnapshot_result::read(apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == apache::thrift::protocol::T_STRUCT) {
|
|
xfer += this->success.read(iprot);
|
|
this->__isset.success = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_GetSnapshot_result::write(apache::thrift::protocol::TProtocol* oprot) const {
|
|
|
|
uint32_t xfer = 0;
|
|
|
|
xfer += oprot->writeStructBegin("DB_GetSnapshot_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;
|
|
}
|
|
|
|
uint32_t DB_GetSnapshot_presult::read(apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == apache::thrift::protocol::T_STRUCT) {
|
|
xfer += (*(this->success)).read(iprot);
|
|
this->__isset.success = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_ReleaseSnapshot_args::read(apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 1:
|
|
if (ftype == apache::thrift::protocol::T_STRUCT) {
|
|
xfer += this->dbhandle.read(iprot);
|
|
this->__isset.dbhandle = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
case 2:
|
|
if (ftype == apache::thrift::protocol::T_STRUCT) {
|
|
xfer += this->snapshot.read(iprot);
|
|
this->__isset.snapshot = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_ReleaseSnapshot_args::write(apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("DB_ReleaseSnapshot_args");
|
|
xfer += oprot->writeFieldBegin("dbhandle", apache::thrift::protocol::T_STRUCT, 1);
|
|
xfer += this->dbhandle.write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("snapshot", apache::thrift::protocol::T_STRUCT, 2);
|
|
xfer += this->snapshot.write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_ReleaseSnapshot_pargs::write(apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("DB_ReleaseSnapshot_pargs");
|
|
xfer += oprot->writeFieldBegin("dbhandle", apache::thrift::protocol::T_STRUCT, 1);
|
|
xfer += (*(this->dbhandle)).write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("snapshot", apache::thrift::protocol::T_STRUCT, 2);
|
|
xfer += (*(this->snapshot)).write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_ReleaseSnapshot_result::read(apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == apache::thrift::protocol::T_I32) {
|
|
int32_t ecast24;
|
|
xfer += iprot->readI32(ecast24);
|
|
this->success = (Code)ecast24;
|
|
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 DB_ReleaseSnapshot_result::write(apache::thrift::protocol::TProtocol* oprot) const {
|
|
|
|
uint32_t xfer = 0;
|
|
|
|
xfer += oprot->writeStructBegin("DB_ReleaseSnapshot_result");
|
|
|
|
if (this->__isset.success) {
|
|
xfer += oprot->writeFieldBegin("success", apache::thrift::protocol::T_I32, 0);
|
|
xfer += oprot->writeI32((int32_t)this->success);
|
|
xfer += oprot->writeFieldEnd();
|
|
}
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_ReleaseSnapshot_presult::read(apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == apache::thrift::protocol::T_I32) {
|
|
int32_t ecast25;
|
|
xfer += iprot->readI32(ecast25);
|
|
(*(this->success)) = (Code)ecast25;
|
|
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 DB_CompactRange_args::read(apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 1:
|
|
if (ftype == apache::thrift::protocol::T_STRUCT) {
|
|
xfer += this->dbhandle.read(iprot);
|
|
this->__isset.dbhandle = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
case 2:
|
|
if (ftype == apache::thrift::protocol::T_STRUCT) {
|
|
xfer += this->begin.read(iprot);
|
|
this->__isset.begin = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
case 3:
|
|
if (ftype == apache::thrift::protocol::T_STRUCT) {
|
|
xfer += this->end.read(iprot);
|
|
this->__isset.end = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_CompactRange_args::write(apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("DB_CompactRange_args");
|
|
xfer += oprot->writeFieldBegin("dbhandle", apache::thrift::protocol::T_STRUCT, 1);
|
|
xfer += this->dbhandle.write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("begin", apache::thrift::protocol::T_STRUCT, 2);
|
|
xfer += this->begin.write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("end", apache::thrift::protocol::T_STRUCT, 3);
|
|
xfer += this->end.write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_CompactRange_pargs::write(apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("DB_CompactRange_pargs");
|
|
xfer += oprot->writeFieldBegin("dbhandle", apache::thrift::protocol::T_STRUCT, 1);
|
|
xfer += (*(this->dbhandle)).write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("begin", apache::thrift::protocol::T_STRUCT, 2);
|
|
xfer += (*(this->begin)).write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("end", apache::thrift::protocol::T_STRUCT, 3);
|
|
xfer += (*(this->end)).write(oprot);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_CompactRange_result::read(apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == apache::thrift::protocol::T_I32) {
|
|
int32_t ecast26;
|
|
xfer += iprot->readI32(ecast26);
|
|
this->success = (Code)ecast26;
|
|
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 DB_CompactRange_result::write(apache::thrift::protocol::TProtocol* oprot) const {
|
|
|
|
uint32_t xfer = 0;
|
|
|
|
xfer += oprot->writeStructBegin("DB_CompactRange_result");
|
|
|
|
if (this->__isset.success) {
|
|
xfer += oprot->writeFieldBegin("success", apache::thrift::protocol::T_I32, 0);
|
|
xfer += oprot->writeI32((int32_t)this->success);
|
|
xfer += oprot->writeFieldEnd();
|
|
}
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t DB_CompactRange_presult::read(apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == apache::thrift::protocol::T_I32) {
|
|
int32_t ecast27;
|
|
xfer += iprot->readI32(ecast27);
|
|
(*(this->success)) = (Code)ecast27;
|
|
this->__isset.success = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
int32_t DBClient::getNextSendSequenceId()
|
|
{
|
|
return nextSendSequenceId_++;
|
|
}
|
|
|
|
int32_t DBClient::getNextRecvSequenceId()
|
|
{
|
|
return nextRecvSequenceId_++;
|
|
}
|
|
|
|
void DBClient::Open(DBHandle& _return, const Text& dbname, const DBOptions& dboptions)
|
|
{
|
|
std::unique_ptr<apache::thrift::ContextStack> ctx(this->getContextStack("DB.Open", NULL));
|
|
|
|
try {
|
|
this->setContextStack(ctx.get());
|
|
send_Open(dbname, dboptions);
|
|
recv_Open(_return);
|
|
} catch(apache::thrift::transport::TTransportException& ex) {
|
|
this->handlerError(ctx.get(), "DB.Open");
|
|
iprot_->getTransport()->close();
|
|
oprot_->getTransport()->close();
|
|
throw;
|
|
} catch(apache::thrift::TApplicationException& ex) {
|
|
if (ex.getType() == apache::thrift::TApplicationException::BAD_SEQUENCE_ID) {
|
|
this->handlerError(ctx.get(), "DB.Open");
|
|
iprot_->getTransport()->close();
|
|
oprot_->getTransport()->close();
|
|
}
|
|
throw;
|
|
}
|
|
}
|
|
|
|
void DBClient::send_Open(const Text& dbname, const DBOptions& dboptions)
|
|
{
|
|
apache::thrift::ContextStack* ctx = this->getContextStack();
|
|
this->preWrite(ctx, "DB.Open");
|
|
oprot_->writeMessageBegin("Open", apache::thrift::protocol::T_CALL, getNextSendSequenceId());
|
|
|
|
DB_Open_pargs args;
|
|
args.dbname = &dbname;
|
|
args.dboptions = &dboptions;
|
|
args.write(oprot_);
|
|
|
|
oprot_->writeMessageEnd();
|
|
uint32_t _bytes28 = oprot_->getTransport()->writeEnd();
|
|
oprot_->getTransport()->flush();
|
|
this->postWrite(ctx, "DB.Open", _bytes28);
|
|
return;
|
|
}
|
|
|
|
void DBClient::recv_Open(DBHandle& _return)
|
|
{
|
|
apache::thrift::ContextStack* ctx = this->getContextStack();
|
|
uint32_t bytes;
|
|
int32_t rseqid = 0;
|
|
int32_t eseqid = getNextRecvSequenceId();
|
|
std::string fname;
|
|
apache::thrift::protocol::TMessageType mtype;
|
|
this->preRead(ctx, "DB.Open");
|
|
|
|
iprot_->readMessageBegin(fname, mtype, rseqid);
|
|
if (this->checkSeqid_ && rseqid != eseqid) {
|
|
iprot_->skip(apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::BAD_SEQUENCE_ID);
|
|
}
|
|
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();
|
|
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
|
|
}
|
|
if (fname.compare("Open") != 0) {
|
|
iprot_->skip(apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME);
|
|
}
|
|
DB_Open_presult result;
|
|
result.success = &_return;
|
|
result.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
bytes = iprot_->getTransport()->readEnd();
|
|
this->postRead(ctx, "DB.Open", bytes);
|
|
|
|
if (result.__isset.success) {
|
|
// _return pointer has now been filled
|
|
return;
|
|
}
|
|
if (result.__isset.se) {
|
|
throw result.se;
|
|
}
|
|
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::MISSING_RESULT, "Open failed: unknown result");
|
|
}
|
|
|
|
Code DBClient::Close(const DBHandle& dbhandle, const Text& dbname)
|
|
{
|
|
std::unique_ptr<apache::thrift::ContextStack> ctx(this->getContextStack("DB.Close", NULL));
|
|
|
|
try {
|
|
this->setContextStack(ctx.get());
|
|
send_Close(dbhandle, dbname);
|
|
return recv_Close();
|
|
} catch(apache::thrift::transport::TTransportException& ex) {
|
|
this->handlerError(ctx.get(), "DB.Close");
|
|
iprot_->getTransport()->close();
|
|
oprot_->getTransport()->close();
|
|
throw;
|
|
} catch(apache::thrift::TApplicationException& ex) {
|
|
if (ex.getType() == apache::thrift::TApplicationException::BAD_SEQUENCE_ID) {
|
|
this->handlerError(ctx.get(), "DB.Close");
|
|
iprot_->getTransport()->close();
|
|
oprot_->getTransport()->close();
|
|
}
|
|
throw;
|
|
}
|
|
}
|
|
|
|
void DBClient::send_Close(const DBHandle& dbhandle, const Text& dbname)
|
|
{
|
|
apache::thrift::ContextStack* ctx = this->getContextStack();
|
|
this->preWrite(ctx, "DB.Close");
|
|
oprot_->writeMessageBegin("Close", apache::thrift::protocol::T_CALL, getNextSendSequenceId());
|
|
|
|
DB_Close_pargs args;
|
|
args.dbhandle = &dbhandle;
|
|
args.dbname = &dbname;
|
|
args.write(oprot_);
|
|
|
|
oprot_->writeMessageEnd();
|
|
uint32_t _bytes29 = oprot_->getTransport()->writeEnd();
|
|
oprot_->getTransport()->flush();
|
|
this->postWrite(ctx, "DB.Close", _bytes29);
|
|
return;
|
|
}
|
|
|
|
Code DBClient::recv_Close()
|
|
{
|
|
apache::thrift::ContextStack* ctx = this->getContextStack();
|
|
uint32_t bytes;
|
|
int32_t rseqid = 0;
|
|
int32_t eseqid = getNextRecvSequenceId();
|
|
std::string fname;
|
|
apache::thrift::protocol::TMessageType mtype;
|
|
this->preRead(ctx, "DB.Close");
|
|
|
|
iprot_->readMessageBegin(fname, mtype, rseqid);
|
|
if (this->checkSeqid_ && rseqid != eseqid) {
|
|
iprot_->skip(apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::BAD_SEQUENCE_ID);
|
|
}
|
|
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();
|
|
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
|
|
}
|
|
if (fname.compare("Close") != 0) {
|
|
iprot_->skip(apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME);
|
|
}
|
|
Code _return;
|
|
DB_Close_presult result;
|
|
result.success = &_return;
|
|
result.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
bytes = iprot_->getTransport()->readEnd();
|
|
this->postRead(ctx, "DB.Close", bytes);
|
|
|
|
if (result.__isset.success) {
|
|
return _return;
|
|
}
|
|
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::MISSING_RESULT, "Close failed: unknown result");
|
|
}
|
|
|
|
Code DBClient::Put(const DBHandle& dbhandle, const kv& keyvalue, const WriteOptions& options)
|
|
{
|
|
std::unique_ptr<apache::thrift::ContextStack> ctx(this->getContextStack("DB.Put", NULL));
|
|
|
|
try {
|
|
this->setContextStack(ctx.get());
|
|
send_Put(dbhandle, keyvalue, options);
|
|
return recv_Put();
|
|
} catch(apache::thrift::transport::TTransportException& ex) {
|
|
this->handlerError(ctx.get(), "DB.Put");
|
|
iprot_->getTransport()->close();
|
|
oprot_->getTransport()->close();
|
|
throw;
|
|
} catch(apache::thrift::TApplicationException& ex) {
|
|
if (ex.getType() == apache::thrift::TApplicationException::BAD_SEQUENCE_ID) {
|
|
this->handlerError(ctx.get(), "DB.Put");
|
|
iprot_->getTransport()->close();
|
|
oprot_->getTransport()->close();
|
|
}
|
|
throw;
|
|
}
|
|
}
|
|
|
|
void DBClient::send_Put(const DBHandle& dbhandle, const kv& keyvalue, const WriteOptions& options)
|
|
{
|
|
apache::thrift::ContextStack* ctx = this->getContextStack();
|
|
this->preWrite(ctx, "DB.Put");
|
|
oprot_->writeMessageBegin("Put", apache::thrift::protocol::T_CALL, getNextSendSequenceId());
|
|
|
|
DB_Put_pargs args;
|
|
args.dbhandle = &dbhandle;
|
|
args.keyvalue = &keyvalue;
|
|
args.options = &options;
|
|
args.write(oprot_);
|
|
|
|
oprot_->writeMessageEnd();
|
|
uint32_t _bytes30 = oprot_->getTransport()->writeEnd();
|
|
oprot_->getTransport()->flush();
|
|
this->postWrite(ctx, "DB.Put", _bytes30);
|
|
return;
|
|
}
|
|
|
|
Code DBClient::recv_Put()
|
|
{
|
|
apache::thrift::ContextStack* ctx = this->getContextStack();
|
|
uint32_t bytes;
|
|
int32_t rseqid = 0;
|
|
int32_t eseqid = getNextRecvSequenceId();
|
|
std::string fname;
|
|
apache::thrift::protocol::TMessageType mtype;
|
|
this->preRead(ctx, "DB.Put");
|
|
|
|
iprot_->readMessageBegin(fname, mtype, rseqid);
|
|
if (this->checkSeqid_ && rseqid != eseqid) {
|
|
iprot_->skip(apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::BAD_SEQUENCE_ID);
|
|
}
|
|
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();
|
|
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
|
|
}
|
|
if (fname.compare("Put") != 0) {
|
|
iprot_->skip(apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME);
|
|
}
|
|
Code _return;
|
|
DB_Put_presult result;
|
|
result.success = &_return;
|
|
result.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
bytes = iprot_->getTransport()->readEnd();
|
|
this->postRead(ctx, "DB.Put", bytes);
|
|
|
|
if (result.__isset.success) {
|
|
return _return;
|
|
}
|
|
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::MISSING_RESULT, "Put failed: unknown result");
|
|
}
|
|
|
|
Code DBClient::Delete(const DBHandle& dbhandle, const Slice& key, const WriteOptions& options)
|
|
{
|
|
std::unique_ptr<apache::thrift::ContextStack> ctx(this->getContextStack("DB.Delete", NULL));
|
|
|
|
try {
|
|
this->setContextStack(ctx.get());
|
|
send_Delete(dbhandle, key, options);
|
|
return recv_Delete();
|
|
} catch(apache::thrift::transport::TTransportException& ex) {
|
|
this->handlerError(ctx.get(), "DB.Delete");
|
|
iprot_->getTransport()->close();
|
|
oprot_->getTransport()->close();
|
|
throw;
|
|
} catch(apache::thrift::TApplicationException& ex) {
|
|
if (ex.getType() == apache::thrift::TApplicationException::BAD_SEQUENCE_ID) {
|
|
this->handlerError(ctx.get(), "DB.Delete");
|
|
iprot_->getTransport()->close();
|
|
oprot_->getTransport()->close();
|
|
}
|
|
throw;
|
|
}
|
|
}
|
|
|
|
void DBClient::send_Delete(const DBHandle& dbhandle, const Slice& key, const WriteOptions& options)
|
|
{
|
|
apache::thrift::ContextStack* ctx = this->getContextStack();
|
|
this->preWrite(ctx, "DB.Delete");
|
|
oprot_->writeMessageBegin("Delete", apache::thrift::protocol::T_CALL, getNextSendSequenceId());
|
|
|
|
DB_Delete_pargs args;
|
|
args.dbhandle = &dbhandle;
|
|
args.key = &key;
|
|
args.options = &options;
|
|
args.write(oprot_);
|
|
|
|
oprot_->writeMessageEnd();
|
|
uint32_t _bytes31 = oprot_->getTransport()->writeEnd();
|
|
oprot_->getTransport()->flush();
|
|
this->postWrite(ctx, "DB.Delete", _bytes31);
|
|
return;
|
|
}
|
|
|
|
Code DBClient::recv_Delete()
|
|
{
|
|
apache::thrift::ContextStack* ctx = this->getContextStack();
|
|
uint32_t bytes;
|
|
int32_t rseqid = 0;
|
|
int32_t eseqid = getNextRecvSequenceId();
|
|
std::string fname;
|
|
apache::thrift::protocol::TMessageType mtype;
|
|
this->preRead(ctx, "DB.Delete");
|
|
|
|
iprot_->readMessageBegin(fname, mtype, rseqid);
|
|
if (this->checkSeqid_ && rseqid != eseqid) {
|
|
iprot_->skip(apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::BAD_SEQUENCE_ID);
|
|
}
|
|
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();
|
|
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
|
|
}
|
|
if (fname.compare("Delete") != 0) {
|
|
iprot_->skip(apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME);
|
|
}
|
|
Code _return;
|
|
DB_Delete_presult result;
|
|
result.success = &_return;
|
|
result.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
bytes = iprot_->getTransport()->readEnd();
|
|
this->postRead(ctx, "DB.Delete", bytes);
|
|
|
|
if (result.__isset.success) {
|
|
return _return;
|
|
}
|
|
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::MISSING_RESULT, "Delete failed: unknown result");
|
|
}
|
|
|
|
Code DBClient::Write(const DBHandle& dbhandle, const std::vector<kv> & batch, const WriteOptions& options)
|
|
{
|
|
std::unique_ptr<apache::thrift::ContextStack> ctx(this->getContextStack("DB.Write", NULL));
|
|
|
|
try {
|
|
this->setContextStack(ctx.get());
|
|
send_Write(dbhandle, batch, options);
|
|
return recv_Write();
|
|
} catch(apache::thrift::transport::TTransportException& ex) {
|
|
this->handlerError(ctx.get(), "DB.Write");
|
|
iprot_->getTransport()->close();
|
|
oprot_->getTransport()->close();
|
|
throw;
|
|
} catch(apache::thrift::TApplicationException& ex) {
|
|
if (ex.getType() == apache::thrift::TApplicationException::BAD_SEQUENCE_ID) {
|
|
this->handlerError(ctx.get(), "DB.Write");
|
|
iprot_->getTransport()->close();
|
|
oprot_->getTransport()->close();
|
|
}
|
|
throw;
|
|
}
|
|
}
|
|
|
|
void DBClient::send_Write(const DBHandle& dbhandle, const std::vector<kv> & batch, const WriteOptions& options)
|
|
{
|
|
apache::thrift::ContextStack* ctx = this->getContextStack();
|
|
this->preWrite(ctx, "DB.Write");
|
|
oprot_->writeMessageBegin("Write", apache::thrift::protocol::T_CALL, getNextSendSequenceId());
|
|
|
|
DB_Write_pargs args;
|
|
args.dbhandle = &dbhandle;
|
|
args.batch = &batch;
|
|
args.options = &options;
|
|
args.write(oprot_);
|
|
|
|
oprot_->writeMessageEnd();
|
|
uint32_t _bytes32 = oprot_->getTransport()->writeEnd();
|
|
oprot_->getTransport()->flush();
|
|
this->postWrite(ctx, "DB.Write", _bytes32);
|
|
return;
|
|
}
|
|
|
|
Code DBClient::recv_Write()
|
|
{
|
|
apache::thrift::ContextStack* ctx = this->getContextStack();
|
|
uint32_t bytes;
|
|
int32_t rseqid = 0;
|
|
int32_t eseqid = getNextRecvSequenceId();
|
|
std::string fname;
|
|
apache::thrift::protocol::TMessageType mtype;
|
|
this->preRead(ctx, "DB.Write");
|
|
|
|
iprot_->readMessageBegin(fname, mtype, rseqid);
|
|
if (this->checkSeqid_ && rseqid != eseqid) {
|
|
iprot_->skip(apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::BAD_SEQUENCE_ID);
|
|
}
|
|
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();
|
|
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
|
|
}
|
|
if (fname.compare("Write") != 0) {
|
|
iprot_->skip(apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME);
|
|
}
|
|
Code _return;
|
|
DB_Write_presult result;
|
|
result.success = &_return;
|
|
result.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
bytes = iprot_->getTransport()->readEnd();
|
|
this->postRead(ctx, "DB.Write", bytes);
|
|
|
|
if (result.__isset.success) {
|
|
return _return;
|
|
}
|
|
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::MISSING_RESULT, "Write failed: unknown result");
|
|
}
|
|
|
|
void DBClient::Get(ResultItem& _return, const DBHandle& dbhandle, const Slice& inputkey, const ReadOptions& options)
|
|
{
|
|
std::unique_ptr<apache::thrift::ContextStack> ctx(this->getContextStack("DB.Get", NULL));
|
|
|
|
try {
|
|
this->setContextStack(ctx.get());
|
|
send_Get(dbhandle, inputkey, options);
|
|
recv_Get(_return);
|
|
} catch(apache::thrift::transport::TTransportException& ex) {
|
|
this->handlerError(ctx.get(), "DB.Get");
|
|
iprot_->getTransport()->close();
|
|
oprot_->getTransport()->close();
|
|
throw;
|
|
} catch(apache::thrift::TApplicationException& ex) {
|
|
if (ex.getType() == apache::thrift::TApplicationException::BAD_SEQUENCE_ID) {
|
|
this->handlerError(ctx.get(), "DB.Get");
|
|
iprot_->getTransport()->close();
|
|
oprot_->getTransport()->close();
|
|
}
|
|
throw;
|
|
}
|
|
}
|
|
|
|
void DBClient::send_Get(const DBHandle& dbhandle, const Slice& inputkey, const ReadOptions& options)
|
|
{
|
|
apache::thrift::ContextStack* ctx = this->getContextStack();
|
|
this->preWrite(ctx, "DB.Get");
|
|
oprot_->writeMessageBegin("Get", apache::thrift::protocol::T_CALL, getNextSendSequenceId());
|
|
|
|
DB_Get_pargs args;
|
|
args.dbhandle = &dbhandle;
|
|
args.inputkey = &inputkey;
|
|
args.options = &options;
|
|
args.write(oprot_);
|
|
|
|
oprot_->writeMessageEnd();
|
|
uint32_t _bytes33 = oprot_->getTransport()->writeEnd();
|
|
oprot_->getTransport()->flush();
|
|
this->postWrite(ctx, "DB.Get", _bytes33);
|
|
return;
|
|
}
|
|
|
|
void DBClient::recv_Get(ResultItem& _return)
|
|
{
|
|
apache::thrift::ContextStack* ctx = this->getContextStack();
|
|
uint32_t bytes;
|
|
int32_t rseqid = 0;
|
|
int32_t eseqid = getNextRecvSequenceId();
|
|
std::string fname;
|
|
apache::thrift::protocol::TMessageType mtype;
|
|
this->preRead(ctx, "DB.Get");
|
|
|
|
iprot_->readMessageBegin(fname, mtype, rseqid);
|
|
if (this->checkSeqid_ && rseqid != eseqid) {
|
|
iprot_->skip(apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::BAD_SEQUENCE_ID);
|
|
}
|
|
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();
|
|
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
|
|
}
|
|
if (fname.compare("Get") != 0) {
|
|
iprot_->skip(apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME);
|
|
}
|
|
DB_Get_presult result;
|
|
result.success = &_return;
|
|
result.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
bytes = iprot_->getTransport()->readEnd();
|
|
this->postRead(ctx, "DB.Get", bytes);
|
|
|
|
if (result.__isset.success) {
|
|
// _return pointer has now been filled
|
|
return;
|
|
}
|
|
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::MISSING_RESULT, "Get failed: unknown result");
|
|
}
|
|
|
|
void DBClient::NewIterator(ResultIterator& _return, const DBHandle& dbhandle, const ReadOptions& options, IteratorType iteratorType, const Slice& target)
|
|
{
|
|
std::unique_ptr<apache::thrift::ContextStack> ctx(this->getContextStack("DB.NewIterator", NULL));
|
|
|
|
try {
|
|
this->setContextStack(ctx.get());
|
|
send_NewIterator(dbhandle, options, iteratorType, target);
|
|
recv_NewIterator(_return);
|
|
} catch(apache::thrift::transport::TTransportException& ex) {
|
|
this->handlerError(ctx.get(), "DB.NewIterator");
|
|
iprot_->getTransport()->close();
|
|
oprot_->getTransport()->close();
|
|
throw;
|
|
} catch(apache::thrift::TApplicationException& ex) {
|
|
if (ex.getType() == apache::thrift::TApplicationException::BAD_SEQUENCE_ID) {
|
|
this->handlerError(ctx.get(), "DB.NewIterator");
|
|
iprot_->getTransport()->close();
|
|
oprot_->getTransport()->close();
|
|
}
|
|
throw;
|
|
}
|
|
}
|
|
|
|
void DBClient::send_NewIterator(const DBHandle& dbhandle, const ReadOptions& options, IteratorType iteratorType, const Slice& target)
|
|
{
|
|
apache::thrift::ContextStack* ctx = this->getContextStack();
|
|
this->preWrite(ctx, "DB.NewIterator");
|
|
oprot_->writeMessageBegin("NewIterator", apache::thrift::protocol::T_CALL, getNextSendSequenceId());
|
|
|
|
DB_NewIterator_pargs args;
|
|
args.dbhandle = &dbhandle;
|
|
args.options = &options;
|
|
args.iteratorType = &iteratorType;
|
|
args.target = ⌖
|
|
args.write(oprot_);
|
|
|
|
oprot_->writeMessageEnd();
|
|
uint32_t _bytes34 = oprot_->getTransport()->writeEnd();
|
|
oprot_->getTransport()->flush();
|
|
this->postWrite(ctx, "DB.NewIterator", _bytes34);
|
|
return;
|
|
}
|
|
|
|
void DBClient::recv_NewIterator(ResultIterator& _return)
|
|
{
|
|
apache::thrift::ContextStack* ctx = this->getContextStack();
|
|
uint32_t bytes;
|
|
int32_t rseqid = 0;
|
|
int32_t eseqid = getNextRecvSequenceId();
|
|
std::string fname;
|
|
apache::thrift::protocol::TMessageType mtype;
|
|
this->preRead(ctx, "DB.NewIterator");
|
|
|
|
iprot_->readMessageBegin(fname, mtype, rseqid);
|
|
if (this->checkSeqid_ && rseqid != eseqid) {
|
|
iprot_->skip(apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::BAD_SEQUENCE_ID);
|
|
}
|
|
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();
|
|
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
|
|
}
|
|
if (fname.compare("NewIterator") != 0) {
|
|
iprot_->skip(apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME);
|
|
}
|
|
DB_NewIterator_presult result;
|
|
result.success = &_return;
|
|
result.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
bytes = iprot_->getTransport()->readEnd();
|
|
this->postRead(ctx, "DB.NewIterator", bytes);
|
|
|
|
if (result.__isset.success) {
|
|
// _return pointer has now been filled
|
|
return;
|
|
}
|
|
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::MISSING_RESULT, "NewIterator failed: unknown result");
|
|
}
|
|
|
|
Code DBClient::DeleteIterator(const DBHandle& dbhandle, const Iterator& iterator)
|
|
{
|
|
std::unique_ptr<apache::thrift::ContextStack> ctx(this->getContextStack("DB.DeleteIterator", NULL));
|
|
|
|
try {
|
|
this->setContextStack(ctx.get());
|
|
send_DeleteIterator(dbhandle, iterator);
|
|
return recv_DeleteIterator();
|
|
} catch(apache::thrift::transport::TTransportException& ex) {
|
|
this->handlerError(ctx.get(), "DB.DeleteIterator");
|
|
iprot_->getTransport()->close();
|
|
oprot_->getTransport()->close();
|
|
throw;
|
|
} catch(apache::thrift::TApplicationException& ex) {
|
|
if (ex.getType() == apache::thrift::TApplicationException::BAD_SEQUENCE_ID) {
|
|
this->handlerError(ctx.get(), "DB.DeleteIterator");
|
|
iprot_->getTransport()->close();
|
|
oprot_->getTransport()->close();
|
|
}
|
|
throw;
|
|
}
|
|
}
|
|
|
|
void DBClient::send_DeleteIterator(const DBHandle& dbhandle, const Iterator& iterator)
|
|
{
|
|
apache::thrift::ContextStack* ctx = this->getContextStack();
|
|
this->preWrite(ctx, "DB.DeleteIterator");
|
|
oprot_->writeMessageBegin("DeleteIterator", apache::thrift::protocol::T_CALL, getNextSendSequenceId());
|
|
|
|
DB_DeleteIterator_pargs args;
|
|
args.dbhandle = &dbhandle;
|
|
args.iterator = &iterator;
|
|
args.write(oprot_);
|
|
|
|
oprot_->writeMessageEnd();
|
|
uint32_t _bytes35 = oprot_->getTransport()->writeEnd();
|
|
oprot_->getTransport()->flush();
|
|
this->postWrite(ctx, "DB.DeleteIterator", _bytes35);
|
|
return;
|
|
}
|
|
|
|
Code DBClient::recv_DeleteIterator()
|
|
{
|
|
apache::thrift::ContextStack* ctx = this->getContextStack();
|
|
uint32_t bytes;
|
|
int32_t rseqid = 0;
|
|
int32_t eseqid = getNextRecvSequenceId();
|
|
std::string fname;
|
|
apache::thrift::protocol::TMessageType mtype;
|
|
this->preRead(ctx, "DB.DeleteIterator");
|
|
|
|
iprot_->readMessageBegin(fname, mtype, rseqid);
|
|
if (this->checkSeqid_ && rseqid != eseqid) {
|
|
iprot_->skip(apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::BAD_SEQUENCE_ID);
|
|
}
|
|
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();
|
|
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
|
|
}
|
|
if (fname.compare("DeleteIterator") != 0) {
|
|
iprot_->skip(apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME);
|
|
}
|
|
Code _return;
|
|
DB_DeleteIterator_presult result;
|
|
result.success = &_return;
|
|
result.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
bytes = iprot_->getTransport()->readEnd();
|
|
this->postRead(ctx, "DB.DeleteIterator", bytes);
|
|
|
|
if (result.__isset.success) {
|
|
return _return;
|
|
}
|
|
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::MISSING_RESULT, "DeleteIterator failed: unknown result");
|
|
}
|
|
|
|
void DBClient::GetNext(ResultPair& _return, const DBHandle& dbhandle, const Iterator& iterator)
|
|
{
|
|
std::unique_ptr<apache::thrift::ContextStack> ctx(this->getContextStack("DB.GetNext", NULL));
|
|
|
|
try {
|
|
this->setContextStack(ctx.get());
|
|
send_GetNext(dbhandle, iterator);
|
|
recv_GetNext(_return);
|
|
} catch(apache::thrift::transport::TTransportException& ex) {
|
|
this->handlerError(ctx.get(), "DB.GetNext");
|
|
iprot_->getTransport()->close();
|
|
oprot_->getTransport()->close();
|
|
throw;
|
|
} catch(apache::thrift::TApplicationException& ex) {
|
|
if (ex.getType() == apache::thrift::TApplicationException::BAD_SEQUENCE_ID) {
|
|
this->handlerError(ctx.get(), "DB.GetNext");
|
|
iprot_->getTransport()->close();
|
|
oprot_->getTransport()->close();
|
|
}
|
|
throw;
|
|
}
|
|
}
|
|
|
|
void DBClient::send_GetNext(const DBHandle& dbhandle, const Iterator& iterator)
|
|
{
|
|
apache::thrift::ContextStack* ctx = this->getContextStack();
|
|
this->preWrite(ctx, "DB.GetNext");
|
|
oprot_->writeMessageBegin("GetNext", apache::thrift::protocol::T_CALL, getNextSendSequenceId());
|
|
|
|
DB_GetNext_pargs args;
|
|
args.dbhandle = &dbhandle;
|
|
args.iterator = &iterator;
|
|
args.write(oprot_);
|
|
|
|
oprot_->writeMessageEnd();
|
|
uint32_t _bytes36 = oprot_->getTransport()->writeEnd();
|
|
oprot_->getTransport()->flush();
|
|
this->postWrite(ctx, "DB.GetNext", _bytes36);
|
|
return;
|
|
}
|
|
|
|
void DBClient::recv_GetNext(ResultPair& _return)
|
|
{
|
|
apache::thrift::ContextStack* ctx = this->getContextStack();
|
|
uint32_t bytes;
|
|
int32_t rseqid = 0;
|
|
int32_t eseqid = getNextRecvSequenceId();
|
|
std::string fname;
|
|
apache::thrift::protocol::TMessageType mtype;
|
|
this->preRead(ctx, "DB.GetNext");
|
|
|
|
iprot_->readMessageBegin(fname, mtype, rseqid);
|
|
if (this->checkSeqid_ && rseqid != eseqid) {
|
|
iprot_->skip(apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::BAD_SEQUENCE_ID);
|
|
}
|
|
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();
|
|
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
|
|
}
|
|
if (fname.compare("GetNext") != 0) {
|
|
iprot_->skip(apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME);
|
|
}
|
|
DB_GetNext_presult result;
|
|
result.success = &_return;
|
|
result.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
bytes = iprot_->getTransport()->readEnd();
|
|
this->postRead(ctx, "DB.GetNext", bytes);
|
|
|
|
if (result.__isset.success) {
|
|
// _return pointer has now been filled
|
|
return;
|
|
}
|
|
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::MISSING_RESULT, "GetNext failed: unknown result");
|
|
}
|
|
|
|
void DBClient::GetPrev(ResultPair& _return, const DBHandle& dbhandle, const Iterator& iterator)
|
|
{
|
|
std::unique_ptr<apache::thrift::ContextStack> ctx(this->getContextStack("DB.GetPrev", NULL));
|
|
|
|
try {
|
|
this->setContextStack(ctx.get());
|
|
send_GetPrev(dbhandle, iterator);
|
|
recv_GetPrev(_return);
|
|
} catch(apache::thrift::transport::TTransportException& ex) {
|
|
this->handlerError(ctx.get(), "DB.GetPrev");
|
|
iprot_->getTransport()->close();
|
|
oprot_->getTransport()->close();
|
|
throw;
|
|
} catch(apache::thrift::TApplicationException& ex) {
|
|
if (ex.getType() == apache::thrift::TApplicationException::BAD_SEQUENCE_ID) {
|
|
this->handlerError(ctx.get(), "DB.GetPrev");
|
|
iprot_->getTransport()->close();
|
|
oprot_->getTransport()->close();
|
|
}
|
|
throw;
|
|
}
|
|
}
|
|
|
|
void DBClient::send_GetPrev(const DBHandle& dbhandle, const Iterator& iterator)
|
|
{
|
|
apache::thrift::ContextStack* ctx = this->getContextStack();
|
|
this->preWrite(ctx, "DB.GetPrev");
|
|
oprot_->writeMessageBegin("GetPrev", apache::thrift::protocol::T_CALL, getNextSendSequenceId());
|
|
|
|
DB_GetPrev_pargs args;
|
|
args.dbhandle = &dbhandle;
|
|
args.iterator = &iterator;
|
|
args.write(oprot_);
|
|
|
|
oprot_->writeMessageEnd();
|
|
uint32_t _bytes37 = oprot_->getTransport()->writeEnd();
|
|
oprot_->getTransport()->flush();
|
|
this->postWrite(ctx, "DB.GetPrev", _bytes37);
|
|
return;
|
|
}
|
|
|
|
void DBClient::recv_GetPrev(ResultPair& _return)
|
|
{
|
|
apache::thrift::ContextStack* ctx = this->getContextStack();
|
|
uint32_t bytes;
|
|
int32_t rseqid = 0;
|
|
int32_t eseqid = getNextRecvSequenceId();
|
|
std::string fname;
|
|
apache::thrift::protocol::TMessageType mtype;
|
|
this->preRead(ctx, "DB.GetPrev");
|
|
|
|
iprot_->readMessageBegin(fname, mtype, rseqid);
|
|
if (this->checkSeqid_ && rseqid != eseqid) {
|
|
iprot_->skip(apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::BAD_SEQUENCE_ID);
|
|
}
|
|
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();
|
|
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
|
|
}
|
|
if (fname.compare("GetPrev") != 0) {
|
|
iprot_->skip(apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME);
|
|
}
|
|
DB_GetPrev_presult result;
|
|
result.success = &_return;
|
|
result.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
bytes = iprot_->getTransport()->readEnd();
|
|
this->postRead(ctx, "DB.GetPrev", bytes);
|
|
|
|
if (result.__isset.success) {
|
|
// _return pointer has now been filled
|
|
return;
|
|
}
|
|
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::MISSING_RESULT, "GetPrev failed: unknown result");
|
|
}
|
|
|
|
void DBClient::GetSnapshot(ResultSnapshot& _return, const DBHandle& dbhandle)
|
|
{
|
|
std::unique_ptr<apache::thrift::ContextStack> ctx(this->getContextStack("DB.GetSnapshot", NULL));
|
|
|
|
try {
|
|
this->setContextStack(ctx.get());
|
|
send_GetSnapshot(dbhandle);
|
|
recv_GetSnapshot(_return);
|
|
} catch(apache::thrift::transport::TTransportException& ex) {
|
|
this->handlerError(ctx.get(), "DB.GetSnapshot");
|
|
iprot_->getTransport()->close();
|
|
oprot_->getTransport()->close();
|
|
throw;
|
|
} catch(apache::thrift::TApplicationException& ex) {
|
|
if (ex.getType() == apache::thrift::TApplicationException::BAD_SEQUENCE_ID) {
|
|
this->handlerError(ctx.get(), "DB.GetSnapshot");
|
|
iprot_->getTransport()->close();
|
|
oprot_->getTransport()->close();
|
|
}
|
|
throw;
|
|
}
|
|
}
|
|
|
|
void DBClient::send_GetSnapshot(const DBHandle& dbhandle)
|
|
{
|
|
apache::thrift::ContextStack* ctx = this->getContextStack();
|
|
this->preWrite(ctx, "DB.GetSnapshot");
|
|
oprot_->writeMessageBegin("GetSnapshot", apache::thrift::protocol::T_CALL, getNextSendSequenceId());
|
|
|
|
DB_GetSnapshot_pargs args;
|
|
args.dbhandle = &dbhandle;
|
|
args.write(oprot_);
|
|
|
|
oprot_->writeMessageEnd();
|
|
uint32_t _bytes38 = oprot_->getTransport()->writeEnd();
|
|
oprot_->getTransport()->flush();
|
|
this->postWrite(ctx, "DB.GetSnapshot", _bytes38);
|
|
return;
|
|
}
|
|
|
|
void DBClient::recv_GetSnapshot(ResultSnapshot& _return)
|
|
{
|
|
apache::thrift::ContextStack* ctx = this->getContextStack();
|
|
uint32_t bytes;
|
|
int32_t rseqid = 0;
|
|
int32_t eseqid = getNextRecvSequenceId();
|
|
std::string fname;
|
|
apache::thrift::protocol::TMessageType mtype;
|
|
this->preRead(ctx, "DB.GetSnapshot");
|
|
|
|
iprot_->readMessageBegin(fname, mtype, rseqid);
|
|
if (this->checkSeqid_ && rseqid != eseqid) {
|
|
iprot_->skip(apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::BAD_SEQUENCE_ID);
|
|
}
|
|
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();
|
|
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
|
|
}
|
|
if (fname.compare("GetSnapshot") != 0) {
|
|
iprot_->skip(apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME);
|
|
}
|
|
DB_GetSnapshot_presult result;
|
|
result.success = &_return;
|
|
result.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
bytes = iprot_->getTransport()->readEnd();
|
|
this->postRead(ctx, "DB.GetSnapshot", bytes);
|
|
|
|
if (result.__isset.success) {
|
|
// _return pointer has now been filled
|
|
return;
|
|
}
|
|
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::MISSING_RESULT, "GetSnapshot failed: unknown result");
|
|
}
|
|
|
|
Code DBClient::ReleaseSnapshot(const DBHandle& dbhandle, const Snapshot& snapshot)
|
|
{
|
|
std::unique_ptr<apache::thrift::ContextStack> ctx(this->getContextStack("DB.ReleaseSnapshot", NULL));
|
|
|
|
try {
|
|
this->setContextStack(ctx.get());
|
|
send_ReleaseSnapshot(dbhandle, snapshot);
|
|
return recv_ReleaseSnapshot();
|
|
} catch(apache::thrift::transport::TTransportException& ex) {
|
|
this->handlerError(ctx.get(), "DB.ReleaseSnapshot");
|
|
iprot_->getTransport()->close();
|
|
oprot_->getTransport()->close();
|
|
throw;
|
|
} catch(apache::thrift::TApplicationException& ex) {
|
|
if (ex.getType() == apache::thrift::TApplicationException::BAD_SEQUENCE_ID) {
|
|
this->handlerError(ctx.get(), "DB.ReleaseSnapshot");
|
|
iprot_->getTransport()->close();
|
|
oprot_->getTransport()->close();
|
|
}
|
|
throw;
|
|
}
|
|
}
|
|
|
|
void DBClient::send_ReleaseSnapshot(const DBHandle& dbhandle, const Snapshot& snapshot)
|
|
{
|
|
apache::thrift::ContextStack* ctx = this->getContextStack();
|
|
this->preWrite(ctx, "DB.ReleaseSnapshot");
|
|
oprot_->writeMessageBegin("ReleaseSnapshot", apache::thrift::protocol::T_CALL, getNextSendSequenceId());
|
|
|
|
DB_ReleaseSnapshot_pargs args;
|
|
args.dbhandle = &dbhandle;
|
|
args.snapshot = &snapshot;
|
|
args.write(oprot_);
|
|
|
|
oprot_->writeMessageEnd();
|
|
uint32_t _bytes39 = oprot_->getTransport()->writeEnd();
|
|
oprot_->getTransport()->flush();
|
|
this->postWrite(ctx, "DB.ReleaseSnapshot", _bytes39);
|
|
return;
|
|
}
|
|
|
|
Code DBClient::recv_ReleaseSnapshot()
|
|
{
|
|
apache::thrift::ContextStack* ctx = this->getContextStack();
|
|
uint32_t bytes;
|
|
int32_t rseqid = 0;
|
|
int32_t eseqid = getNextRecvSequenceId();
|
|
std::string fname;
|
|
apache::thrift::protocol::TMessageType mtype;
|
|
this->preRead(ctx, "DB.ReleaseSnapshot");
|
|
|
|
iprot_->readMessageBegin(fname, mtype, rseqid);
|
|
if (this->checkSeqid_ && rseqid != eseqid) {
|
|
iprot_->skip(apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::BAD_SEQUENCE_ID);
|
|
}
|
|
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();
|
|
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
|
|
}
|
|
if (fname.compare("ReleaseSnapshot") != 0) {
|
|
iprot_->skip(apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME);
|
|
}
|
|
Code _return;
|
|
DB_ReleaseSnapshot_presult result;
|
|
result.success = &_return;
|
|
result.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
bytes = iprot_->getTransport()->readEnd();
|
|
this->postRead(ctx, "DB.ReleaseSnapshot", bytes);
|
|
|
|
if (result.__isset.success) {
|
|
return _return;
|
|
}
|
|
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::MISSING_RESULT, "ReleaseSnapshot failed: unknown result");
|
|
}
|
|
|
|
Code DBClient::CompactRange(const DBHandle& dbhandle, const Slice& begin, const Slice& end)
|
|
{
|
|
std::unique_ptr<apache::thrift::ContextStack> ctx(this->getContextStack("DB.CompactRange", NULL));
|
|
|
|
try {
|
|
this->setContextStack(ctx.get());
|
|
send_CompactRange(dbhandle, begin, end);
|
|
return recv_CompactRange();
|
|
} catch(apache::thrift::transport::TTransportException& ex) {
|
|
this->handlerError(ctx.get(), "DB.CompactRange");
|
|
iprot_->getTransport()->close();
|
|
oprot_->getTransport()->close();
|
|
throw;
|
|
} catch(apache::thrift::TApplicationException& ex) {
|
|
if (ex.getType() == apache::thrift::TApplicationException::BAD_SEQUENCE_ID) {
|
|
this->handlerError(ctx.get(), "DB.CompactRange");
|
|
iprot_->getTransport()->close();
|
|
oprot_->getTransport()->close();
|
|
}
|
|
throw;
|
|
}
|
|
}
|
|
|
|
void DBClient::send_CompactRange(const DBHandle& dbhandle, const Slice& begin, const Slice& end)
|
|
{
|
|
apache::thrift::ContextStack* ctx = this->getContextStack();
|
|
this->preWrite(ctx, "DB.CompactRange");
|
|
oprot_->writeMessageBegin("CompactRange", apache::thrift::protocol::T_CALL, getNextSendSequenceId());
|
|
|
|
DB_CompactRange_pargs args;
|
|
args.dbhandle = &dbhandle;
|
|
args.begin = &begin;
|
|
args.end = &end;
|
|
args.write(oprot_);
|
|
|
|
oprot_->writeMessageEnd();
|
|
uint32_t _bytes40 = oprot_->getTransport()->writeEnd();
|
|
oprot_->getTransport()->flush();
|
|
this->postWrite(ctx, "DB.CompactRange", _bytes40);
|
|
return;
|
|
}
|
|
|
|
Code DBClient::recv_CompactRange()
|
|
{
|
|
apache::thrift::ContextStack* ctx = this->getContextStack();
|
|
uint32_t bytes;
|
|
int32_t rseqid = 0;
|
|
int32_t eseqid = getNextRecvSequenceId();
|
|
std::string fname;
|
|
apache::thrift::protocol::TMessageType mtype;
|
|
this->preRead(ctx, "DB.CompactRange");
|
|
|
|
iprot_->readMessageBegin(fname, mtype, rseqid);
|
|
if (this->checkSeqid_ && rseqid != eseqid) {
|
|
iprot_->skip(apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::BAD_SEQUENCE_ID);
|
|
}
|
|
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();
|
|
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
|
|
}
|
|
if (fname.compare("CompactRange") != 0) {
|
|
iprot_->skip(apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME);
|
|
}
|
|
Code _return;
|
|
DB_CompactRange_presult result;
|
|
result.success = &_return;
|
|
result.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
bytes = iprot_->getTransport()->readEnd();
|
|
this->postRead(ctx, "DB.CompactRange", bytes);
|
|
|
|
if (result.__isset.success) {
|
|
return _return;
|
|
}
|
|
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::MISSING_RESULT, "CompactRange failed: unknown result");
|
|
}
|
|
|
|
bool DBProcessor::dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, apache::thrift::server::TConnectionContext* connectionContext) {
|
|
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;
|
|
}
|
|
const ProcessFunction& pf = pfn->second;
|
|
(this->*pf)(seqid, iprot, oprot, connectionContext);
|
|
return true;
|
|
}
|
|
|
|
void DBProcessor::process_Open(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, apache::thrift::server::TConnectionContext* connectionContext)
|
|
{
|
|
std::unique_ptr<apache::thrift::ContextStack> ctx(this->getContextStack("DB.Open", connectionContext));
|
|
|
|
this->preRead(ctx.get(), "DB.Open");
|
|
DB_Open_args args;
|
|
args.read(iprot);
|
|
iprot->readMessageEnd();
|
|
uint32_t bytes = iprot->getTransport()->readEnd();
|
|
|
|
this->postRead(ctx.get(), "DB.Open", bytes);
|
|
|
|
DB_Open_result result;
|
|
try {
|
|
iface_->Open(result.success, args.dbname, args.dboptions);
|
|
result.__isset.success = true;
|
|
} catch (LeveldbException &se) {
|
|
result.se = se;
|
|
result.__isset.se = true;
|
|
} catch (const std::exception& e) {
|
|
this->handlerError(ctx.get(), "DB.Open");
|
|
|
|
|
|
apache::thrift::TApplicationException x(e.what());
|
|
oprot->writeMessageBegin("Open", apache::thrift::protocol::T_EXCEPTION, seqid);
|
|
x.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
return;
|
|
}
|
|
|
|
this->preWrite(ctx.get(), "DB.Open");
|
|
oprot->writeMessageBegin("Open", apache::thrift::protocol::T_REPLY, seqid);
|
|
result.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
bytes = oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
|
|
this->postWrite(ctx.get(), "DB.Open", bytes);
|
|
|
|
}
|
|
|
|
void DBProcessor::process_Close(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, apache::thrift::server::TConnectionContext* connectionContext)
|
|
{
|
|
std::unique_ptr<apache::thrift::ContextStack> ctx(this->getContextStack("DB.Close", connectionContext));
|
|
|
|
this->preRead(ctx.get(), "DB.Close");
|
|
DB_Close_args args;
|
|
args.read(iprot);
|
|
iprot->readMessageEnd();
|
|
uint32_t bytes = iprot->getTransport()->readEnd();
|
|
|
|
this->postRead(ctx.get(), "DB.Close", bytes);
|
|
|
|
DB_Close_result result;
|
|
try {
|
|
result.success = iface_->Close(args.dbhandle, args.dbname);
|
|
result.__isset.success = true;
|
|
} catch (const std::exception& e) {
|
|
this->handlerError(ctx.get(), "DB.Close");
|
|
|
|
|
|
apache::thrift::TApplicationException x(e.what());
|
|
oprot->writeMessageBegin("Close", apache::thrift::protocol::T_EXCEPTION, seqid);
|
|
x.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
return;
|
|
}
|
|
|
|
this->preWrite(ctx.get(), "DB.Close");
|
|
oprot->writeMessageBegin("Close", apache::thrift::protocol::T_REPLY, seqid);
|
|
result.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
bytes = oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
|
|
this->postWrite(ctx.get(), "DB.Close", bytes);
|
|
|
|
}
|
|
|
|
void DBProcessor::process_Put(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, apache::thrift::server::TConnectionContext* connectionContext)
|
|
{
|
|
std::unique_ptr<apache::thrift::ContextStack> ctx(this->getContextStack("DB.Put", connectionContext));
|
|
|
|
this->preRead(ctx.get(), "DB.Put");
|
|
DB_Put_args args;
|
|
args.read(iprot);
|
|
iprot->readMessageEnd();
|
|
uint32_t bytes = iprot->getTransport()->readEnd();
|
|
|
|
this->postRead(ctx.get(), "DB.Put", bytes);
|
|
|
|
DB_Put_result result;
|
|
try {
|
|
result.success = iface_->Put(args.dbhandle, args.keyvalue, args.options);
|
|
result.__isset.success = true;
|
|
} catch (const std::exception& e) {
|
|
this->handlerError(ctx.get(), "DB.Put");
|
|
|
|
|
|
apache::thrift::TApplicationException x(e.what());
|
|
oprot->writeMessageBegin("Put", apache::thrift::protocol::T_EXCEPTION, seqid);
|
|
x.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
return;
|
|
}
|
|
|
|
this->preWrite(ctx.get(), "DB.Put");
|
|
oprot->writeMessageBegin("Put", apache::thrift::protocol::T_REPLY, seqid);
|
|
result.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
bytes = oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
|
|
this->postWrite(ctx.get(), "DB.Put", bytes);
|
|
|
|
}
|
|
|
|
void DBProcessor::process_Delete(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, apache::thrift::server::TConnectionContext* connectionContext)
|
|
{
|
|
std::unique_ptr<apache::thrift::ContextStack> ctx(this->getContextStack("DB.Delete", connectionContext));
|
|
|
|
this->preRead(ctx.get(), "DB.Delete");
|
|
DB_Delete_args args;
|
|
args.read(iprot);
|
|
iprot->readMessageEnd();
|
|
uint32_t bytes = iprot->getTransport()->readEnd();
|
|
|
|
this->postRead(ctx.get(), "DB.Delete", bytes);
|
|
|
|
DB_Delete_result result;
|
|
try {
|
|
result.success = iface_->Delete(args.dbhandle, args.key, args.options);
|
|
result.__isset.success = true;
|
|
} catch (const std::exception& e) {
|
|
this->handlerError(ctx.get(), "DB.Delete");
|
|
|
|
|
|
apache::thrift::TApplicationException x(e.what());
|
|
oprot->writeMessageBegin("Delete", apache::thrift::protocol::T_EXCEPTION, seqid);
|
|
x.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
return;
|
|
}
|
|
|
|
this->preWrite(ctx.get(), "DB.Delete");
|
|
oprot->writeMessageBegin("Delete", apache::thrift::protocol::T_REPLY, seqid);
|
|
result.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
bytes = oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
|
|
this->postWrite(ctx.get(), "DB.Delete", bytes);
|
|
|
|
}
|
|
|
|
void DBProcessor::process_Write(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, apache::thrift::server::TConnectionContext* connectionContext)
|
|
{
|
|
std::unique_ptr<apache::thrift::ContextStack> ctx(this->getContextStack("DB.Write", connectionContext));
|
|
|
|
this->preRead(ctx.get(), "DB.Write");
|
|
DB_Write_args args;
|
|
args.read(iprot);
|
|
iprot->readMessageEnd();
|
|
uint32_t bytes = iprot->getTransport()->readEnd();
|
|
|
|
this->postRead(ctx.get(), "DB.Write", bytes);
|
|
|
|
DB_Write_result result;
|
|
try {
|
|
result.success = iface_->Write(args.dbhandle, args.batch, args.options);
|
|
result.__isset.success = true;
|
|
} catch (const std::exception& e) {
|
|
this->handlerError(ctx.get(), "DB.Write");
|
|
|
|
|
|
apache::thrift::TApplicationException x(e.what());
|
|
oprot->writeMessageBegin("Write", apache::thrift::protocol::T_EXCEPTION, seqid);
|
|
x.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
return;
|
|
}
|
|
|
|
this->preWrite(ctx.get(), "DB.Write");
|
|
oprot->writeMessageBegin("Write", apache::thrift::protocol::T_REPLY, seqid);
|
|
result.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
bytes = oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
|
|
this->postWrite(ctx.get(), "DB.Write", bytes);
|
|
|
|
}
|
|
|
|
void DBProcessor::process_Get(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, apache::thrift::server::TConnectionContext* connectionContext)
|
|
{
|
|
std::unique_ptr<apache::thrift::ContextStack> ctx(this->getContextStack("DB.Get", connectionContext));
|
|
|
|
this->preRead(ctx.get(), "DB.Get");
|
|
DB_Get_args args;
|
|
args.read(iprot);
|
|
iprot->readMessageEnd();
|
|
uint32_t bytes = iprot->getTransport()->readEnd();
|
|
|
|
this->postRead(ctx.get(), "DB.Get", bytes);
|
|
|
|
DB_Get_result result;
|
|
try {
|
|
iface_->Get(result.success, args.dbhandle, args.inputkey, args.options);
|
|
result.__isset.success = true;
|
|
} catch (const std::exception& e) {
|
|
this->handlerError(ctx.get(), "DB.Get");
|
|
|
|
|
|
apache::thrift::TApplicationException x(e.what());
|
|
oprot->writeMessageBegin("Get", apache::thrift::protocol::T_EXCEPTION, seqid);
|
|
x.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
return;
|
|
}
|
|
|
|
this->preWrite(ctx.get(), "DB.Get");
|
|
oprot->writeMessageBegin("Get", apache::thrift::protocol::T_REPLY, seqid);
|
|
result.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
bytes = oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
|
|
this->postWrite(ctx.get(), "DB.Get", bytes);
|
|
|
|
}
|
|
|
|
void DBProcessor::process_NewIterator(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, apache::thrift::server::TConnectionContext* connectionContext)
|
|
{
|
|
std::unique_ptr<apache::thrift::ContextStack> ctx(this->getContextStack("DB.NewIterator", connectionContext));
|
|
|
|
this->preRead(ctx.get(), "DB.NewIterator");
|
|
DB_NewIterator_args args;
|
|
args.read(iprot);
|
|
iprot->readMessageEnd();
|
|
uint32_t bytes = iprot->getTransport()->readEnd();
|
|
|
|
this->postRead(ctx.get(), "DB.NewIterator", bytes);
|
|
|
|
DB_NewIterator_result result;
|
|
try {
|
|
iface_->NewIterator(result.success, args.dbhandle, args.options, args.iteratorType, args.target);
|
|
result.__isset.success = true;
|
|
} catch (const std::exception& e) {
|
|
this->handlerError(ctx.get(), "DB.NewIterator");
|
|
|
|
|
|
apache::thrift::TApplicationException x(e.what());
|
|
oprot->writeMessageBegin("NewIterator", apache::thrift::protocol::T_EXCEPTION, seqid);
|
|
x.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
return;
|
|
}
|
|
|
|
this->preWrite(ctx.get(), "DB.NewIterator");
|
|
oprot->writeMessageBegin("NewIterator", apache::thrift::protocol::T_REPLY, seqid);
|
|
result.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
bytes = oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
|
|
this->postWrite(ctx.get(), "DB.NewIterator", bytes);
|
|
|
|
}
|
|
|
|
void DBProcessor::process_DeleteIterator(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, apache::thrift::server::TConnectionContext* connectionContext)
|
|
{
|
|
std::unique_ptr<apache::thrift::ContextStack> ctx(this->getContextStack("DB.DeleteIterator", connectionContext));
|
|
|
|
this->preRead(ctx.get(), "DB.DeleteIterator");
|
|
DB_DeleteIterator_args args;
|
|
args.read(iprot);
|
|
iprot->readMessageEnd();
|
|
uint32_t bytes = iprot->getTransport()->readEnd();
|
|
|
|
this->postRead(ctx.get(), "DB.DeleteIterator", bytes);
|
|
|
|
DB_DeleteIterator_result result;
|
|
try {
|
|
result.success = iface_->DeleteIterator(args.dbhandle, args.iterator);
|
|
result.__isset.success = true;
|
|
} catch (const std::exception& e) {
|
|
this->handlerError(ctx.get(), "DB.DeleteIterator");
|
|
|
|
|
|
apache::thrift::TApplicationException x(e.what());
|
|
oprot->writeMessageBegin("DeleteIterator", apache::thrift::protocol::T_EXCEPTION, seqid);
|
|
x.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
return;
|
|
}
|
|
|
|
this->preWrite(ctx.get(), "DB.DeleteIterator");
|
|
oprot->writeMessageBegin("DeleteIterator", apache::thrift::protocol::T_REPLY, seqid);
|
|
result.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
bytes = oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
|
|
this->postWrite(ctx.get(), "DB.DeleteIterator", bytes);
|
|
|
|
}
|
|
|
|
void DBProcessor::process_GetNext(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, apache::thrift::server::TConnectionContext* connectionContext)
|
|
{
|
|
std::unique_ptr<apache::thrift::ContextStack> ctx(this->getContextStack("DB.GetNext", connectionContext));
|
|
|
|
this->preRead(ctx.get(), "DB.GetNext");
|
|
DB_GetNext_args args;
|
|
args.read(iprot);
|
|
iprot->readMessageEnd();
|
|
uint32_t bytes = iprot->getTransport()->readEnd();
|
|
|
|
this->postRead(ctx.get(), "DB.GetNext", bytes);
|
|
|
|
DB_GetNext_result result;
|
|
try {
|
|
iface_->GetNext(result.success, args.dbhandle, args.iterator);
|
|
result.__isset.success = true;
|
|
} catch (const std::exception& e) {
|
|
this->handlerError(ctx.get(), "DB.GetNext");
|
|
|
|
|
|
apache::thrift::TApplicationException x(e.what());
|
|
oprot->writeMessageBegin("GetNext", apache::thrift::protocol::T_EXCEPTION, seqid);
|
|
x.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
return;
|
|
}
|
|
|
|
this->preWrite(ctx.get(), "DB.GetNext");
|
|
oprot->writeMessageBegin("GetNext", apache::thrift::protocol::T_REPLY, seqid);
|
|
result.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
bytes = oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
|
|
this->postWrite(ctx.get(), "DB.GetNext", bytes);
|
|
|
|
}
|
|
|
|
void DBProcessor::process_GetPrev(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, apache::thrift::server::TConnectionContext* connectionContext)
|
|
{
|
|
std::unique_ptr<apache::thrift::ContextStack> ctx(this->getContextStack("DB.GetPrev", connectionContext));
|
|
|
|
this->preRead(ctx.get(), "DB.GetPrev");
|
|
DB_GetPrev_args args;
|
|
args.read(iprot);
|
|
iprot->readMessageEnd();
|
|
uint32_t bytes = iprot->getTransport()->readEnd();
|
|
|
|
this->postRead(ctx.get(), "DB.GetPrev", bytes);
|
|
|
|
DB_GetPrev_result result;
|
|
try {
|
|
iface_->GetPrev(result.success, args.dbhandle, args.iterator);
|
|
result.__isset.success = true;
|
|
} catch (const std::exception& e) {
|
|
this->handlerError(ctx.get(), "DB.GetPrev");
|
|
|
|
|
|
apache::thrift::TApplicationException x(e.what());
|
|
oprot->writeMessageBegin("GetPrev", apache::thrift::protocol::T_EXCEPTION, seqid);
|
|
x.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
return;
|
|
}
|
|
|
|
this->preWrite(ctx.get(), "DB.GetPrev");
|
|
oprot->writeMessageBegin("GetPrev", apache::thrift::protocol::T_REPLY, seqid);
|
|
result.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
bytes = oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
|
|
this->postWrite(ctx.get(), "DB.GetPrev", bytes);
|
|
|
|
}
|
|
|
|
void DBProcessor::process_GetSnapshot(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, apache::thrift::server::TConnectionContext* connectionContext)
|
|
{
|
|
std::unique_ptr<apache::thrift::ContextStack> ctx(this->getContextStack("DB.GetSnapshot", connectionContext));
|
|
|
|
this->preRead(ctx.get(), "DB.GetSnapshot");
|
|
DB_GetSnapshot_args args;
|
|
args.read(iprot);
|
|
iprot->readMessageEnd();
|
|
uint32_t bytes = iprot->getTransport()->readEnd();
|
|
|
|
this->postRead(ctx.get(), "DB.GetSnapshot", bytes);
|
|
|
|
DB_GetSnapshot_result result;
|
|
try {
|
|
iface_->GetSnapshot(result.success, args.dbhandle);
|
|
result.__isset.success = true;
|
|
} catch (const std::exception& e) {
|
|
this->handlerError(ctx.get(), "DB.GetSnapshot");
|
|
|
|
|
|
apache::thrift::TApplicationException x(e.what());
|
|
oprot->writeMessageBegin("GetSnapshot", apache::thrift::protocol::T_EXCEPTION, seqid);
|
|
x.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
return;
|
|
}
|
|
|
|
this->preWrite(ctx.get(), "DB.GetSnapshot");
|
|
oprot->writeMessageBegin("GetSnapshot", apache::thrift::protocol::T_REPLY, seqid);
|
|
result.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
bytes = oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
|
|
this->postWrite(ctx.get(), "DB.GetSnapshot", bytes);
|
|
|
|
}
|
|
|
|
void DBProcessor::process_ReleaseSnapshot(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, apache::thrift::server::TConnectionContext* connectionContext)
|
|
{
|
|
std::unique_ptr<apache::thrift::ContextStack> ctx(this->getContextStack("DB.ReleaseSnapshot", connectionContext));
|
|
|
|
this->preRead(ctx.get(), "DB.ReleaseSnapshot");
|
|
DB_ReleaseSnapshot_args args;
|
|
args.read(iprot);
|
|
iprot->readMessageEnd();
|
|
uint32_t bytes = iprot->getTransport()->readEnd();
|
|
|
|
this->postRead(ctx.get(), "DB.ReleaseSnapshot", bytes);
|
|
|
|
DB_ReleaseSnapshot_result result;
|
|
try {
|
|
result.success = iface_->ReleaseSnapshot(args.dbhandle, args.snapshot);
|
|
result.__isset.success = true;
|
|
} catch (const std::exception& e) {
|
|
this->handlerError(ctx.get(), "DB.ReleaseSnapshot");
|
|
|
|
|
|
apache::thrift::TApplicationException x(e.what());
|
|
oprot->writeMessageBegin("ReleaseSnapshot", apache::thrift::protocol::T_EXCEPTION, seqid);
|
|
x.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
return;
|
|
}
|
|
|
|
this->preWrite(ctx.get(), "DB.ReleaseSnapshot");
|
|
oprot->writeMessageBegin("ReleaseSnapshot", apache::thrift::protocol::T_REPLY, seqid);
|
|
result.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
bytes = oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
|
|
this->postWrite(ctx.get(), "DB.ReleaseSnapshot", bytes);
|
|
|
|
}
|
|
|
|
void DBProcessor::process_CompactRange(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, apache::thrift::server::TConnectionContext* connectionContext)
|
|
{
|
|
std::unique_ptr<apache::thrift::ContextStack> ctx(this->getContextStack("DB.CompactRange", connectionContext));
|
|
|
|
this->preRead(ctx.get(), "DB.CompactRange");
|
|
DB_CompactRange_args args;
|
|
args.read(iprot);
|
|
iprot->readMessageEnd();
|
|
uint32_t bytes = iprot->getTransport()->readEnd();
|
|
|
|
this->postRead(ctx.get(), "DB.CompactRange", bytes);
|
|
|
|
DB_CompactRange_result result;
|
|
try {
|
|
result.success = iface_->CompactRange(args.dbhandle, args.begin, args.end);
|
|
result.__isset.success = true;
|
|
} catch (const std::exception& e) {
|
|
this->handlerError(ctx.get(), "DB.CompactRange");
|
|
|
|
|
|
apache::thrift::TApplicationException x(e.what());
|
|
oprot->writeMessageBegin("CompactRange", apache::thrift::protocol::T_EXCEPTION, seqid);
|
|
x.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
return;
|
|
}
|
|
|
|
this->preWrite(ctx.get(), "DB.CompactRange");
|
|
oprot->writeMessageBegin("CompactRange", apache::thrift::protocol::T_REPLY, seqid);
|
|
result.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
bytes = oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
|
|
this->postWrite(ctx.get(), "DB.CompactRange", bytes);
|
|
|
|
}
|
|
|
|
::boost::shared_ptr< ::apache::thrift::TProcessor > DBProcessorFactory::getProcessor(::apache::thrift::server::TConnectionContext* ctx) {
|
|
::apache::thrift::ReleaseHandler< DBIfFactory > cleanup(handlerFactory_);
|
|
::boost::shared_ptr< DBIf > handler(handlerFactory_->getHandler(ctx), cleanup);
|
|
::boost::shared_ptr< ::apache::thrift::TProcessor > processor(new DBProcessor(handler));
|
|
return processor;
|
|
}
|
|
} // namespace
|
|
|