5721 lines
157 KiB
C++
5721 lines
157 KiB
C++
/**
|
|
* Autogenerated by Thrift Compiler (0.7.0)
|
|
*
|
|
* DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
|
|
*/
|
|
#include "Pos.h"
|
|
|
|
namespace pos {
|
|
|
|
uint32_t Pos_ping_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)
|
|
{
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_ping_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("Pos_ping_args");
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_ping_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("Pos_ping_pargs");
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_ping_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)
|
|
{
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_ping_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
|
|
uint32_t xfer = 0;
|
|
|
|
xfer += oprot->writeStructBegin("Pos_ping_result");
|
|
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_ping_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)
|
|
{
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_getSalt_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)
|
|
{
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_getSalt_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("Pos_getSalt_args");
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_getSalt_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("Pos_getSalt_pargs");
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_getSalt_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_STRING) {
|
|
xfer += iprot->readString(this->success);
|
|
this->__isset.success = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_getSalt_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
|
|
uint32_t xfer = 0;
|
|
|
|
xfer += oprot->writeStructBegin("Pos_getSalt_result");
|
|
|
|
if (this->__isset.success) {
|
|
xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRING, 0);
|
|
xfer += oprot->writeString(this->success);
|
|
xfer += oprot->writeFieldEnd();
|
|
}
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_getSalt_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_STRING) {
|
|
xfer += iprot->readString((*(this->success)));
|
|
this->__isset.success = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_getAccountFromHash_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->readString(this->dataToHash);
|
|
this->__isset.dataToHash = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_getAccountFromHash_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("Pos_getAccountFromHash_args");
|
|
xfer += oprot->writeFieldBegin("dataToHash", ::apache::thrift::protocol::T_STRING, 1);
|
|
xfer += oprot->writeString(this->dataToHash);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_getAccountFromHash_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("Pos_getAccountFromHash_pargs");
|
|
xfer += oprot->writeFieldBegin("dataToHash", ::apache::thrift::protocol::T_STRING, 1);
|
|
xfer += oprot->writeString((*(this->dataToHash)));
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_getAccountFromHash_result::read(::apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using ::apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == ::apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == ::apache::thrift::protocol::T_I32) {
|
|
xfer += iprot->readI32(this->success);
|
|
this->__isset.success = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_getAccountFromHash_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
|
|
uint32_t xfer = 0;
|
|
|
|
xfer += oprot->writeStructBegin("Pos_getAccountFromHash_result");
|
|
|
|
if (this->__isset.success) {
|
|
xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I32, 0);
|
|
xfer += oprot->writeI32(this->success);
|
|
xfer += oprot->writeFieldEnd();
|
|
}
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_getAccountFromHash_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using ::apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == ::apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == ::apache::thrift::protocol::T_I32) {
|
|
xfer += iprot->readI32((*(this->success)));
|
|
this->__isset.success = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_getHashesFromAccountId_args::read(::apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using ::apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == ::apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 1:
|
|
if (ftype == ::apache::thrift::protocol::T_I32) {
|
|
xfer += iprot->readI32(this->account);
|
|
this->__isset.account = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_getHashesFromAccountId_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("Pos_getHashesFromAccountId_args");
|
|
xfer += oprot->writeFieldBegin("account", ::apache::thrift::protocol::T_I32, 1);
|
|
xfer += oprot->writeI32(this->account);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_getHashesFromAccountId_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("Pos_getHashesFromAccountId_pargs");
|
|
xfer += oprot->writeFieldBegin("account", ::apache::thrift::protocol::T_I32, 1);
|
|
xfer += oprot->writeI32((*(this->account)));
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_getHashesFromAccountId_result::read(::apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using ::apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == ::apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == ::apache::thrift::protocol::T_LIST) {
|
|
{
|
|
this->success.clear();
|
|
uint32_t _size0;
|
|
::apache::thrift::protocol::TType _etype3;
|
|
iprot->readListBegin(_etype3, _size0);
|
|
this->success.resize(_size0);
|
|
uint32_t _i4;
|
|
for (_i4 = 0; _i4 < _size0; ++_i4)
|
|
{
|
|
xfer += iprot->readString(this->success[_i4]);
|
|
}
|
|
iprot->readListEnd();
|
|
}
|
|
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 Pos_getHashesFromAccountId_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
|
|
uint32_t xfer = 0;
|
|
|
|
xfer += oprot->writeStructBegin("Pos_getHashesFromAccountId_result");
|
|
|
|
if (this->__isset.success) {
|
|
xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
|
|
{
|
|
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size()));
|
|
std::vector<std::string> ::const_iterator _iter5;
|
|
for (_iter5 = this->success.begin(); _iter5 != this->success.end(); ++_iter5)
|
|
{
|
|
xfer += oprot->writeString((*_iter5));
|
|
}
|
|
xfer += oprot->writeListEnd();
|
|
}
|
|
xfer += oprot->writeFieldEnd();
|
|
}
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_getHashesFromAccountId_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using ::apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == ::apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == ::apache::thrift::protocol::T_LIST) {
|
|
{
|
|
(*(this->success)).clear();
|
|
uint32_t _size6;
|
|
::apache::thrift::protocol::TType _etype9;
|
|
iprot->readListBegin(_etype9, _size6);
|
|
(*(this->success)).resize(_size6);
|
|
uint32_t _i10;
|
|
for (_i10 = 0; _i10 < _size6; ++_i10)
|
|
{
|
|
xfer += iprot->readString((*(this->success))[_i10]);
|
|
}
|
|
iprot->readListEnd();
|
|
}
|
|
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 Pos_getHashesFromAccountName_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->readString(this->account);
|
|
this->__isset.account = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_getHashesFromAccountName_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("Pos_getHashesFromAccountName_args");
|
|
xfer += oprot->writeFieldBegin("account", ::apache::thrift::protocol::T_STRING, 1);
|
|
xfer += oprot->writeString(this->account);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_getHashesFromAccountName_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("Pos_getHashesFromAccountName_pargs");
|
|
xfer += oprot->writeFieldBegin("account", ::apache::thrift::protocol::T_STRING, 1);
|
|
xfer += oprot->writeString((*(this->account)));
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_getHashesFromAccountName_result::read(::apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using ::apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == ::apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == ::apache::thrift::protocol::T_LIST) {
|
|
{
|
|
this->success.clear();
|
|
uint32_t _size11;
|
|
::apache::thrift::protocol::TType _etype14;
|
|
iprot->readListBegin(_etype14, _size11);
|
|
this->success.resize(_size11);
|
|
uint32_t _i15;
|
|
for (_i15 = 0; _i15 < _size11; ++_i15)
|
|
{
|
|
xfer += iprot->readString(this->success[_i15]);
|
|
}
|
|
iprot->readListEnd();
|
|
}
|
|
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 Pos_getHashesFromAccountName_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
|
|
uint32_t xfer = 0;
|
|
|
|
xfer += oprot->writeStructBegin("Pos_getHashesFromAccountName_result");
|
|
|
|
if (this->__isset.success) {
|
|
xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
|
|
{
|
|
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size()));
|
|
std::vector<std::string> ::const_iterator _iter16;
|
|
for (_iter16 = this->success.begin(); _iter16 != this->success.end(); ++_iter16)
|
|
{
|
|
xfer += oprot->writeString((*_iter16));
|
|
}
|
|
xfer += oprot->writeListEnd();
|
|
}
|
|
xfer += oprot->writeFieldEnd();
|
|
}
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_getHashesFromAccountName_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using ::apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == ::apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == ::apache::thrift::protocol::T_LIST) {
|
|
{
|
|
(*(this->success)).clear();
|
|
uint32_t _size17;
|
|
::apache::thrift::protocol::TType _etype20;
|
|
iprot->readListBegin(_etype20, _size17);
|
|
(*(this->success)).resize(_size17);
|
|
uint32_t _i21;
|
|
for (_i21 = 0; _i21 < _size17; ++_i21)
|
|
{
|
|
xfer += iprot->readString((*(this->success))[_i21]);
|
|
}
|
|
iprot->readListEnd();
|
|
}
|
|
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 Pos_getHashAccountBalance_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->readString(this->dataToHash);
|
|
this->__isset.dataToHash = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_getHashAccountBalance_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("Pos_getHashAccountBalance_args");
|
|
xfer += oprot->writeFieldBegin("dataToHash", ::apache::thrift::protocol::T_STRING, 1);
|
|
xfer += oprot->writeString(this->dataToHash);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_getHashAccountBalance_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("Pos_getHashAccountBalance_pargs");
|
|
xfer += oprot->writeFieldBegin("dataToHash", ::apache::thrift::protocol::T_STRING, 1);
|
|
xfer += oprot->writeString((*(this->dataToHash)));
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_getHashAccountBalance_result::read(::apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using ::apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == ::apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == ::apache::thrift::protocol::T_I32) {
|
|
xfer += iprot->readI32(this->success);
|
|
this->__isset.success = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_getHashAccountBalance_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
|
|
uint32_t xfer = 0;
|
|
|
|
xfer += oprot->writeStructBegin("Pos_getHashAccountBalance_result");
|
|
|
|
if (this->__isset.success) {
|
|
xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I32, 0);
|
|
xfer += oprot->writeI32(this->success);
|
|
xfer += oprot->writeFieldEnd();
|
|
}
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_getHashAccountBalance_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using ::apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == ::apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == ::apache::thrift::protocol::T_I32) {
|
|
xfer += iprot->readI32((*(this->success)));
|
|
this->__isset.success = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_getIdAccountBalance_args::read(::apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using ::apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == ::apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 1:
|
|
if (ftype == ::apache::thrift::protocol::T_I32) {
|
|
xfer += iprot->readI32(this->account);
|
|
this->__isset.account = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_getIdAccountBalance_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("Pos_getIdAccountBalance_args");
|
|
xfer += oprot->writeFieldBegin("account", ::apache::thrift::protocol::T_I32, 1);
|
|
xfer += oprot->writeI32(this->account);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_getIdAccountBalance_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("Pos_getIdAccountBalance_pargs");
|
|
xfer += oprot->writeFieldBegin("account", ::apache::thrift::protocol::T_I32, 1);
|
|
xfer += oprot->writeI32((*(this->account)));
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_getIdAccountBalance_result::read(::apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using ::apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == ::apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == ::apache::thrift::protocol::T_I32) {
|
|
xfer += iprot->readI32(this->success);
|
|
this->__isset.success = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_getIdAccountBalance_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
|
|
uint32_t xfer = 0;
|
|
|
|
xfer += oprot->writeStructBegin("Pos_getIdAccountBalance_result");
|
|
|
|
if (this->__isset.success) {
|
|
xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I32, 0);
|
|
xfer += oprot->writeI32(this->success);
|
|
xfer += oprot->writeFieldEnd();
|
|
}
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_getIdAccountBalance_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using ::apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == ::apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == ::apache::thrift::protocol::T_I32) {
|
|
xfer += iprot->readI32((*(this->success)));
|
|
this->__isset.success = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_getNameAccountBalance_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->readString(this->account);
|
|
this->__isset.account = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_getNameAccountBalance_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("Pos_getNameAccountBalance_args");
|
|
xfer += oprot->writeFieldBegin("account", ::apache::thrift::protocol::T_STRING, 1);
|
|
xfer += oprot->writeString(this->account);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_getNameAccountBalance_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("Pos_getNameAccountBalance_pargs");
|
|
xfer += oprot->writeFieldBegin("account", ::apache::thrift::protocol::T_STRING, 1);
|
|
xfer += oprot->writeString((*(this->account)));
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_getNameAccountBalance_result::read(::apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using ::apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == ::apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == ::apache::thrift::protocol::T_I32) {
|
|
xfer += iprot->readI32(this->success);
|
|
this->__isset.success = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_getNameAccountBalance_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
|
|
uint32_t xfer = 0;
|
|
|
|
xfer += oprot->writeStructBegin("Pos_getNameAccountBalance_result");
|
|
|
|
if (this->__isset.success) {
|
|
xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I32, 0);
|
|
xfer += oprot->writeI32(this->success);
|
|
xfer += oprot->writeFieldEnd();
|
|
}
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_getNameAccountBalance_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using ::apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == ::apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == ::apache::thrift::protocol::T_I32) {
|
|
xfer += iprot->readI32((*(this->success)));
|
|
this->__isset.success = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_associateHashWithId_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->readString(this->auth);
|
|
this->__isset.auth = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
case 2:
|
|
if (ftype == ::apache::thrift::protocol::T_STRING) {
|
|
xfer += iprot->readString(this->dataToHash);
|
|
this->__isset.dataToHash = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
case 3:
|
|
if (ftype == ::apache::thrift::protocol::T_I32) {
|
|
xfer += iprot->readI32(this->account);
|
|
this->__isset.account = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_associateHashWithId_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("Pos_associateHashWithId_args");
|
|
xfer += oprot->writeFieldBegin("auth", ::apache::thrift::protocol::T_STRING, 1);
|
|
xfer += oprot->writeString(this->auth);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("dataToHash", ::apache::thrift::protocol::T_STRING, 2);
|
|
xfer += oprot->writeString(this->dataToHash);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("account", ::apache::thrift::protocol::T_I32, 3);
|
|
xfer += oprot->writeI32(this->account);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_associateHashWithId_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("Pos_associateHashWithId_pargs");
|
|
xfer += oprot->writeFieldBegin("auth", ::apache::thrift::protocol::T_STRING, 1);
|
|
xfer += oprot->writeString((*(this->auth)));
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("dataToHash", ::apache::thrift::protocol::T_STRING, 2);
|
|
xfer += oprot->writeString((*(this->dataToHash)));
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("account", ::apache::thrift::protocol::T_I32, 3);
|
|
xfer += oprot->writeI32((*(this->account)));
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_associateHashWithId_result::read(::apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using ::apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == ::apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == ::apache::thrift::protocol::T_I64) {
|
|
xfer += iprot->readI64(this->success);
|
|
this->__isset.success = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_associateHashWithId_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
|
|
uint32_t xfer = 0;
|
|
|
|
xfer += oprot->writeStructBegin("Pos_associateHashWithId_result");
|
|
|
|
if (this->__isset.success) {
|
|
xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I64, 0);
|
|
xfer += oprot->writeI64(this->success);
|
|
xfer += oprot->writeFieldEnd();
|
|
}
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_associateHashWithId_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using ::apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == ::apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == ::apache::thrift::protocol::T_I64) {
|
|
xfer += iprot->readI64((*(this->success)));
|
|
this->__isset.success = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_associateHashWithName_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->readString(this->auth);
|
|
this->__isset.auth = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
case 2:
|
|
if (ftype == ::apache::thrift::protocol::T_STRING) {
|
|
xfer += iprot->readString(this->dataToHash);
|
|
this->__isset.dataToHash = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
case 3:
|
|
if (ftype == ::apache::thrift::protocol::T_STRING) {
|
|
xfer += iprot->readString(this->account);
|
|
this->__isset.account = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_associateHashWithName_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("Pos_associateHashWithName_args");
|
|
xfer += oprot->writeFieldBegin("auth", ::apache::thrift::protocol::T_STRING, 1);
|
|
xfer += oprot->writeString(this->auth);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("dataToHash", ::apache::thrift::protocol::T_STRING, 2);
|
|
xfer += oprot->writeString(this->dataToHash);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("account", ::apache::thrift::protocol::T_STRING, 3);
|
|
xfer += oprot->writeString(this->account);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_associateHashWithName_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("Pos_associateHashWithName_pargs");
|
|
xfer += oprot->writeFieldBegin("auth", ::apache::thrift::protocol::T_STRING, 1);
|
|
xfer += oprot->writeString((*(this->auth)));
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("dataToHash", ::apache::thrift::protocol::T_STRING, 2);
|
|
xfer += oprot->writeString((*(this->dataToHash)));
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("account", ::apache::thrift::protocol::T_STRING, 3);
|
|
xfer += oprot->writeString((*(this->account)));
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_associateHashWithName_result::read(::apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using ::apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == ::apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == ::apache::thrift::protocol::T_I64) {
|
|
xfer += iprot->readI64(this->success);
|
|
this->__isset.success = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_associateHashWithName_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
|
|
uint32_t xfer = 0;
|
|
|
|
xfer += oprot->writeStructBegin("Pos_associateHashWithName_result");
|
|
|
|
if (this->__isset.success) {
|
|
xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I64, 0);
|
|
xfer += oprot->writeI64(this->success);
|
|
xfer += oprot->writeFieldEnd();
|
|
}
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_associateHashWithName_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using ::apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == ::apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == ::apache::thrift::protocol::T_I64) {
|
|
xfer += iprot->readI64((*(this->success)));
|
|
this->__isset.success = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_deassociateHash_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->readString(this->auth);
|
|
this->__isset.auth = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
case 2:
|
|
if (ftype == ::apache::thrift::protocol::T_STRING) {
|
|
xfer += iprot->readString(this->dataToHash);
|
|
this->__isset.dataToHash = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_deassociateHash_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("Pos_deassociateHash_args");
|
|
xfer += oprot->writeFieldBegin("auth", ::apache::thrift::protocol::T_STRING, 1);
|
|
xfer += oprot->writeString(this->auth);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("dataToHash", ::apache::thrift::protocol::T_STRING, 2);
|
|
xfer += oprot->writeString(this->dataToHash);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_deassociateHash_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("Pos_deassociateHash_pargs");
|
|
xfer += oprot->writeFieldBegin("auth", ::apache::thrift::protocol::T_STRING, 1);
|
|
xfer += oprot->writeString((*(this->auth)));
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("dataToHash", ::apache::thrift::protocol::T_STRING, 2);
|
|
xfer += oprot->writeString((*(this->dataToHash)));
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_deassociateHash_result::read(::apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using ::apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == ::apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == ::apache::thrift::protocol::T_I64) {
|
|
xfer += iprot->readI64(this->success);
|
|
this->__isset.success = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_deassociateHash_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
|
|
uint32_t xfer = 0;
|
|
|
|
xfer += oprot->writeStructBegin("Pos_deassociateHash_result");
|
|
|
|
if (this->__isset.success) {
|
|
xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I64, 0);
|
|
xfer += oprot->writeI64(this->success);
|
|
xfer += oprot->writeFieldEnd();
|
|
}
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_deassociateHash_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using ::apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == ::apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == ::apache::thrift::protocol::T_I64) {
|
|
xfer += iprot->readI64((*(this->success)));
|
|
this->__isset.success = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_getUPCPrice_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_I64) {
|
|
xfer += iprot->readI64(this->upc);
|
|
this->__isset.upc = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_getUPCPrice_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("Pos_getUPCPrice_args");
|
|
xfer += oprot->writeFieldBegin("upc", ::apache::thrift::protocol::T_I64, 1);
|
|
xfer += oprot->writeI64(this->upc);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_getUPCPrice_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("Pos_getUPCPrice_pargs");
|
|
xfer += oprot->writeFieldBegin("upc", ::apache::thrift::protocol::T_I64, 1);
|
|
xfer += oprot->writeI64((*(this->upc)));
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_getUPCPrice_result::read(::apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using ::apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == ::apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == ::apache::thrift::protocol::T_I32) {
|
|
xfer += iprot->readI32(this->success);
|
|
this->__isset.success = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_getUPCPrice_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
|
|
uint32_t xfer = 0;
|
|
|
|
xfer += oprot->writeStructBegin("Pos_getUPCPrice_result");
|
|
|
|
if (this->__isset.success) {
|
|
xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I32, 0);
|
|
xfer += oprot->writeI32(this->success);
|
|
xfer += oprot->writeFieldEnd();
|
|
}
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_getUPCPrice_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using ::apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == ::apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == ::apache::thrift::protocol::T_I32) {
|
|
xfer += iprot->readI32((*(this->success)));
|
|
this->__isset.success = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_setUPCPrice_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->readString(this->auth);
|
|
this->__isset.auth = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
case 2:
|
|
if (ftype == ::apache::thrift::protocol::T_I64) {
|
|
xfer += iprot->readI64(this->upc);
|
|
this->__isset.upc = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
case 3:
|
|
if (ftype == ::apache::thrift::protocol::T_I32) {
|
|
xfer += iprot->readI32(this->price);
|
|
this->__isset.price = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_setUPCPrice_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("Pos_setUPCPrice_args");
|
|
xfer += oprot->writeFieldBegin("auth", ::apache::thrift::protocol::T_STRING, 1);
|
|
xfer += oprot->writeString(this->auth);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("upc", ::apache::thrift::protocol::T_I64, 2);
|
|
xfer += oprot->writeI64(this->upc);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("price", ::apache::thrift::protocol::T_I32, 3);
|
|
xfer += oprot->writeI32(this->price);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_setUPCPrice_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("Pos_setUPCPrice_pargs");
|
|
xfer += oprot->writeFieldBegin("auth", ::apache::thrift::protocol::T_STRING, 1);
|
|
xfer += oprot->writeString((*(this->auth)));
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("upc", ::apache::thrift::protocol::T_I64, 2);
|
|
xfer += oprot->writeI64((*(this->upc)));
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("price", ::apache::thrift::protocol::T_I32, 3);
|
|
xfer += oprot->writeI32((*(this->price)));
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_setUPCPrice_result::read(::apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using ::apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == ::apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == ::apache::thrift::protocol::T_I64) {
|
|
xfer += iprot->readI64(this->success);
|
|
this->__isset.success = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_setUPCPrice_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
|
|
uint32_t xfer = 0;
|
|
|
|
xfer += oprot->writeStructBegin("Pos_setUPCPrice_result");
|
|
|
|
if (this->__isset.success) {
|
|
xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I64, 0);
|
|
xfer += oprot->writeI64(this->success);
|
|
xfer += oprot->writeFieldEnd();
|
|
}
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_setUPCPrice_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using ::apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == ::apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == ::apache::thrift::protocol::T_I64) {
|
|
xfer += iprot->readI64((*(this->success)));
|
|
this->__isset.success = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_doTransactionOnHash_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->readString(this->auth);
|
|
this->__isset.auth = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
case 2:
|
|
if (ftype == ::apache::thrift::protocol::T_STRING) {
|
|
xfer += iprot->readString(this->dataToHash);
|
|
this->__isset.dataToHash = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
case 3:
|
|
if (ftype == ::apache::thrift::protocol::T_I32) {
|
|
xfer += iprot->readI32(this->delta);
|
|
this->__isset.delta = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_doTransactionOnHash_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("Pos_doTransactionOnHash_args");
|
|
xfer += oprot->writeFieldBegin("auth", ::apache::thrift::protocol::T_STRING, 1);
|
|
xfer += oprot->writeString(this->auth);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("dataToHash", ::apache::thrift::protocol::T_STRING, 2);
|
|
xfer += oprot->writeString(this->dataToHash);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("delta", ::apache::thrift::protocol::T_I32, 3);
|
|
xfer += oprot->writeI32(this->delta);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_doTransactionOnHash_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("Pos_doTransactionOnHash_pargs");
|
|
xfer += oprot->writeFieldBegin("auth", ::apache::thrift::protocol::T_STRING, 1);
|
|
xfer += oprot->writeString((*(this->auth)));
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("dataToHash", ::apache::thrift::protocol::T_STRING, 2);
|
|
xfer += oprot->writeString((*(this->dataToHash)));
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("delta", ::apache::thrift::protocol::T_I32, 3);
|
|
xfer += oprot->writeI32((*(this->delta)));
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_doTransactionOnHash_result::read(::apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using ::apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == ::apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == ::apache::thrift::protocol::T_I64) {
|
|
xfer += iprot->readI64(this->success);
|
|
this->__isset.success = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_doTransactionOnHash_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
|
|
uint32_t xfer = 0;
|
|
|
|
xfer += oprot->writeStructBegin("Pos_doTransactionOnHash_result");
|
|
|
|
if (this->__isset.success) {
|
|
xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I64, 0);
|
|
xfer += oprot->writeI64(this->success);
|
|
xfer += oprot->writeFieldEnd();
|
|
}
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_doTransactionOnHash_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using ::apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == ::apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == ::apache::thrift::protocol::T_I64) {
|
|
xfer += iprot->readI64((*(this->success)));
|
|
this->__isset.success = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_doTransactionOnId_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->readString(this->auth);
|
|
this->__isset.auth = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
case 2:
|
|
if (ftype == ::apache::thrift::protocol::T_I32) {
|
|
xfer += iprot->readI32(this->account);
|
|
this->__isset.account = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
case 3:
|
|
if (ftype == ::apache::thrift::protocol::T_I32) {
|
|
xfer += iprot->readI32(this->delta);
|
|
this->__isset.delta = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_doTransactionOnId_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("Pos_doTransactionOnId_args");
|
|
xfer += oprot->writeFieldBegin("auth", ::apache::thrift::protocol::T_STRING, 1);
|
|
xfer += oprot->writeString(this->auth);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("account", ::apache::thrift::protocol::T_I32, 2);
|
|
xfer += oprot->writeI32(this->account);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("delta", ::apache::thrift::protocol::T_I32, 3);
|
|
xfer += oprot->writeI32(this->delta);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_doTransactionOnId_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("Pos_doTransactionOnId_pargs");
|
|
xfer += oprot->writeFieldBegin("auth", ::apache::thrift::protocol::T_STRING, 1);
|
|
xfer += oprot->writeString((*(this->auth)));
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("account", ::apache::thrift::protocol::T_I32, 2);
|
|
xfer += oprot->writeI32((*(this->account)));
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("delta", ::apache::thrift::protocol::T_I32, 3);
|
|
xfer += oprot->writeI32((*(this->delta)));
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_doTransactionOnId_result::read(::apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using ::apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == ::apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == ::apache::thrift::protocol::T_I64) {
|
|
xfer += iprot->readI64(this->success);
|
|
this->__isset.success = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_doTransactionOnId_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
|
|
uint32_t xfer = 0;
|
|
|
|
xfer += oprot->writeStructBegin("Pos_doTransactionOnId_result");
|
|
|
|
if (this->__isset.success) {
|
|
xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I64, 0);
|
|
xfer += oprot->writeI64(this->success);
|
|
xfer += oprot->writeFieldEnd();
|
|
}
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_doTransactionOnId_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using ::apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == ::apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == ::apache::thrift::protocol::T_I64) {
|
|
xfer += iprot->readI64((*(this->success)));
|
|
this->__isset.success = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_doTransactionOnName_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->readString(this->auth);
|
|
this->__isset.auth = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
case 2:
|
|
if (ftype == ::apache::thrift::protocol::T_STRING) {
|
|
xfer += iprot->readString(this->account);
|
|
this->__isset.account = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
case 3:
|
|
if (ftype == ::apache::thrift::protocol::T_I32) {
|
|
xfer += iprot->readI32(this->delta);
|
|
this->__isset.delta = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_doTransactionOnName_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("Pos_doTransactionOnName_args");
|
|
xfer += oprot->writeFieldBegin("auth", ::apache::thrift::protocol::T_STRING, 1);
|
|
xfer += oprot->writeString(this->auth);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("account", ::apache::thrift::protocol::T_STRING, 2);
|
|
xfer += oprot->writeString(this->account);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("delta", ::apache::thrift::protocol::T_I32, 3);
|
|
xfer += oprot->writeI32(this->delta);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_doTransactionOnName_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("Pos_doTransactionOnName_pargs");
|
|
xfer += oprot->writeFieldBegin("auth", ::apache::thrift::protocol::T_STRING, 1);
|
|
xfer += oprot->writeString((*(this->auth)));
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("account", ::apache::thrift::protocol::T_STRING, 2);
|
|
xfer += oprot->writeString((*(this->account)));
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("delta", ::apache::thrift::protocol::T_I32, 3);
|
|
xfer += oprot->writeI32((*(this->delta)));
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_doTransactionOnName_result::read(::apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using ::apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == ::apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == ::apache::thrift::protocol::T_I64) {
|
|
xfer += iprot->readI64(this->success);
|
|
this->__isset.success = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_doTransactionOnName_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
|
|
uint32_t xfer = 0;
|
|
|
|
xfer += oprot->writeStructBegin("Pos_doTransactionOnName_result");
|
|
|
|
if (this->__isset.success) {
|
|
xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I64, 0);
|
|
xfer += oprot->writeI64(this->success);
|
|
xfer += oprot->writeFieldEnd();
|
|
}
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_doTransactionOnName_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using ::apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == ::apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == ::apache::thrift::protocol::T_I64) {
|
|
xfer += iprot->readI64((*(this->success)));
|
|
this->__isset.success = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_revertTransaction_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->readString(this->auth);
|
|
this->__isset.auth = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
case 2:
|
|
if (ftype == ::apache::thrift::protocol::T_I64) {
|
|
xfer += iprot->readI64(this->serial);
|
|
this->__isset.serial = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_revertTransaction_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("Pos_revertTransaction_args");
|
|
xfer += oprot->writeFieldBegin("auth", ::apache::thrift::protocol::T_STRING, 1);
|
|
xfer += oprot->writeString(this->auth);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("serial", ::apache::thrift::protocol::T_I64, 2);
|
|
xfer += oprot->writeI64(this->serial);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_revertTransaction_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("Pos_revertTransaction_pargs");
|
|
xfer += oprot->writeFieldBegin("auth", ::apache::thrift::protocol::T_STRING, 1);
|
|
xfer += oprot->writeString((*(this->auth)));
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("serial", ::apache::thrift::protocol::T_I64, 2);
|
|
xfer += oprot->writeI64((*(this->serial)));
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_revertTransaction_result::read(::apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using ::apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == ::apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == ::apache::thrift::protocol::T_I64) {
|
|
xfer += iprot->readI64(this->success);
|
|
this->__isset.success = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_revertTransaction_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
|
|
uint32_t xfer = 0;
|
|
|
|
xfer += oprot->writeStructBegin("Pos_revertTransaction_result");
|
|
|
|
if (this->__isset.success) {
|
|
xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I64, 0);
|
|
xfer += oprot->writeI64(this->success);
|
|
xfer += oprot->writeFieldEnd();
|
|
}
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_revertTransaction_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using ::apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == ::apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == ::apache::thrift::protocol::T_I64) {
|
|
xfer += iprot->readI64((*(this->success)));
|
|
this->__isset.success = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_getStock_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_I64) {
|
|
xfer += iprot->readI64(this->upc);
|
|
this->__isset.upc = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_getStock_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("Pos_getStock_args");
|
|
xfer += oprot->writeFieldBegin("upc", ::apache::thrift::protocol::T_I64, 1);
|
|
xfer += oprot->writeI64(this->upc);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_getStock_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("Pos_getStock_pargs");
|
|
xfer += oprot->writeFieldBegin("upc", ::apache::thrift::protocol::T_I64, 1);
|
|
xfer += oprot->writeI64((*(this->upc)));
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_getStock_result::read(::apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using ::apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == ::apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == ::apache::thrift::protocol::T_I32) {
|
|
xfer += iprot->readI32(this->success);
|
|
this->__isset.success = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_getStock_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
|
|
uint32_t xfer = 0;
|
|
|
|
xfer += oprot->writeStructBegin("Pos_getStock_result");
|
|
|
|
if (this->__isset.success) {
|
|
xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I32, 0);
|
|
xfer += oprot->writeI32(this->success);
|
|
xfer += oprot->writeFieldEnd();
|
|
}
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_getStock_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using ::apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == ::apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == ::apache::thrift::protocol::T_I32) {
|
|
xfer += iprot->readI32((*(this->success)));
|
|
this->__isset.success = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_doStockChange_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->readString(this->auth);
|
|
this->__isset.auth = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
case 2:
|
|
if (ftype == ::apache::thrift::protocol::T_I64) {
|
|
xfer += iprot->readI64(this->upc);
|
|
this->__isset.upc = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
case 3:
|
|
if (ftype == ::apache::thrift::protocol::T_I32) {
|
|
xfer += iprot->readI32(this->delta);
|
|
this->__isset.delta = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_doStockChange_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("Pos_doStockChange_args");
|
|
xfer += oprot->writeFieldBegin("auth", ::apache::thrift::protocol::T_STRING, 1);
|
|
xfer += oprot->writeString(this->auth);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("upc", ::apache::thrift::protocol::T_I64, 2);
|
|
xfer += oprot->writeI64(this->upc);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("delta", ::apache::thrift::protocol::T_I32, 4);
|
|
xfer += oprot->writeI32(this->delta);
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_doStockChange_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("Pos_doStockChange_pargs");
|
|
xfer += oprot->writeFieldBegin("auth", ::apache::thrift::protocol::T_STRING, 1);
|
|
xfer += oprot->writeString((*(this->auth)));
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("upc", ::apache::thrift::protocol::T_I64, 2);
|
|
xfer += oprot->writeI64((*(this->upc)));
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldBegin("delta", ::apache::thrift::protocol::T_I32, 4);
|
|
xfer += oprot->writeI32((*(this->delta)));
|
|
xfer += oprot->writeFieldEnd();
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_doStockChange_result::read(::apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using ::apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == ::apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == ::apache::thrift::protocol::T_I64) {
|
|
xfer += iprot->readI64(this->success);
|
|
this->__isset.success = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_doStockChange_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
|
|
uint32_t xfer = 0;
|
|
|
|
xfer += oprot->writeStructBegin("Pos_doStockChange_result");
|
|
|
|
if (this->__isset.success) {
|
|
xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I64, 0);
|
|
xfer += oprot->writeI64(this->success);
|
|
xfer += oprot->writeFieldEnd();
|
|
}
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_doStockChange_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using ::apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == ::apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == ::apache::thrift::protocol::T_I64) {
|
|
xfer += iprot->readI64((*(this->success)));
|
|
this->__isset.success = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_toString_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)
|
|
{
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_toString_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("Pos_toString_args");
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_toString_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
uint32_t xfer = 0;
|
|
xfer += oprot->writeStructBegin("Pos_toString_pargs");
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_toString_result::read(::apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using ::apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == ::apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == ::apache::thrift::protocol::T_LIST) {
|
|
{
|
|
this->success.clear();
|
|
uint32_t _size22;
|
|
::apache::thrift::protocol::TType _etype25;
|
|
iprot->readListBegin(_etype25, _size22);
|
|
this->success.resize(_size22);
|
|
uint32_t _i26;
|
|
for (_i26 = 0; _i26 < _size22; ++_i26)
|
|
{
|
|
xfer += iprot->readString(this->success[_i26]);
|
|
}
|
|
iprot->readListEnd();
|
|
}
|
|
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 Pos_toString_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
|
|
|
|
uint32_t xfer = 0;
|
|
|
|
xfer += oprot->writeStructBegin("Pos_toString_result");
|
|
|
|
if (this->__isset.success) {
|
|
xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
|
|
{
|
|
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size()));
|
|
std::vector<std::string> ::const_iterator _iter27;
|
|
for (_iter27 = this->success.begin(); _iter27 != this->success.end(); ++_iter27)
|
|
{
|
|
xfer += oprot->writeString((*_iter27));
|
|
}
|
|
xfer += oprot->writeListEnd();
|
|
}
|
|
xfer += oprot->writeFieldEnd();
|
|
}
|
|
xfer += oprot->writeFieldStop();
|
|
xfer += oprot->writeStructEnd();
|
|
return xfer;
|
|
}
|
|
|
|
uint32_t Pos_toString_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
|
|
|
|
uint32_t xfer = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TType ftype;
|
|
int16_t fid;
|
|
|
|
xfer += iprot->readStructBegin(fname);
|
|
|
|
using ::apache::thrift::protocol::TProtocolException;
|
|
|
|
|
|
while (true)
|
|
{
|
|
xfer += iprot->readFieldBegin(fname, ftype, fid);
|
|
if (ftype == ::apache::thrift::protocol::T_STOP) {
|
|
break;
|
|
}
|
|
switch (fid)
|
|
{
|
|
case 0:
|
|
if (ftype == ::apache::thrift::protocol::T_LIST) {
|
|
{
|
|
(*(this->success)).clear();
|
|
uint32_t _size28;
|
|
::apache::thrift::protocol::TType _etype31;
|
|
iprot->readListBegin(_etype31, _size28);
|
|
(*(this->success)).resize(_size28);
|
|
uint32_t _i32;
|
|
for (_i32 = 0; _i32 < _size28; ++_i32)
|
|
{
|
|
xfer += iprot->readString((*(this->success))[_i32]);
|
|
}
|
|
iprot->readListEnd();
|
|
}
|
|
this->__isset.success = true;
|
|
} else {
|
|
xfer += iprot->skip(ftype);
|
|
}
|
|
break;
|
|
default:
|
|
xfer += iprot->skip(ftype);
|
|
break;
|
|
}
|
|
xfer += iprot->readFieldEnd();
|
|
}
|
|
|
|
xfer += iprot->readStructEnd();
|
|
|
|
return xfer;
|
|
}
|
|
|
|
void PosClient::ping()
|
|
{
|
|
send_ping();
|
|
recv_ping();
|
|
}
|
|
|
|
void PosClient::send_ping()
|
|
{
|
|
int32_t cseqid = 0;
|
|
oprot_->writeMessageBegin("ping", ::apache::thrift::protocol::T_CALL, cseqid);
|
|
|
|
Pos_ping_pargs args;
|
|
args.write(oprot_);
|
|
|
|
oprot_->writeMessageEnd();
|
|
oprot_->getTransport()->writeEnd();
|
|
oprot_->getTransport()->flush();
|
|
}
|
|
|
|
void PosClient::recv_ping()
|
|
{
|
|
|
|
int32_t rseqid = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TMessageType mtype;
|
|
|
|
iprot_->readMessageBegin(fname, mtype, rseqid);
|
|
if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
|
|
::apache::thrift::TApplicationException x;
|
|
x.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
throw x;
|
|
}
|
|
if (mtype != ::apache::thrift::protocol::T_REPLY) {
|
|
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
}
|
|
if (fname.compare("ping") != 0) {
|
|
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
}
|
|
Pos_ping_presult result;
|
|
result.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
|
|
return;
|
|
}
|
|
|
|
void PosClient::getSalt(std::string& _return)
|
|
{
|
|
send_getSalt();
|
|
recv_getSalt(_return);
|
|
}
|
|
|
|
void PosClient::send_getSalt()
|
|
{
|
|
int32_t cseqid = 0;
|
|
oprot_->writeMessageBegin("getSalt", ::apache::thrift::protocol::T_CALL, cseqid);
|
|
|
|
Pos_getSalt_pargs args;
|
|
args.write(oprot_);
|
|
|
|
oprot_->writeMessageEnd();
|
|
oprot_->getTransport()->writeEnd();
|
|
oprot_->getTransport()->flush();
|
|
}
|
|
|
|
void PosClient::recv_getSalt(std::string& _return)
|
|
{
|
|
|
|
int32_t rseqid = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TMessageType mtype;
|
|
|
|
iprot_->readMessageBegin(fname, mtype, rseqid);
|
|
if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
|
|
::apache::thrift::TApplicationException x;
|
|
x.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
throw x;
|
|
}
|
|
if (mtype != ::apache::thrift::protocol::T_REPLY) {
|
|
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
}
|
|
if (fname.compare("getSalt") != 0) {
|
|
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
}
|
|
Pos_getSalt_presult result;
|
|
result.success = &_return;
|
|
result.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
|
|
if (result.__isset.success) {
|
|
// _return pointer has now been filled
|
|
return;
|
|
}
|
|
throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getSalt failed: unknown result");
|
|
}
|
|
|
|
int32_t PosClient::getAccountFromHash(const std::string& dataToHash)
|
|
{
|
|
send_getAccountFromHash(dataToHash);
|
|
return recv_getAccountFromHash();
|
|
}
|
|
|
|
void PosClient::send_getAccountFromHash(const std::string& dataToHash)
|
|
{
|
|
int32_t cseqid = 0;
|
|
oprot_->writeMessageBegin("getAccountFromHash", ::apache::thrift::protocol::T_CALL, cseqid);
|
|
|
|
Pos_getAccountFromHash_pargs args;
|
|
args.dataToHash = &dataToHash;
|
|
args.write(oprot_);
|
|
|
|
oprot_->writeMessageEnd();
|
|
oprot_->getTransport()->writeEnd();
|
|
oprot_->getTransport()->flush();
|
|
}
|
|
|
|
int32_t PosClient::recv_getAccountFromHash()
|
|
{
|
|
|
|
int32_t rseqid = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TMessageType mtype;
|
|
|
|
iprot_->readMessageBegin(fname, mtype, rseqid);
|
|
if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
|
|
::apache::thrift::TApplicationException x;
|
|
x.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
throw x;
|
|
}
|
|
if (mtype != ::apache::thrift::protocol::T_REPLY) {
|
|
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
}
|
|
if (fname.compare("getAccountFromHash") != 0) {
|
|
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
}
|
|
int32_t _return;
|
|
Pos_getAccountFromHash_presult result;
|
|
result.success = &_return;
|
|
result.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
|
|
if (result.__isset.success) {
|
|
return _return;
|
|
}
|
|
throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getAccountFromHash failed: unknown result");
|
|
}
|
|
|
|
void PosClient::getHashesFromAccountId(std::vector<std::string> & _return, const int32_t account)
|
|
{
|
|
send_getHashesFromAccountId(account);
|
|
recv_getHashesFromAccountId(_return);
|
|
}
|
|
|
|
void PosClient::send_getHashesFromAccountId(const int32_t account)
|
|
{
|
|
int32_t cseqid = 0;
|
|
oprot_->writeMessageBegin("getHashesFromAccountId", ::apache::thrift::protocol::T_CALL, cseqid);
|
|
|
|
Pos_getHashesFromAccountId_pargs args;
|
|
args.account = &account;
|
|
args.write(oprot_);
|
|
|
|
oprot_->writeMessageEnd();
|
|
oprot_->getTransport()->writeEnd();
|
|
oprot_->getTransport()->flush();
|
|
}
|
|
|
|
void PosClient::recv_getHashesFromAccountId(std::vector<std::string> & _return)
|
|
{
|
|
|
|
int32_t rseqid = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TMessageType mtype;
|
|
|
|
iprot_->readMessageBegin(fname, mtype, rseqid);
|
|
if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
|
|
::apache::thrift::TApplicationException x;
|
|
x.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
throw x;
|
|
}
|
|
if (mtype != ::apache::thrift::protocol::T_REPLY) {
|
|
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
}
|
|
if (fname.compare("getHashesFromAccountId") != 0) {
|
|
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
}
|
|
Pos_getHashesFromAccountId_presult result;
|
|
result.success = &_return;
|
|
result.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
|
|
if (result.__isset.success) {
|
|
// _return pointer has now been filled
|
|
return;
|
|
}
|
|
throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getHashesFromAccountId failed: unknown result");
|
|
}
|
|
|
|
void PosClient::getHashesFromAccountName(std::vector<std::string> & _return, const std::string& account)
|
|
{
|
|
send_getHashesFromAccountName(account);
|
|
recv_getHashesFromAccountName(_return);
|
|
}
|
|
|
|
void PosClient::send_getHashesFromAccountName(const std::string& account)
|
|
{
|
|
int32_t cseqid = 0;
|
|
oprot_->writeMessageBegin("getHashesFromAccountName", ::apache::thrift::protocol::T_CALL, cseqid);
|
|
|
|
Pos_getHashesFromAccountName_pargs args;
|
|
args.account = &account;
|
|
args.write(oprot_);
|
|
|
|
oprot_->writeMessageEnd();
|
|
oprot_->getTransport()->writeEnd();
|
|
oprot_->getTransport()->flush();
|
|
}
|
|
|
|
void PosClient::recv_getHashesFromAccountName(std::vector<std::string> & _return)
|
|
{
|
|
|
|
int32_t rseqid = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TMessageType mtype;
|
|
|
|
iprot_->readMessageBegin(fname, mtype, rseqid);
|
|
if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
|
|
::apache::thrift::TApplicationException x;
|
|
x.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
throw x;
|
|
}
|
|
if (mtype != ::apache::thrift::protocol::T_REPLY) {
|
|
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
}
|
|
if (fname.compare("getHashesFromAccountName") != 0) {
|
|
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
}
|
|
Pos_getHashesFromAccountName_presult result;
|
|
result.success = &_return;
|
|
result.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
|
|
if (result.__isset.success) {
|
|
// _return pointer has now been filled
|
|
return;
|
|
}
|
|
throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getHashesFromAccountName failed: unknown result");
|
|
}
|
|
|
|
int32_t PosClient::getHashAccountBalance(const std::string& dataToHash)
|
|
{
|
|
send_getHashAccountBalance(dataToHash);
|
|
return recv_getHashAccountBalance();
|
|
}
|
|
|
|
void PosClient::send_getHashAccountBalance(const std::string& dataToHash)
|
|
{
|
|
int32_t cseqid = 0;
|
|
oprot_->writeMessageBegin("getHashAccountBalance", ::apache::thrift::protocol::T_CALL, cseqid);
|
|
|
|
Pos_getHashAccountBalance_pargs args;
|
|
args.dataToHash = &dataToHash;
|
|
args.write(oprot_);
|
|
|
|
oprot_->writeMessageEnd();
|
|
oprot_->getTransport()->writeEnd();
|
|
oprot_->getTransport()->flush();
|
|
}
|
|
|
|
int32_t PosClient::recv_getHashAccountBalance()
|
|
{
|
|
|
|
int32_t rseqid = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TMessageType mtype;
|
|
|
|
iprot_->readMessageBegin(fname, mtype, rseqid);
|
|
if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
|
|
::apache::thrift::TApplicationException x;
|
|
x.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
throw x;
|
|
}
|
|
if (mtype != ::apache::thrift::protocol::T_REPLY) {
|
|
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
}
|
|
if (fname.compare("getHashAccountBalance") != 0) {
|
|
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
}
|
|
int32_t _return;
|
|
Pos_getHashAccountBalance_presult result;
|
|
result.success = &_return;
|
|
result.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
|
|
if (result.__isset.success) {
|
|
return _return;
|
|
}
|
|
throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getHashAccountBalance failed: unknown result");
|
|
}
|
|
|
|
int32_t PosClient::getIdAccountBalance(const int32_t account)
|
|
{
|
|
send_getIdAccountBalance(account);
|
|
return recv_getIdAccountBalance();
|
|
}
|
|
|
|
void PosClient::send_getIdAccountBalance(const int32_t account)
|
|
{
|
|
int32_t cseqid = 0;
|
|
oprot_->writeMessageBegin("getIdAccountBalance", ::apache::thrift::protocol::T_CALL, cseqid);
|
|
|
|
Pos_getIdAccountBalance_pargs args;
|
|
args.account = &account;
|
|
args.write(oprot_);
|
|
|
|
oprot_->writeMessageEnd();
|
|
oprot_->getTransport()->writeEnd();
|
|
oprot_->getTransport()->flush();
|
|
}
|
|
|
|
int32_t PosClient::recv_getIdAccountBalance()
|
|
{
|
|
|
|
int32_t rseqid = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TMessageType mtype;
|
|
|
|
iprot_->readMessageBegin(fname, mtype, rseqid);
|
|
if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
|
|
::apache::thrift::TApplicationException x;
|
|
x.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
throw x;
|
|
}
|
|
if (mtype != ::apache::thrift::protocol::T_REPLY) {
|
|
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
}
|
|
if (fname.compare("getIdAccountBalance") != 0) {
|
|
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
}
|
|
int32_t _return;
|
|
Pos_getIdAccountBalance_presult result;
|
|
result.success = &_return;
|
|
result.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
|
|
if (result.__isset.success) {
|
|
return _return;
|
|
}
|
|
throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getIdAccountBalance failed: unknown result");
|
|
}
|
|
|
|
int32_t PosClient::getNameAccountBalance(const std::string& account)
|
|
{
|
|
send_getNameAccountBalance(account);
|
|
return recv_getNameAccountBalance();
|
|
}
|
|
|
|
void PosClient::send_getNameAccountBalance(const std::string& account)
|
|
{
|
|
int32_t cseqid = 0;
|
|
oprot_->writeMessageBegin("getNameAccountBalance", ::apache::thrift::protocol::T_CALL, cseqid);
|
|
|
|
Pos_getNameAccountBalance_pargs args;
|
|
args.account = &account;
|
|
args.write(oprot_);
|
|
|
|
oprot_->writeMessageEnd();
|
|
oprot_->getTransport()->writeEnd();
|
|
oprot_->getTransport()->flush();
|
|
}
|
|
|
|
int32_t PosClient::recv_getNameAccountBalance()
|
|
{
|
|
|
|
int32_t rseqid = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TMessageType mtype;
|
|
|
|
iprot_->readMessageBegin(fname, mtype, rseqid);
|
|
if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
|
|
::apache::thrift::TApplicationException x;
|
|
x.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
throw x;
|
|
}
|
|
if (mtype != ::apache::thrift::protocol::T_REPLY) {
|
|
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
}
|
|
if (fname.compare("getNameAccountBalance") != 0) {
|
|
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
}
|
|
int32_t _return;
|
|
Pos_getNameAccountBalance_presult result;
|
|
result.success = &_return;
|
|
result.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
|
|
if (result.__isset.success) {
|
|
return _return;
|
|
}
|
|
throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getNameAccountBalance failed: unknown result");
|
|
}
|
|
|
|
int64_t PosClient::associateHashWithId(const std::string& auth, const std::string& dataToHash, const int32_t account)
|
|
{
|
|
send_associateHashWithId(auth, dataToHash, account);
|
|
return recv_associateHashWithId();
|
|
}
|
|
|
|
void PosClient::send_associateHashWithId(const std::string& auth, const std::string& dataToHash, const int32_t account)
|
|
{
|
|
int32_t cseqid = 0;
|
|
oprot_->writeMessageBegin("associateHashWithId", ::apache::thrift::protocol::T_CALL, cseqid);
|
|
|
|
Pos_associateHashWithId_pargs args;
|
|
args.auth = &auth;
|
|
args.dataToHash = &dataToHash;
|
|
args.account = &account;
|
|
args.write(oprot_);
|
|
|
|
oprot_->writeMessageEnd();
|
|
oprot_->getTransport()->writeEnd();
|
|
oprot_->getTransport()->flush();
|
|
}
|
|
|
|
int64_t PosClient::recv_associateHashWithId()
|
|
{
|
|
|
|
int32_t rseqid = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TMessageType mtype;
|
|
|
|
iprot_->readMessageBegin(fname, mtype, rseqid);
|
|
if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
|
|
::apache::thrift::TApplicationException x;
|
|
x.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
throw x;
|
|
}
|
|
if (mtype != ::apache::thrift::protocol::T_REPLY) {
|
|
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
}
|
|
if (fname.compare("associateHashWithId") != 0) {
|
|
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
}
|
|
int64_t _return;
|
|
Pos_associateHashWithId_presult result;
|
|
result.success = &_return;
|
|
result.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
|
|
if (result.__isset.success) {
|
|
return _return;
|
|
}
|
|
throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "associateHashWithId failed: unknown result");
|
|
}
|
|
|
|
int64_t PosClient::associateHashWithName(const std::string& auth, const std::string& dataToHash, const std::string& account)
|
|
{
|
|
send_associateHashWithName(auth, dataToHash, account);
|
|
return recv_associateHashWithName();
|
|
}
|
|
|
|
void PosClient::send_associateHashWithName(const std::string& auth, const std::string& dataToHash, const std::string& account)
|
|
{
|
|
int32_t cseqid = 0;
|
|
oprot_->writeMessageBegin("associateHashWithName", ::apache::thrift::protocol::T_CALL, cseqid);
|
|
|
|
Pos_associateHashWithName_pargs args;
|
|
args.auth = &auth;
|
|
args.dataToHash = &dataToHash;
|
|
args.account = &account;
|
|
args.write(oprot_);
|
|
|
|
oprot_->writeMessageEnd();
|
|
oprot_->getTransport()->writeEnd();
|
|
oprot_->getTransport()->flush();
|
|
}
|
|
|
|
int64_t PosClient::recv_associateHashWithName()
|
|
{
|
|
|
|
int32_t rseqid = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TMessageType mtype;
|
|
|
|
iprot_->readMessageBegin(fname, mtype, rseqid);
|
|
if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
|
|
::apache::thrift::TApplicationException x;
|
|
x.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
throw x;
|
|
}
|
|
if (mtype != ::apache::thrift::protocol::T_REPLY) {
|
|
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
}
|
|
if (fname.compare("associateHashWithName") != 0) {
|
|
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
}
|
|
int64_t _return;
|
|
Pos_associateHashWithName_presult result;
|
|
result.success = &_return;
|
|
result.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
|
|
if (result.__isset.success) {
|
|
return _return;
|
|
}
|
|
throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "associateHashWithName failed: unknown result");
|
|
}
|
|
|
|
int64_t PosClient::deassociateHash(const std::string& auth, const std::string& dataToHash)
|
|
{
|
|
send_deassociateHash(auth, dataToHash);
|
|
return recv_deassociateHash();
|
|
}
|
|
|
|
void PosClient::send_deassociateHash(const std::string& auth, const std::string& dataToHash)
|
|
{
|
|
int32_t cseqid = 0;
|
|
oprot_->writeMessageBegin("deassociateHash", ::apache::thrift::protocol::T_CALL, cseqid);
|
|
|
|
Pos_deassociateHash_pargs args;
|
|
args.auth = &auth;
|
|
args.dataToHash = &dataToHash;
|
|
args.write(oprot_);
|
|
|
|
oprot_->writeMessageEnd();
|
|
oprot_->getTransport()->writeEnd();
|
|
oprot_->getTransport()->flush();
|
|
}
|
|
|
|
int64_t PosClient::recv_deassociateHash()
|
|
{
|
|
|
|
int32_t rseqid = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TMessageType mtype;
|
|
|
|
iprot_->readMessageBegin(fname, mtype, rseqid);
|
|
if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
|
|
::apache::thrift::TApplicationException x;
|
|
x.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
throw x;
|
|
}
|
|
if (mtype != ::apache::thrift::protocol::T_REPLY) {
|
|
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
}
|
|
if (fname.compare("deassociateHash") != 0) {
|
|
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
}
|
|
int64_t _return;
|
|
Pos_deassociateHash_presult result;
|
|
result.success = &_return;
|
|
result.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
|
|
if (result.__isset.success) {
|
|
return _return;
|
|
}
|
|
throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "deassociateHash failed: unknown result");
|
|
}
|
|
|
|
int32_t PosClient::getUPCPrice(const int64_t upc)
|
|
{
|
|
send_getUPCPrice(upc);
|
|
return recv_getUPCPrice();
|
|
}
|
|
|
|
void PosClient::send_getUPCPrice(const int64_t upc)
|
|
{
|
|
int32_t cseqid = 0;
|
|
oprot_->writeMessageBegin("getUPCPrice", ::apache::thrift::protocol::T_CALL, cseqid);
|
|
|
|
Pos_getUPCPrice_pargs args;
|
|
args.upc = &upc;
|
|
args.write(oprot_);
|
|
|
|
oprot_->writeMessageEnd();
|
|
oprot_->getTransport()->writeEnd();
|
|
oprot_->getTransport()->flush();
|
|
}
|
|
|
|
int32_t PosClient::recv_getUPCPrice()
|
|
{
|
|
|
|
int32_t rseqid = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TMessageType mtype;
|
|
|
|
iprot_->readMessageBegin(fname, mtype, rseqid);
|
|
if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
|
|
::apache::thrift::TApplicationException x;
|
|
x.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
throw x;
|
|
}
|
|
if (mtype != ::apache::thrift::protocol::T_REPLY) {
|
|
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
}
|
|
if (fname.compare("getUPCPrice") != 0) {
|
|
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
}
|
|
int32_t _return;
|
|
Pos_getUPCPrice_presult result;
|
|
result.success = &_return;
|
|
result.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
|
|
if (result.__isset.success) {
|
|
return _return;
|
|
}
|
|
throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getUPCPrice failed: unknown result");
|
|
}
|
|
|
|
int64_t PosClient::setUPCPrice(const std::string& auth, const int64_t upc, const int32_t price)
|
|
{
|
|
send_setUPCPrice(auth, upc, price);
|
|
return recv_setUPCPrice();
|
|
}
|
|
|
|
void PosClient::send_setUPCPrice(const std::string& auth, const int64_t upc, const int32_t price)
|
|
{
|
|
int32_t cseqid = 0;
|
|
oprot_->writeMessageBegin("setUPCPrice", ::apache::thrift::protocol::T_CALL, cseqid);
|
|
|
|
Pos_setUPCPrice_pargs args;
|
|
args.auth = &auth;
|
|
args.upc = &upc;
|
|
args.price = &price;
|
|
args.write(oprot_);
|
|
|
|
oprot_->writeMessageEnd();
|
|
oprot_->getTransport()->writeEnd();
|
|
oprot_->getTransport()->flush();
|
|
}
|
|
|
|
int64_t PosClient::recv_setUPCPrice()
|
|
{
|
|
|
|
int32_t rseqid = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TMessageType mtype;
|
|
|
|
iprot_->readMessageBegin(fname, mtype, rseqid);
|
|
if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
|
|
::apache::thrift::TApplicationException x;
|
|
x.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
throw x;
|
|
}
|
|
if (mtype != ::apache::thrift::protocol::T_REPLY) {
|
|
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
}
|
|
if (fname.compare("setUPCPrice") != 0) {
|
|
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
}
|
|
int64_t _return;
|
|
Pos_setUPCPrice_presult result;
|
|
result.success = &_return;
|
|
result.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
|
|
if (result.__isset.success) {
|
|
return _return;
|
|
}
|
|
throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "setUPCPrice failed: unknown result");
|
|
}
|
|
|
|
int64_t PosClient::doTransactionOnHash(const std::string& auth, const std::string& dataToHash, const int32_t delta)
|
|
{
|
|
send_doTransactionOnHash(auth, dataToHash, delta);
|
|
return recv_doTransactionOnHash();
|
|
}
|
|
|
|
void PosClient::send_doTransactionOnHash(const std::string& auth, const std::string& dataToHash, const int32_t delta)
|
|
{
|
|
int32_t cseqid = 0;
|
|
oprot_->writeMessageBegin("doTransactionOnHash", ::apache::thrift::protocol::T_CALL, cseqid);
|
|
|
|
Pos_doTransactionOnHash_pargs args;
|
|
args.auth = &auth;
|
|
args.dataToHash = &dataToHash;
|
|
args.delta = δ
|
|
args.write(oprot_);
|
|
|
|
oprot_->writeMessageEnd();
|
|
oprot_->getTransport()->writeEnd();
|
|
oprot_->getTransport()->flush();
|
|
}
|
|
|
|
int64_t PosClient::recv_doTransactionOnHash()
|
|
{
|
|
|
|
int32_t rseqid = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TMessageType mtype;
|
|
|
|
iprot_->readMessageBegin(fname, mtype, rseqid);
|
|
if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
|
|
::apache::thrift::TApplicationException x;
|
|
x.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
throw x;
|
|
}
|
|
if (mtype != ::apache::thrift::protocol::T_REPLY) {
|
|
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
}
|
|
if (fname.compare("doTransactionOnHash") != 0) {
|
|
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
}
|
|
int64_t _return;
|
|
Pos_doTransactionOnHash_presult result;
|
|
result.success = &_return;
|
|
result.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
|
|
if (result.__isset.success) {
|
|
return _return;
|
|
}
|
|
throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "doTransactionOnHash failed: unknown result");
|
|
}
|
|
|
|
int64_t PosClient::doTransactionOnId(const std::string& auth, const int32_t account, const int32_t delta)
|
|
{
|
|
send_doTransactionOnId(auth, account, delta);
|
|
return recv_doTransactionOnId();
|
|
}
|
|
|
|
void PosClient::send_doTransactionOnId(const std::string& auth, const int32_t account, const int32_t delta)
|
|
{
|
|
int32_t cseqid = 0;
|
|
oprot_->writeMessageBegin("doTransactionOnId", ::apache::thrift::protocol::T_CALL, cseqid);
|
|
|
|
Pos_doTransactionOnId_pargs args;
|
|
args.auth = &auth;
|
|
args.account = &account;
|
|
args.delta = δ
|
|
args.write(oprot_);
|
|
|
|
oprot_->writeMessageEnd();
|
|
oprot_->getTransport()->writeEnd();
|
|
oprot_->getTransport()->flush();
|
|
}
|
|
|
|
int64_t PosClient::recv_doTransactionOnId()
|
|
{
|
|
|
|
int32_t rseqid = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TMessageType mtype;
|
|
|
|
iprot_->readMessageBegin(fname, mtype, rseqid);
|
|
if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
|
|
::apache::thrift::TApplicationException x;
|
|
x.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
throw x;
|
|
}
|
|
if (mtype != ::apache::thrift::protocol::T_REPLY) {
|
|
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
}
|
|
if (fname.compare("doTransactionOnId") != 0) {
|
|
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
}
|
|
int64_t _return;
|
|
Pos_doTransactionOnId_presult result;
|
|
result.success = &_return;
|
|
result.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
|
|
if (result.__isset.success) {
|
|
return _return;
|
|
}
|
|
throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "doTransactionOnId failed: unknown result");
|
|
}
|
|
|
|
int64_t PosClient::doTransactionOnName(const std::string& auth, const std::string& account, const int32_t delta)
|
|
{
|
|
send_doTransactionOnName(auth, account, delta);
|
|
return recv_doTransactionOnName();
|
|
}
|
|
|
|
void PosClient::send_doTransactionOnName(const std::string& auth, const std::string& account, const int32_t delta)
|
|
{
|
|
int32_t cseqid = 0;
|
|
oprot_->writeMessageBegin("doTransactionOnName", ::apache::thrift::protocol::T_CALL, cseqid);
|
|
|
|
Pos_doTransactionOnName_pargs args;
|
|
args.auth = &auth;
|
|
args.account = &account;
|
|
args.delta = δ
|
|
args.write(oprot_);
|
|
|
|
oprot_->writeMessageEnd();
|
|
oprot_->getTransport()->writeEnd();
|
|
oprot_->getTransport()->flush();
|
|
}
|
|
|
|
int64_t PosClient::recv_doTransactionOnName()
|
|
{
|
|
|
|
int32_t rseqid = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TMessageType mtype;
|
|
|
|
iprot_->readMessageBegin(fname, mtype, rseqid);
|
|
if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
|
|
::apache::thrift::TApplicationException x;
|
|
x.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
throw x;
|
|
}
|
|
if (mtype != ::apache::thrift::protocol::T_REPLY) {
|
|
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
}
|
|
if (fname.compare("doTransactionOnName") != 0) {
|
|
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
}
|
|
int64_t _return;
|
|
Pos_doTransactionOnName_presult result;
|
|
result.success = &_return;
|
|
result.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
|
|
if (result.__isset.success) {
|
|
return _return;
|
|
}
|
|
throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "doTransactionOnName failed: unknown result");
|
|
}
|
|
|
|
int64_t PosClient::revertTransaction(const std::string& auth, const int64_t serial)
|
|
{
|
|
send_revertTransaction(auth, serial);
|
|
return recv_revertTransaction();
|
|
}
|
|
|
|
void PosClient::send_revertTransaction(const std::string& auth, const int64_t serial)
|
|
{
|
|
int32_t cseqid = 0;
|
|
oprot_->writeMessageBegin("revertTransaction", ::apache::thrift::protocol::T_CALL, cseqid);
|
|
|
|
Pos_revertTransaction_pargs args;
|
|
args.auth = &auth;
|
|
args.serial = &serial;
|
|
args.write(oprot_);
|
|
|
|
oprot_->writeMessageEnd();
|
|
oprot_->getTransport()->writeEnd();
|
|
oprot_->getTransport()->flush();
|
|
}
|
|
|
|
int64_t PosClient::recv_revertTransaction()
|
|
{
|
|
|
|
int32_t rseqid = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TMessageType mtype;
|
|
|
|
iprot_->readMessageBegin(fname, mtype, rseqid);
|
|
if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
|
|
::apache::thrift::TApplicationException x;
|
|
x.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
throw x;
|
|
}
|
|
if (mtype != ::apache::thrift::protocol::T_REPLY) {
|
|
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
}
|
|
if (fname.compare("revertTransaction") != 0) {
|
|
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
}
|
|
int64_t _return;
|
|
Pos_revertTransaction_presult result;
|
|
result.success = &_return;
|
|
result.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
|
|
if (result.__isset.success) {
|
|
return _return;
|
|
}
|
|
throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "revertTransaction failed: unknown result");
|
|
}
|
|
|
|
int32_t PosClient::getStock(const int64_t upc)
|
|
{
|
|
send_getStock(upc);
|
|
return recv_getStock();
|
|
}
|
|
|
|
void PosClient::send_getStock(const int64_t upc)
|
|
{
|
|
int32_t cseqid = 0;
|
|
oprot_->writeMessageBegin("getStock", ::apache::thrift::protocol::T_CALL, cseqid);
|
|
|
|
Pos_getStock_pargs args;
|
|
args.upc = &upc;
|
|
args.write(oprot_);
|
|
|
|
oprot_->writeMessageEnd();
|
|
oprot_->getTransport()->writeEnd();
|
|
oprot_->getTransport()->flush();
|
|
}
|
|
|
|
int32_t PosClient::recv_getStock()
|
|
{
|
|
|
|
int32_t rseqid = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TMessageType mtype;
|
|
|
|
iprot_->readMessageBegin(fname, mtype, rseqid);
|
|
if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
|
|
::apache::thrift::TApplicationException x;
|
|
x.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
throw x;
|
|
}
|
|
if (mtype != ::apache::thrift::protocol::T_REPLY) {
|
|
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
}
|
|
if (fname.compare("getStock") != 0) {
|
|
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
}
|
|
int32_t _return;
|
|
Pos_getStock_presult result;
|
|
result.success = &_return;
|
|
result.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
|
|
if (result.__isset.success) {
|
|
return _return;
|
|
}
|
|
throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getStock failed: unknown result");
|
|
}
|
|
|
|
int64_t PosClient::doStockChange(const std::string& auth, const int64_t upc, const int32_t delta)
|
|
{
|
|
send_doStockChange(auth, upc, delta);
|
|
return recv_doStockChange();
|
|
}
|
|
|
|
void PosClient::send_doStockChange(const std::string& auth, const int64_t upc, const int32_t delta)
|
|
{
|
|
int32_t cseqid = 0;
|
|
oprot_->writeMessageBegin("doStockChange", ::apache::thrift::protocol::T_CALL, cseqid);
|
|
|
|
Pos_doStockChange_pargs args;
|
|
args.auth = &auth;
|
|
args.upc = &upc;
|
|
args.delta = δ
|
|
args.write(oprot_);
|
|
|
|
oprot_->writeMessageEnd();
|
|
oprot_->getTransport()->writeEnd();
|
|
oprot_->getTransport()->flush();
|
|
}
|
|
|
|
int64_t PosClient::recv_doStockChange()
|
|
{
|
|
|
|
int32_t rseqid = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TMessageType mtype;
|
|
|
|
iprot_->readMessageBegin(fname, mtype, rseqid);
|
|
if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
|
|
::apache::thrift::TApplicationException x;
|
|
x.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
throw x;
|
|
}
|
|
if (mtype != ::apache::thrift::protocol::T_REPLY) {
|
|
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
}
|
|
if (fname.compare("doStockChange") != 0) {
|
|
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
}
|
|
int64_t _return;
|
|
Pos_doStockChange_presult result;
|
|
result.success = &_return;
|
|
result.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
|
|
if (result.__isset.success) {
|
|
return _return;
|
|
}
|
|
throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "doStockChange failed: unknown result");
|
|
}
|
|
|
|
void PosClient::toString(std::vector<std::string> & _return)
|
|
{
|
|
send_toString();
|
|
recv_toString(_return);
|
|
}
|
|
|
|
void PosClient::send_toString()
|
|
{
|
|
int32_t cseqid = 0;
|
|
oprot_->writeMessageBegin("toString", ::apache::thrift::protocol::T_CALL, cseqid);
|
|
|
|
Pos_toString_pargs args;
|
|
args.write(oprot_);
|
|
|
|
oprot_->writeMessageEnd();
|
|
oprot_->getTransport()->writeEnd();
|
|
oprot_->getTransport()->flush();
|
|
}
|
|
|
|
void PosClient::recv_toString(std::vector<std::string> & _return)
|
|
{
|
|
|
|
int32_t rseqid = 0;
|
|
std::string fname;
|
|
::apache::thrift::protocol::TMessageType mtype;
|
|
|
|
iprot_->readMessageBegin(fname, mtype, rseqid);
|
|
if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
|
|
::apache::thrift::TApplicationException x;
|
|
x.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
throw x;
|
|
}
|
|
if (mtype != ::apache::thrift::protocol::T_REPLY) {
|
|
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
}
|
|
if (fname.compare("toString") != 0) {
|
|
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
}
|
|
Pos_toString_presult result;
|
|
result.success = &_return;
|
|
result.read(iprot_);
|
|
iprot_->readMessageEnd();
|
|
iprot_->getTransport()->readEnd();
|
|
|
|
if (result.__isset.success) {
|
|
// _return pointer has now been filled
|
|
return;
|
|
}
|
|
throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "toString failed: unknown result");
|
|
}
|
|
|
|
bool PosProcessor::process(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot, void* callContext) {
|
|
|
|
::apache::thrift::protocol::TProtocol* iprot = piprot.get();
|
|
::apache::thrift::protocol::TProtocol* oprot = poprot.get();
|
|
std::string fname;
|
|
::apache::thrift::protocol::TMessageType mtype;
|
|
int32_t seqid;
|
|
|
|
iprot->readMessageBegin(fname, mtype, seqid);
|
|
|
|
if (mtype != ::apache::thrift::protocol::T_CALL && mtype != ::apache::thrift::protocol::T_ONEWAY) {
|
|
iprot->skip(::apache::thrift::protocol::T_STRUCT);
|
|
iprot->readMessageEnd();
|
|
iprot->getTransport()->readEnd();
|
|
::apache::thrift::TApplicationException x(::apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
|
|
oprot->writeMessageBegin(fname, ::apache::thrift::protocol::T_EXCEPTION, seqid);
|
|
x.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
return false;
|
|
}
|
|
|
|
return process_fn(iprot, oprot, fname, seqid, callContext);
|
|
}
|
|
|
|
bool PosProcessor::process_fn(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, std::string& fname, int32_t seqid, void* callContext) {
|
|
std::map<std::string, void (PosProcessor::*)(int32_t, ::apache::thrift::protocol::TProtocol*, ::apache::thrift::protocol::TProtocol*, void*)>::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 false;
|
|
}
|
|
(this->*(pfn->second))(seqid, iprot, oprot, callContext);
|
|
return true;
|
|
}
|
|
|
|
void PosProcessor::process_ping(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
|
|
{
|
|
void* ctx = NULL;
|
|
if (eventHandler_.get() != NULL) {
|
|
ctx = eventHandler_->getContext("Pos.ping", callContext);
|
|
}
|
|
::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Pos.ping");
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->preRead(ctx, "Pos.ping");
|
|
}
|
|
|
|
Pos_ping_args args;
|
|
args.read(iprot);
|
|
iprot->readMessageEnd();
|
|
uint32_t bytes = iprot->getTransport()->readEnd();
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->postRead(ctx, "Pos.ping", bytes);
|
|
}
|
|
|
|
Pos_ping_result result;
|
|
try {
|
|
iface_->ping();
|
|
} catch (const std::exception& e) {
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->handlerError(ctx, "Pos.ping");
|
|
}
|
|
|
|
::apache::thrift::TApplicationException x(e.what());
|
|
oprot->writeMessageBegin("ping", ::apache::thrift::protocol::T_EXCEPTION, seqid);
|
|
x.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
return;
|
|
}
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->preWrite(ctx, "Pos.ping");
|
|
}
|
|
|
|
oprot->writeMessageBegin("ping", ::apache::thrift::protocol::T_REPLY, seqid);
|
|
result.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
bytes = oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->postWrite(ctx, "Pos.ping", bytes);
|
|
}
|
|
}
|
|
|
|
void PosProcessor::process_getSalt(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
|
|
{
|
|
void* ctx = NULL;
|
|
if (eventHandler_.get() != NULL) {
|
|
ctx = eventHandler_->getContext("Pos.getSalt", callContext);
|
|
}
|
|
::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Pos.getSalt");
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->preRead(ctx, "Pos.getSalt");
|
|
}
|
|
|
|
Pos_getSalt_args args;
|
|
args.read(iprot);
|
|
iprot->readMessageEnd();
|
|
uint32_t bytes = iprot->getTransport()->readEnd();
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->postRead(ctx, "Pos.getSalt", bytes);
|
|
}
|
|
|
|
Pos_getSalt_result result;
|
|
try {
|
|
iface_->getSalt(result.success);
|
|
result.__isset.success = true;
|
|
} catch (const std::exception& e) {
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->handlerError(ctx, "Pos.getSalt");
|
|
}
|
|
|
|
::apache::thrift::TApplicationException x(e.what());
|
|
oprot->writeMessageBegin("getSalt", ::apache::thrift::protocol::T_EXCEPTION, seqid);
|
|
x.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
return;
|
|
}
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->preWrite(ctx, "Pos.getSalt");
|
|
}
|
|
|
|
oprot->writeMessageBegin("getSalt", ::apache::thrift::protocol::T_REPLY, seqid);
|
|
result.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
bytes = oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->postWrite(ctx, "Pos.getSalt", bytes);
|
|
}
|
|
}
|
|
|
|
void PosProcessor::process_getAccountFromHash(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
|
|
{
|
|
void* ctx = NULL;
|
|
if (eventHandler_.get() != NULL) {
|
|
ctx = eventHandler_->getContext("Pos.getAccountFromHash", callContext);
|
|
}
|
|
::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Pos.getAccountFromHash");
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->preRead(ctx, "Pos.getAccountFromHash");
|
|
}
|
|
|
|
Pos_getAccountFromHash_args args;
|
|
args.read(iprot);
|
|
iprot->readMessageEnd();
|
|
uint32_t bytes = iprot->getTransport()->readEnd();
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->postRead(ctx, "Pos.getAccountFromHash", bytes);
|
|
}
|
|
|
|
Pos_getAccountFromHash_result result;
|
|
try {
|
|
result.success = iface_->getAccountFromHash(args.dataToHash);
|
|
result.__isset.success = true;
|
|
} catch (const std::exception& e) {
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->handlerError(ctx, "Pos.getAccountFromHash");
|
|
}
|
|
|
|
::apache::thrift::TApplicationException x(e.what());
|
|
oprot->writeMessageBegin("getAccountFromHash", ::apache::thrift::protocol::T_EXCEPTION, seqid);
|
|
x.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
return;
|
|
}
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->preWrite(ctx, "Pos.getAccountFromHash");
|
|
}
|
|
|
|
oprot->writeMessageBegin("getAccountFromHash", ::apache::thrift::protocol::T_REPLY, seqid);
|
|
result.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
bytes = oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->postWrite(ctx, "Pos.getAccountFromHash", bytes);
|
|
}
|
|
}
|
|
|
|
void PosProcessor::process_getHashesFromAccountId(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
|
|
{
|
|
void* ctx = NULL;
|
|
if (eventHandler_.get() != NULL) {
|
|
ctx = eventHandler_->getContext("Pos.getHashesFromAccountId", callContext);
|
|
}
|
|
::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Pos.getHashesFromAccountId");
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->preRead(ctx, "Pos.getHashesFromAccountId");
|
|
}
|
|
|
|
Pos_getHashesFromAccountId_args args;
|
|
args.read(iprot);
|
|
iprot->readMessageEnd();
|
|
uint32_t bytes = iprot->getTransport()->readEnd();
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->postRead(ctx, "Pos.getHashesFromAccountId", bytes);
|
|
}
|
|
|
|
Pos_getHashesFromAccountId_result result;
|
|
try {
|
|
iface_->getHashesFromAccountId(result.success, args.account);
|
|
result.__isset.success = true;
|
|
} catch (const std::exception& e) {
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->handlerError(ctx, "Pos.getHashesFromAccountId");
|
|
}
|
|
|
|
::apache::thrift::TApplicationException x(e.what());
|
|
oprot->writeMessageBegin("getHashesFromAccountId", ::apache::thrift::protocol::T_EXCEPTION, seqid);
|
|
x.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
return;
|
|
}
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->preWrite(ctx, "Pos.getHashesFromAccountId");
|
|
}
|
|
|
|
oprot->writeMessageBegin("getHashesFromAccountId", ::apache::thrift::protocol::T_REPLY, seqid);
|
|
result.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
bytes = oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->postWrite(ctx, "Pos.getHashesFromAccountId", bytes);
|
|
}
|
|
}
|
|
|
|
void PosProcessor::process_getHashesFromAccountName(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
|
|
{
|
|
void* ctx = NULL;
|
|
if (eventHandler_.get() != NULL) {
|
|
ctx = eventHandler_->getContext("Pos.getHashesFromAccountName", callContext);
|
|
}
|
|
::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Pos.getHashesFromAccountName");
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->preRead(ctx, "Pos.getHashesFromAccountName");
|
|
}
|
|
|
|
Pos_getHashesFromAccountName_args args;
|
|
args.read(iprot);
|
|
iprot->readMessageEnd();
|
|
uint32_t bytes = iprot->getTransport()->readEnd();
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->postRead(ctx, "Pos.getHashesFromAccountName", bytes);
|
|
}
|
|
|
|
Pos_getHashesFromAccountName_result result;
|
|
try {
|
|
iface_->getHashesFromAccountName(result.success, args.account);
|
|
result.__isset.success = true;
|
|
} catch (const std::exception& e) {
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->handlerError(ctx, "Pos.getHashesFromAccountName");
|
|
}
|
|
|
|
::apache::thrift::TApplicationException x(e.what());
|
|
oprot->writeMessageBegin("getHashesFromAccountName", ::apache::thrift::protocol::T_EXCEPTION, seqid);
|
|
x.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
return;
|
|
}
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->preWrite(ctx, "Pos.getHashesFromAccountName");
|
|
}
|
|
|
|
oprot->writeMessageBegin("getHashesFromAccountName", ::apache::thrift::protocol::T_REPLY, seqid);
|
|
result.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
bytes = oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->postWrite(ctx, "Pos.getHashesFromAccountName", bytes);
|
|
}
|
|
}
|
|
|
|
void PosProcessor::process_getHashAccountBalance(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
|
|
{
|
|
void* ctx = NULL;
|
|
if (eventHandler_.get() != NULL) {
|
|
ctx = eventHandler_->getContext("Pos.getHashAccountBalance", callContext);
|
|
}
|
|
::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Pos.getHashAccountBalance");
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->preRead(ctx, "Pos.getHashAccountBalance");
|
|
}
|
|
|
|
Pos_getHashAccountBalance_args args;
|
|
args.read(iprot);
|
|
iprot->readMessageEnd();
|
|
uint32_t bytes = iprot->getTransport()->readEnd();
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->postRead(ctx, "Pos.getHashAccountBalance", bytes);
|
|
}
|
|
|
|
Pos_getHashAccountBalance_result result;
|
|
try {
|
|
result.success = iface_->getHashAccountBalance(args.dataToHash);
|
|
result.__isset.success = true;
|
|
} catch (const std::exception& e) {
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->handlerError(ctx, "Pos.getHashAccountBalance");
|
|
}
|
|
|
|
::apache::thrift::TApplicationException x(e.what());
|
|
oprot->writeMessageBegin("getHashAccountBalance", ::apache::thrift::protocol::T_EXCEPTION, seqid);
|
|
x.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
return;
|
|
}
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->preWrite(ctx, "Pos.getHashAccountBalance");
|
|
}
|
|
|
|
oprot->writeMessageBegin("getHashAccountBalance", ::apache::thrift::protocol::T_REPLY, seqid);
|
|
result.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
bytes = oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->postWrite(ctx, "Pos.getHashAccountBalance", bytes);
|
|
}
|
|
}
|
|
|
|
void PosProcessor::process_getIdAccountBalance(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
|
|
{
|
|
void* ctx = NULL;
|
|
if (eventHandler_.get() != NULL) {
|
|
ctx = eventHandler_->getContext("Pos.getIdAccountBalance", callContext);
|
|
}
|
|
::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Pos.getIdAccountBalance");
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->preRead(ctx, "Pos.getIdAccountBalance");
|
|
}
|
|
|
|
Pos_getIdAccountBalance_args args;
|
|
args.read(iprot);
|
|
iprot->readMessageEnd();
|
|
uint32_t bytes = iprot->getTransport()->readEnd();
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->postRead(ctx, "Pos.getIdAccountBalance", bytes);
|
|
}
|
|
|
|
Pos_getIdAccountBalance_result result;
|
|
try {
|
|
result.success = iface_->getIdAccountBalance(args.account);
|
|
result.__isset.success = true;
|
|
} catch (const std::exception& e) {
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->handlerError(ctx, "Pos.getIdAccountBalance");
|
|
}
|
|
|
|
::apache::thrift::TApplicationException x(e.what());
|
|
oprot->writeMessageBegin("getIdAccountBalance", ::apache::thrift::protocol::T_EXCEPTION, seqid);
|
|
x.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
return;
|
|
}
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->preWrite(ctx, "Pos.getIdAccountBalance");
|
|
}
|
|
|
|
oprot->writeMessageBegin("getIdAccountBalance", ::apache::thrift::protocol::T_REPLY, seqid);
|
|
result.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
bytes = oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->postWrite(ctx, "Pos.getIdAccountBalance", bytes);
|
|
}
|
|
}
|
|
|
|
void PosProcessor::process_getNameAccountBalance(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
|
|
{
|
|
void* ctx = NULL;
|
|
if (eventHandler_.get() != NULL) {
|
|
ctx = eventHandler_->getContext("Pos.getNameAccountBalance", callContext);
|
|
}
|
|
::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Pos.getNameAccountBalance");
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->preRead(ctx, "Pos.getNameAccountBalance");
|
|
}
|
|
|
|
Pos_getNameAccountBalance_args args;
|
|
args.read(iprot);
|
|
iprot->readMessageEnd();
|
|
uint32_t bytes = iprot->getTransport()->readEnd();
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->postRead(ctx, "Pos.getNameAccountBalance", bytes);
|
|
}
|
|
|
|
Pos_getNameAccountBalance_result result;
|
|
try {
|
|
result.success = iface_->getNameAccountBalance(args.account);
|
|
result.__isset.success = true;
|
|
} catch (const std::exception& e) {
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->handlerError(ctx, "Pos.getNameAccountBalance");
|
|
}
|
|
|
|
::apache::thrift::TApplicationException x(e.what());
|
|
oprot->writeMessageBegin("getNameAccountBalance", ::apache::thrift::protocol::T_EXCEPTION, seqid);
|
|
x.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
return;
|
|
}
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->preWrite(ctx, "Pos.getNameAccountBalance");
|
|
}
|
|
|
|
oprot->writeMessageBegin("getNameAccountBalance", ::apache::thrift::protocol::T_REPLY, seqid);
|
|
result.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
bytes = oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->postWrite(ctx, "Pos.getNameAccountBalance", bytes);
|
|
}
|
|
}
|
|
|
|
void PosProcessor::process_associateHashWithId(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
|
|
{
|
|
void* ctx = NULL;
|
|
if (eventHandler_.get() != NULL) {
|
|
ctx = eventHandler_->getContext("Pos.associateHashWithId", callContext);
|
|
}
|
|
::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Pos.associateHashWithId");
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->preRead(ctx, "Pos.associateHashWithId");
|
|
}
|
|
|
|
Pos_associateHashWithId_args args;
|
|
args.read(iprot);
|
|
iprot->readMessageEnd();
|
|
uint32_t bytes = iprot->getTransport()->readEnd();
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->postRead(ctx, "Pos.associateHashWithId", bytes);
|
|
}
|
|
|
|
Pos_associateHashWithId_result result;
|
|
try {
|
|
result.success = iface_->associateHashWithId(args.auth, args.dataToHash, args.account);
|
|
result.__isset.success = true;
|
|
} catch (const std::exception& e) {
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->handlerError(ctx, "Pos.associateHashWithId");
|
|
}
|
|
|
|
::apache::thrift::TApplicationException x(e.what());
|
|
oprot->writeMessageBegin("associateHashWithId", ::apache::thrift::protocol::T_EXCEPTION, seqid);
|
|
x.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
return;
|
|
}
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->preWrite(ctx, "Pos.associateHashWithId");
|
|
}
|
|
|
|
oprot->writeMessageBegin("associateHashWithId", ::apache::thrift::protocol::T_REPLY, seqid);
|
|
result.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
bytes = oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->postWrite(ctx, "Pos.associateHashWithId", bytes);
|
|
}
|
|
}
|
|
|
|
void PosProcessor::process_associateHashWithName(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
|
|
{
|
|
void* ctx = NULL;
|
|
if (eventHandler_.get() != NULL) {
|
|
ctx = eventHandler_->getContext("Pos.associateHashWithName", callContext);
|
|
}
|
|
::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Pos.associateHashWithName");
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->preRead(ctx, "Pos.associateHashWithName");
|
|
}
|
|
|
|
Pos_associateHashWithName_args args;
|
|
args.read(iprot);
|
|
iprot->readMessageEnd();
|
|
uint32_t bytes = iprot->getTransport()->readEnd();
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->postRead(ctx, "Pos.associateHashWithName", bytes);
|
|
}
|
|
|
|
Pos_associateHashWithName_result result;
|
|
try {
|
|
result.success = iface_->associateHashWithName(args.auth, args.dataToHash, args.account);
|
|
result.__isset.success = true;
|
|
} catch (const std::exception& e) {
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->handlerError(ctx, "Pos.associateHashWithName");
|
|
}
|
|
|
|
::apache::thrift::TApplicationException x(e.what());
|
|
oprot->writeMessageBegin("associateHashWithName", ::apache::thrift::protocol::T_EXCEPTION, seqid);
|
|
x.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
return;
|
|
}
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->preWrite(ctx, "Pos.associateHashWithName");
|
|
}
|
|
|
|
oprot->writeMessageBegin("associateHashWithName", ::apache::thrift::protocol::T_REPLY, seqid);
|
|
result.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
bytes = oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->postWrite(ctx, "Pos.associateHashWithName", bytes);
|
|
}
|
|
}
|
|
|
|
void PosProcessor::process_deassociateHash(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
|
|
{
|
|
void* ctx = NULL;
|
|
if (eventHandler_.get() != NULL) {
|
|
ctx = eventHandler_->getContext("Pos.deassociateHash", callContext);
|
|
}
|
|
::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Pos.deassociateHash");
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->preRead(ctx, "Pos.deassociateHash");
|
|
}
|
|
|
|
Pos_deassociateHash_args args;
|
|
args.read(iprot);
|
|
iprot->readMessageEnd();
|
|
uint32_t bytes = iprot->getTransport()->readEnd();
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->postRead(ctx, "Pos.deassociateHash", bytes);
|
|
}
|
|
|
|
Pos_deassociateHash_result result;
|
|
try {
|
|
result.success = iface_->deassociateHash(args.auth, args.dataToHash);
|
|
result.__isset.success = true;
|
|
} catch (const std::exception& e) {
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->handlerError(ctx, "Pos.deassociateHash");
|
|
}
|
|
|
|
::apache::thrift::TApplicationException x(e.what());
|
|
oprot->writeMessageBegin("deassociateHash", ::apache::thrift::protocol::T_EXCEPTION, seqid);
|
|
x.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
return;
|
|
}
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->preWrite(ctx, "Pos.deassociateHash");
|
|
}
|
|
|
|
oprot->writeMessageBegin("deassociateHash", ::apache::thrift::protocol::T_REPLY, seqid);
|
|
result.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
bytes = oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->postWrite(ctx, "Pos.deassociateHash", bytes);
|
|
}
|
|
}
|
|
|
|
void PosProcessor::process_getUPCPrice(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
|
|
{
|
|
void* ctx = NULL;
|
|
if (eventHandler_.get() != NULL) {
|
|
ctx = eventHandler_->getContext("Pos.getUPCPrice", callContext);
|
|
}
|
|
::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Pos.getUPCPrice");
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->preRead(ctx, "Pos.getUPCPrice");
|
|
}
|
|
|
|
Pos_getUPCPrice_args args;
|
|
args.read(iprot);
|
|
iprot->readMessageEnd();
|
|
uint32_t bytes = iprot->getTransport()->readEnd();
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->postRead(ctx, "Pos.getUPCPrice", bytes);
|
|
}
|
|
|
|
Pos_getUPCPrice_result result;
|
|
try {
|
|
result.success = iface_->getUPCPrice(args.upc);
|
|
result.__isset.success = true;
|
|
} catch (const std::exception& e) {
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->handlerError(ctx, "Pos.getUPCPrice");
|
|
}
|
|
|
|
::apache::thrift::TApplicationException x(e.what());
|
|
oprot->writeMessageBegin("getUPCPrice", ::apache::thrift::protocol::T_EXCEPTION, seqid);
|
|
x.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
return;
|
|
}
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->preWrite(ctx, "Pos.getUPCPrice");
|
|
}
|
|
|
|
oprot->writeMessageBegin("getUPCPrice", ::apache::thrift::protocol::T_REPLY, seqid);
|
|
result.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
bytes = oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->postWrite(ctx, "Pos.getUPCPrice", bytes);
|
|
}
|
|
}
|
|
|
|
void PosProcessor::process_setUPCPrice(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
|
|
{
|
|
void* ctx = NULL;
|
|
if (eventHandler_.get() != NULL) {
|
|
ctx = eventHandler_->getContext("Pos.setUPCPrice", callContext);
|
|
}
|
|
::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Pos.setUPCPrice");
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->preRead(ctx, "Pos.setUPCPrice");
|
|
}
|
|
|
|
Pos_setUPCPrice_args args;
|
|
args.read(iprot);
|
|
iprot->readMessageEnd();
|
|
uint32_t bytes = iprot->getTransport()->readEnd();
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->postRead(ctx, "Pos.setUPCPrice", bytes);
|
|
}
|
|
|
|
Pos_setUPCPrice_result result;
|
|
try {
|
|
result.success = iface_->setUPCPrice(args.auth, args.upc, args.price);
|
|
result.__isset.success = true;
|
|
} catch (const std::exception& e) {
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->handlerError(ctx, "Pos.setUPCPrice");
|
|
}
|
|
|
|
::apache::thrift::TApplicationException x(e.what());
|
|
oprot->writeMessageBegin("setUPCPrice", ::apache::thrift::protocol::T_EXCEPTION, seqid);
|
|
x.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
return;
|
|
}
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->preWrite(ctx, "Pos.setUPCPrice");
|
|
}
|
|
|
|
oprot->writeMessageBegin("setUPCPrice", ::apache::thrift::protocol::T_REPLY, seqid);
|
|
result.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
bytes = oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->postWrite(ctx, "Pos.setUPCPrice", bytes);
|
|
}
|
|
}
|
|
|
|
void PosProcessor::process_doTransactionOnHash(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
|
|
{
|
|
void* ctx = NULL;
|
|
if (eventHandler_.get() != NULL) {
|
|
ctx = eventHandler_->getContext("Pos.doTransactionOnHash", callContext);
|
|
}
|
|
::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Pos.doTransactionOnHash");
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->preRead(ctx, "Pos.doTransactionOnHash");
|
|
}
|
|
|
|
Pos_doTransactionOnHash_args args;
|
|
args.read(iprot);
|
|
iprot->readMessageEnd();
|
|
uint32_t bytes = iprot->getTransport()->readEnd();
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->postRead(ctx, "Pos.doTransactionOnHash", bytes);
|
|
}
|
|
|
|
Pos_doTransactionOnHash_result result;
|
|
try {
|
|
result.success = iface_->doTransactionOnHash(args.auth, args.dataToHash, args.delta);
|
|
result.__isset.success = true;
|
|
} catch (const std::exception& e) {
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->handlerError(ctx, "Pos.doTransactionOnHash");
|
|
}
|
|
|
|
::apache::thrift::TApplicationException x(e.what());
|
|
oprot->writeMessageBegin("doTransactionOnHash", ::apache::thrift::protocol::T_EXCEPTION, seqid);
|
|
x.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
return;
|
|
}
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->preWrite(ctx, "Pos.doTransactionOnHash");
|
|
}
|
|
|
|
oprot->writeMessageBegin("doTransactionOnHash", ::apache::thrift::protocol::T_REPLY, seqid);
|
|
result.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
bytes = oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->postWrite(ctx, "Pos.doTransactionOnHash", bytes);
|
|
}
|
|
}
|
|
|
|
void PosProcessor::process_doTransactionOnId(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
|
|
{
|
|
void* ctx = NULL;
|
|
if (eventHandler_.get() != NULL) {
|
|
ctx = eventHandler_->getContext("Pos.doTransactionOnId", callContext);
|
|
}
|
|
::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Pos.doTransactionOnId");
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->preRead(ctx, "Pos.doTransactionOnId");
|
|
}
|
|
|
|
Pos_doTransactionOnId_args args;
|
|
args.read(iprot);
|
|
iprot->readMessageEnd();
|
|
uint32_t bytes = iprot->getTransport()->readEnd();
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->postRead(ctx, "Pos.doTransactionOnId", bytes);
|
|
}
|
|
|
|
Pos_doTransactionOnId_result result;
|
|
try {
|
|
result.success = iface_->doTransactionOnId(args.auth, args.account, args.delta);
|
|
result.__isset.success = true;
|
|
} catch (const std::exception& e) {
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->handlerError(ctx, "Pos.doTransactionOnId");
|
|
}
|
|
|
|
::apache::thrift::TApplicationException x(e.what());
|
|
oprot->writeMessageBegin("doTransactionOnId", ::apache::thrift::protocol::T_EXCEPTION, seqid);
|
|
x.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
return;
|
|
}
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->preWrite(ctx, "Pos.doTransactionOnId");
|
|
}
|
|
|
|
oprot->writeMessageBegin("doTransactionOnId", ::apache::thrift::protocol::T_REPLY, seqid);
|
|
result.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
bytes = oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->postWrite(ctx, "Pos.doTransactionOnId", bytes);
|
|
}
|
|
}
|
|
|
|
void PosProcessor::process_doTransactionOnName(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
|
|
{
|
|
void* ctx = NULL;
|
|
if (eventHandler_.get() != NULL) {
|
|
ctx = eventHandler_->getContext("Pos.doTransactionOnName", callContext);
|
|
}
|
|
::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Pos.doTransactionOnName");
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->preRead(ctx, "Pos.doTransactionOnName");
|
|
}
|
|
|
|
Pos_doTransactionOnName_args args;
|
|
args.read(iprot);
|
|
iprot->readMessageEnd();
|
|
uint32_t bytes = iprot->getTransport()->readEnd();
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->postRead(ctx, "Pos.doTransactionOnName", bytes);
|
|
}
|
|
|
|
Pos_doTransactionOnName_result result;
|
|
try {
|
|
result.success = iface_->doTransactionOnName(args.auth, args.account, args.delta);
|
|
result.__isset.success = true;
|
|
} catch (const std::exception& e) {
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->handlerError(ctx, "Pos.doTransactionOnName");
|
|
}
|
|
|
|
::apache::thrift::TApplicationException x(e.what());
|
|
oprot->writeMessageBegin("doTransactionOnName", ::apache::thrift::protocol::T_EXCEPTION, seqid);
|
|
x.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
return;
|
|
}
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->preWrite(ctx, "Pos.doTransactionOnName");
|
|
}
|
|
|
|
oprot->writeMessageBegin("doTransactionOnName", ::apache::thrift::protocol::T_REPLY, seqid);
|
|
result.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
bytes = oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->postWrite(ctx, "Pos.doTransactionOnName", bytes);
|
|
}
|
|
}
|
|
|
|
void PosProcessor::process_revertTransaction(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
|
|
{
|
|
void* ctx = NULL;
|
|
if (eventHandler_.get() != NULL) {
|
|
ctx = eventHandler_->getContext("Pos.revertTransaction", callContext);
|
|
}
|
|
::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Pos.revertTransaction");
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->preRead(ctx, "Pos.revertTransaction");
|
|
}
|
|
|
|
Pos_revertTransaction_args args;
|
|
args.read(iprot);
|
|
iprot->readMessageEnd();
|
|
uint32_t bytes = iprot->getTransport()->readEnd();
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->postRead(ctx, "Pos.revertTransaction", bytes);
|
|
}
|
|
|
|
Pos_revertTransaction_result result;
|
|
try {
|
|
result.success = iface_->revertTransaction(args.auth, args.serial);
|
|
result.__isset.success = true;
|
|
} catch (const std::exception& e) {
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->handlerError(ctx, "Pos.revertTransaction");
|
|
}
|
|
|
|
::apache::thrift::TApplicationException x(e.what());
|
|
oprot->writeMessageBegin("revertTransaction", ::apache::thrift::protocol::T_EXCEPTION, seqid);
|
|
x.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
return;
|
|
}
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->preWrite(ctx, "Pos.revertTransaction");
|
|
}
|
|
|
|
oprot->writeMessageBegin("revertTransaction", ::apache::thrift::protocol::T_REPLY, seqid);
|
|
result.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
bytes = oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->postWrite(ctx, "Pos.revertTransaction", bytes);
|
|
}
|
|
}
|
|
|
|
void PosProcessor::process_getStock(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
|
|
{
|
|
void* ctx = NULL;
|
|
if (eventHandler_.get() != NULL) {
|
|
ctx = eventHandler_->getContext("Pos.getStock", callContext);
|
|
}
|
|
::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Pos.getStock");
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->preRead(ctx, "Pos.getStock");
|
|
}
|
|
|
|
Pos_getStock_args args;
|
|
args.read(iprot);
|
|
iprot->readMessageEnd();
|
|
uint32_t bytes = iprot->getTransport()->readEnd();
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->postRead(ctx, "Pos.getStock", bytes);
|
|
}
|
|
|
|
Pos_getStock_result result;
|
|
try {
|
|
result.success = iface_->getStock(args.upc);
|
|
result.__isset.success = true;
|
|
} catch (const std::exception& e) {
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->handlerError(ctx, "Pos.getStock");
|
|
}
|
|
|
|
::apache::thrift::TApplicationException x(e.what());
|
|
oprot->writeMessageBegin("getStock", ::apache::thrift::protocol::T_EXCEPTION, seqid);
|
|
x.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
return;
|
|
}
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->preWrite(ctx, "Pos.getStock");
|
|
}
|
|
|
|
oprot->writeMessageBegin("getStock", ::apache::thrift::protocol::T_REPLY, seqid);
|
|
result.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
bytes = oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->postWrite(ctx, "Pos.getStock", bytes);
|
|
}
|
|
}
|
|
|
|
void PosProcessor::process_doStockChange(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
|
|
{
|
|
void* ctx = NULL;
|
|
if (eventHandler_.get() != NULL) {
|
|
ctx = eventHandler_->getContext("Pos.doStockChange", callContext);
|
|
}
|
|
::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Pos.doStockChange");
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->preRead(ctx, "Pos.doStockChange");
|
|
}
|
|
|
|
Pos_doStockChange_args args;
|
|
args.read(iprot);
|
|
iprot->readMessageEnd();
|
|
uint32_t bytes = iprot->getTransport()->readEnd();
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->postRead(ctx, "Pos.doStockChange", bytes);
|
|
}
|
|
|
|
Pos_doStockChange_result result;
|
|
try {
|
|
result.success = iface_->doStockChange(args.auth, args.upc, args.delta);
|
|
result.__isset.success = true;
|
|
} catch (const std::exception& e) {
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->handlerError(ctx, "Pos.doStockChange");
|
|
}
|
|
|
|
::apache::thrift::TApplicationException x(e.what());
|
|
oprot->writeMessageBegin("doStockChange", ::apache::thrift::protocol::T_EXCEPTION, seqid);
|
|
x.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
return;
|
|
}
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->preWrite(ctx, "Pos.doStockChange");
|
|
}
|
|
|
|
oprot->writeMessageBegin("doStockChange", ::apache::thrift::protocol::T_REPLY, seqid);
|
|
result.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
bytes = oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->postWrite(ctx, "Pos.doStockChange", bytes);
|
|
}
|
|
}
|
|
|
|
void PosProcessor::process_toString(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
|
|
{
|
|
void* ctx = NULL;
|
|
if (eventHandler_.get() != NULL) {
|
|
ctx = eventHandler_->getContext("Pos.toString", callContext);
|
|
}
|
|
::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Pos.toString");
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->preRead(ctx, "Pos.toString");
|
|
}
|
|
|
|
Pos_toString_args args;
|
|
args.read(iprot);
|
|
iprot->readMessageEnd();
|
|
uint32_t bytes = iprot->getTransport()->readEnd();
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->postRead(ctx, "Pos.toString", bytes);
|
|
}
|
|
|
|
Pos_toString_result result;
|
|
try {
|
|
iface_->toString(result.success);
|
|
result.__isset.success = true;
|
|
} catch (const std::exception& e) {
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->handlerError(ctx, "Pos.toString");
|
|
}
|
|
|
|
::apache::thrift::TApplicationException x(e.what());
|
|
oprot->writeMessageBegin("toString", ::apache::thrift::protocol::T_EXCEPTION, seqid);
|
|
x.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
return;
|
|
}
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->preWrite(ctx, "Pos.toString");
|
|
}
|
|
|
|
oprot->writeMessageBegin("toString", ::apache::thrift::protocol::T_REPLY, seqid);
|
|
result.write(oprot);
|
|
oprot->writeMessageEnd();
|
|
bytes = oprot->getTransport()->writeEnd();
|
|
oprot->getTransport()->flush();
|
|
|
|
if (eventHandler_.get() != NULL) {
|
|
eventHandler_->postWrite(ctx, "Pos.toString", bytes);
|
|
}
|
|
}
|
|
|
|
} // namespace
|
|
|