2724 lines
69 KiB
C++
2724 lines
69 KiB
C++
/**
|
|
* Autogenerated by Thrift Compiler (0.7.0)
|
|
*
|
|
* DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
|
|
*/
|
|
#ifndef Pos_H
|
|
#define Pos_H
|
|
|
|
#include <TProcessor.h>
|
|
#include "pos_types.h"
|
|
|
|
namespace pos {
|
|
|
|
class PosIf {
|
|
public:
|
|
virtual ~PosIf() {}
|
|
virtual void ping() = 0;
|
|
virtual void getSalt(std::string& _return) = 0;
|
|
virtual int32_t getAccountFromHash(const std::string& dataToHash) = 0;
|
|
virtual void getHashesFromAccountId(std::vector<std::string> & _return, const int32_t account) = 0;
|
|
virtual void getHashesFromAccountName(std::vector<std::string> & _return, const std::string& account) = 0;
|
|
virtual int32_t getHashAccountBalance(const std::string& dataToHash) = 0;
|
|
virtual int32_t getIdAccountBalance(const int32_t account) = 0;
|
|
virtual int32_t getNameAccountBalance(const std::string& account) = 0;
|
|
virtual int64_t associateHashWithId(const std::string& auth, const std::string& dataToHash, const int32_t account) = 0;
|
|
virtual int64_t associateHashWithName(const std::string& auth, const std::string& dataToHash, const std::string& account) = 0;
|
|
virtual int64_t deassociateHash(const std::string& auth, const std::string& dataToHash) = 0;
|
|
virtual int32_t getUPCPrice(const int64_t upc) = 0;
|
|
virtual int64_t setUPCPrice(const std::string& auth, const int64_t upc, const int32_t price) = 0;
|
|
virtual int64_t doTransactionOnHash(const std::string& auth, const std::string& dataToHash, const int32_t delta) = 0;
|
|
virtual int64_t doTransactionOnId(const std::string& auth, const int32_t account, const int32_t delta) = 0;
|
|
virtual int64_t doTransactionOnName(const std::string& auth, const std::string& account, const int32_t delta) = 0;
|
|
virtual int64_t revertTransaction(const std::string& auth, const int64_t serial) = 0;
|
|
virtual int32_t getStock(const int64_t upc) = 0;
|
|
virtual int64_t doStockChange(const std::string& auth, const int64_t upc, const int32_t delta) = 0;
|
|
virtual void toString(std::vector<std::string> & _return) = 0;
|
|
};
|
|
|
|
class PosNull : virtual public PosIf {
|
|
public:
|
|
virtual ~PosNull() {}
|
|
void ping() {
|
|
return;
|
|
}
|
|
void getSalt(std::string& /* _return */) {
|
|
return;
|
|
}
|
|
int32_t getAccountFromHash(const std::string& /* dataToHash */) {
|
|
int32_t _return = 0;
|
|
return _return;
|
|
}
|
|
void getHashesFromAccountId(std::vector<std::string> & /* _return */, const int32_t /* account */) {
|
|
return;
|
|
}
|
|
void getHashesFromAccountName(std::vector<std::string> & /* _return */, const std::string& /* account */) {
|
|
return;
|
|
}
|
|
int32_t getHashAccountBalance(const std::string& /* dataToHash */) {
|
|
int32_t _return = 0;
|
|
return _return;
|
|
}
|
|
int32_t getIdAccountBalance(const int32_t /* account */) {
|
|
int32_t _return = 0;
|
|
return _return;
|
|
}
|
|
int32_t getNameAccountBalance(const std::string& /* account */) {
|
|
int32_t _return = 0;
|
|
return _return;
|
|
}
|
|
int64_t associateHashWithId(const std::string& /* auth */, const std::string& /* dataToHash */, const int32_t /* account */) {
|
|
int64_t _return = 0;
|
|
return _return;
|
|
}
|
|
int64_t associateHashWithName(const std::string& /* auth */, const std::string& /* dataToHash */, const std::string& /* account */) {
|
|
int64_t _return = 0;
|
|
return _return;
|
|
}
|
|
int64_t deassociateHash(const std::string& /* auth */, const std::string& /* dataToHash */) {
|
|
int64_t _return = 0;
|
|
return _return;
|
|
}
|
|
int32_t getUPCPrice(const int64_t /* upc */) {
|
|
int32_t _return = 0;
|
|
return _return;
|
|
}
|
|
int64_t setUPCPrice(const std::string& /* auth */, const int64_t /* upc */, const int32_t /* price */) {
|
|
int64_t _return = 0;
|
|
return _return;
|
|
}
|
|
int64_t doTransactionOnHash(const std::string& /* auth */, const std::string& /* dataToHash */, const int32_t /* delta */) {
|
|
int64_t _return = 0;
|
|
return _return;
|
|
}
|
|
int64_t doTransactionOnId(const std::string& /* auth */, const int32_t /* account */, const int32_t /* delta */) {
|
|
int64_t _return = 0;
|
|
return _return;
|
|
}
|
|
int64_t doTransactionOnName(const std::string& /* auth */, const std::string& /* account */, const int32_t /* delta */) {
|
|
int64_t _return = 0;
|
|
return _return;
|
|
}
|
|
int64_t revertTransaction(const std::string& /* auth */, const int64_t /* serial */) {
|
|
int64_t _return = 0;
|
|
return _return;
|
|
}
|
|
int32_t getStock(const int64_t /* upc */) {
|
|
int32_t _return = 0;
|
|
return _return;
|
|
}
|
|
int64_t doStockChange(const std::string& /* auth */, const int64_t /* upc */, const int32_t /* delta */) {
|
|
int64_t _return = 0;
|
|
return _return;
|
|
}
|
|
void toString(std::vector<std::string> & /* _return */) {
|
|
return;
|
|
}
|
|
};
|
|
|
|
|
|
class Pos_ping_args {
|
|
public:
|
|
|
|
Pos_ping_args() {
|
|
}
|
|
|
|
virtual ~Pos_ping_args() throw() {}
|
|
|
|
|
|
bool operator == (const Pos_ping_args & /* rhs */) const
|
|
{
|
|
return true;
|
|
}
|
|
bool operator != (const Pos_ping_args &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const Pos_ping_args & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
|
|
class Pos_ping_pargs {
|
|
public:
|
|
|
|
|
|
virtual ~Pos_ping_pargs() throw() {}
|
|
|
|
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
|
|
class Pos_ping_result {
|
|
public:
|
|
|
|
Pos_ping_result() {
|
|
}
|
|
|
|
virtual ~Pos_ping_result() throw() {}
|
|
|
|
|
|
bool operator == (const Pos_ping_result & /* rhs */) const
|
|
{
|
|
return true;
|
|
}
|
|
bool operator != (const Pos_ping_result &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const Pos_ping_result & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
|
|
class Pos_ping_presult {
|
|
public:
|
|
|
|
|
|
virtual ~Pos_ping_presult() throw() {}
|
|
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
|
|
};
|
|
|
|
|
|
class Pos_getSalt_args {
|
|
public:
|
|
|
|
Pos_getSalt_args() {
|
|
}
|
|
|
|
virtual ~Pos_getSalt_args() throw() {}
|
|
|
|
|
|
bool operator == (const Pos_getSalt_args & /* rhs */) const
|
|
{
|
|
return true;
|
|
}
|
|
bool operator != (const Pos_getSalt_args &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const Pos_getSalt_args & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
|
|
class Pos_getSalt_pargs {
|
|
public:
|
|
|
|
|
|
virtual ~Pos_getSalt_pargs() throw() {}
|
|
|
|
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _Pos_getSalt_result__isset {
|
|
_Pos_getSalt_result__isset() : success(false) {}
|
|
bool success;
|
|
} _Pos_getSalt_result__isset;
|
|
|
|
class Pos_getSalt_result {
|
|
public:
|
|
|
|
Pos_getSalt_result() : success("") {
|
|
}
|
|
|
|
virtual ~Pos_getSalt_result() throw() {}
|
|
|
|
std::string success;
|
|
|
|
_Pos_getSalt_result__isset __isset;
|
|
|
|
void __set_success(const std::string& val) {
|
|
success = val;
|
|
}
|
|
|
|
bool operator == (const Pos_getSalt_result & rhs) const
|
|
{
|
|
if (!(success == rhs.success))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const Pos_getSalt_result &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const Pos_getSalt_result & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _Pos_getSalt_presult__isset {
|
|
_Pos_getSalt_presult__isset() : success(false) {}
|
|
bool success;
|
|
} _Pos_getSalt_presult__isset;
|
|
|
|
class Pos_getSalt_presult {
|
|
public:
|
|
|
|
|
|
virtual ~Pos_getSalt_presult() throw() {}
|
|
|
|
std::string* success;
|
|
|
|
_Pos_getSalt_presult__isset __isset;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
|
|
};
|
|
|
|
typedef struct _Pos_getAccountFromHash_args__isset {
|
|
_Pos_getAccountFromHash_args__isset() : dataToHash(false) {}
|
|
bool dataToHash;
|
|
} _Pos_getAccountFromHash_args__isset;
|
|
|
|
class Pos_getAccountFromHash_args {
|
|
public:
|
|
|
|
Pos_getAccountFromHash_args() : dataToHash("") {
|
|
}
|
|
|
|
virtual ~Pos_getAccountFromHash_args() throw() {}
|
|
|
|
std::string dataToHash;
|
|
|
|
_Pos_getAccountFromHash_args__isset __isset;
|
|
|
|
void __set_dataToHash(const std::string& val) {
|
|
dataToHash = val;
|
|
}
|
|
|
|
bool operator == (const Pos_getAccountFromHash_args & rhs) const
|
|
{
|
|
if (!(dataToHash == rhs.dataToHash))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const Pos_getAccountFromHash_args &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const Pos_getAccountFromHash_args & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
|
|
class Pos_getAccountFromHash_pargs {
|
|
public:
|
|
|
|
|
|
virtual ~Pos_getAccountFromHash_pargs() throw() {}
|
|
|
|
const std::string* dataToHash;
|
|
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _Pos_getAccountFromHash_result__isset {
|
|
_Pos_getAccountFromHash_result__isset() : success(false) {}
|
|
bool success;
|
|
} _Pos_getAccountFromHash_result__isset;
|
|
|
|
class Pos_getAccountFromHash_result {
|
|
public:
|
|
|
|
Pos_getAccountFromHash_result() : success(0) {
|
|
}
|
|
|
|
virtual ~Pos_getAccountFromHash_result() throw() {}
|
|
|
|
int32_t success;
|
|
|
|
_Pos_getAccountFromHash_result__isset __isset;
|
|
|
|
void __set_success(const int32_t val) {
|
|
success = val;
|
|
}
|
|
|
|
bool operator == (const Pos_getAccountFromHash_result & rhs) const
|
|
{
|
|
if (!(success == rhs.success))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const Pos_getAccountFromHash_result &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const Pos_getAccountFromHash_result & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _Pos_getAccountFromHash_presult__isset {
|
|
_Pos_getAccountFromHash_presult__isset() : success(false) {}
|
|
bool success;
|
|
} _Pos_getAccountFromHash_presult__isset;
|
|
|
|
class Pos_getAccountFromHash_presult {
|
|
public:
|
|
|
|
|
|
virtual ~Pos_getAccountFromHash_presult() throw() {}
|
|
|
|
int32_t* success;
|
|
|
|
_Pos_getAccountFromHash_presult__isset __isset;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
|
|
};
|
|
|
|
typedef struct _Pos_getHashesFromAccountId_args__isset {
|
|
_Pos_getHashesFromAccountId_args__isset() : account(false) {}
|
|
bool account;
|
|
} _Pos_getHashesFromAccountId_args__isset;
|
|
|
|
class Pos_getHashesFromAccountId_args {
|
|
public:
|
|
|
|
Pos_getHashesFromAccountId_args() : account(0) {
|
|
}
|
|
|
|
virtual ~Pos_getHashesFromAccountId_args() throw() {}
|
|
|
|
int32_t account;
|
|
|
|
_Pos_getHashesFromAccountId_args__isset __isset;
|
|
|
|
void __set_account(const int32_t val) {
|
|
account = val;
|
|
}
|
|
|
|
bool operator == (const Pos_getHashesFromAccountId_args & rhs) const
|
|
{
|
|
if (!(account == rhs.account))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const Pos_getHashesFromAccountId_args &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const Pos_getHashesFromAccountId_args & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
|
|
class Pos_getHashesFromAccountId_pargs {
|
|
public:
|
|
|
|
|
|
virtual ~Pos_getHashesFromAccountId_pargs() throw() {}
|
|
|
|
const int32_t* account;
|
|
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _Pos_getHashesFromAccountId_result__isset {
|
|
_Pos_getHashesFromAccountId_result__isset() : success(false) {}
|
|
bool success;
|
|
} _Pos_getHashesFromAccountId_result__isset;
|
|
|
|
class Pos_getHashesFromAccountId_result {
|
|
public:
|
|
|
|
Pos_getHashesFromAccountId_result() {
|
|
}
|
|
|
|
virtual ~Pos_getHashesFromAccountId_result() throw() {}
|
|
|
|
std::vector<std::string> success;
|
|
|
|
_Pos_getHashesFromAccountId_result__isset __isset;
|
|
|
|
void __set_success(const std::vector<std::string> & val) {
|
|
success = val;
|
|
}
|
|
|
|
bool operator == (const Pos_getHashesFromAccountId_result & rhs) const
|
|
{
|
|
if (!(success == rhs.success))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const Pos_getHashesFromAccountId_result &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const Pos_getHashesFromAccountId_result & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _Pos_getHashesFromAccountId_presult__isset {
|
|
_Pos_getHashesFromAccountId_presult__isset() : success(false) {}
|
|
bool success;
|
|
} _Pos_getHashesFromAccountId_presult__isset;
|
|
|
|
class Pos_getHashesFromAccountId_presult {
|
|
public:
|
|
|
|
|
|
virtual ~Pos_getHashesFromAccountId_presult() throw() {}
|
|
|
|
std::vector<std::string> * success;
|
|
|
|
_Pos_getHashesFromAccountId_presult__isset __isset;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
|
|
};
|
|
|
|
typedef struct _Pos_getHashesFromAccountName_args__isset {
|
|
_Pos_getHashesFromAccountName_args__isset() : account(false) {}
|
|
bool account;
|
|
} _Pos_getHashesFromAccountName_args__isset;
|
|
|
|
class Pos_getHashesFromAccountName_args {
|
|
public:
|
|
|
|
Pos_getHashesFromAccountName_args() : account("") {
|
|
}
|
|
|
|
virtual ~Pos_getHashesFromAccountName_args() throw() {}
|
|
|
|
std::string account;
|
|
|
|
_Pos_getHashesFromAccountName_args__isset __isset;
|
|
|
|
void __set_account(const std::string& val) {
|
|
account = val;
|
|
}
|
|
|
|
bool operator == (const Pos_getHashesFromAccountName_args & rhs) const
|
|
{
|
|
if (!(account == rhs.account))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const Pos_getHashesFromAccountName_args &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const Pos_getHashesFromAccountName_args & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
|
|
class Pos_getHashesFromAccountName_pargs {
|
|
public:
|
|
|
|
|
|
virtual ~Pos_getHashesFromAccountName_pargs() throw() {}
|
|
|
|
const std::string* account;
|
|
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _Pos_getHashesFromAccountName_result__isset {
|
|
_Pos_getHashesFromAccountName_result__isset() : success(false) {}
|
|
bool success;
|
|
} _Pos_getHashesFromAccountName_result__isset;
|
|
|
|
class Pos_getHashesFromAccountName_result {
|
|
public:
|
|
|
|
Pos_getHashesFromAccountName_result() {
|
|
}
|
|
|
|
virtual ~Pos_getHashesFromAccountName_result() throw() {}
|
|
|
|
std::vector<std::string> success;
|
|
|
|
_Pos_getHashesFromAccountName_result__isset __isset;
|
|
|
|
void __set_success(const std::vector<std::string> & val) {
|
|
success = val;
|
|
}
|
|
|
|
bool operator == (const Pos_getHashesFromAccountName_result & rhs) const
|
|
{
|
|
if (!(success == rhs.success))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const Pos_getHashesFromAccountName_result &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const Pos_getHashesFromAccountName_result & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _Pos_getHashesFromAccountName_presult__isset {
|
|
_Pos_getHashesFromAccountName_presult__isset() : success(false) {}
|
|
bool success;
|
|
} _Pos_getHashesFromAccountName_presult__isset;
|
|
|
|
class Pos_getHashesFromAccountName_presult {
|
|
public:
|
|
|
|
|
|
virtual ~Pos_getHashesFromAccountName_presult() throw() {}
|
|
|
|
std::vector<std::string> * success;
|
|
|
|
_Pos_getHashesFromAccountName_presult__isset __isset;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
|
|
};
|
|
|
|
typedef struct _Pos_getHashAccountBalance_args__isset {
|
|
_Pos_getHashAccountBalance_args__isset() : dataToHash(false) {}
|
|
bool dataToHash;
|
|
} _Pos_getHashAccountBalance_args__isset;
|
|
|
|
class Pos_getHashAccountBalance_args {
|
|
public:
|
|
|
|
Pos_getHashAccountBalance_args() : dataToHash("") {
|
|
}
|
|
|
|
virtual ~Pos_getHashAccountBalance_args() throw() {}
|
|
|
|
std::string dataToHash;
|
|
|
|
_Pos_getHashAccountBalance_args__isset __isset;
|
|
|
|
void __set_dataToHash(const std::string& val) {
|
|
dataToHash = val;
|
|
}
|
|
|
|
bool operator == (const Pos_getHashAccountBalance_args & rhs) const
|
|
{
|
|
if (!(dataToHash == rhs.dataToHash))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const Pos_getHashAccountBalance_args &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const Pos_getHashAccountBalance_args & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
|
|
class Pos_getHashAccountBalance_pargs {
|
|
public:
|
|
|
|
|
|
virtual ~Pos_getHashAccountBalance_pargs() throw() {}
|
|
|
|
const std::string* dataToHash;
|
|
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _Pos_getHashAccountBalance_result__isset {
|
|
_Pos_getHashAccountBalance_result__isset() : success(false) {}
|
|
bool success;
|
|
} _Pos_getHashAccountBalance_result__isset;
|
|
|
|
class Pos_getHashAccountBalance_result {
|
|
public:
|
|
|
|
Pos_getHashAccountBalance_result() : success(0) {
|
|
}
|
|
|
|
virtual ~Pos_getHashAccountBalance_result() throw() {}
|
|
|
|
int32_t success;
|
|
|
|
_Pos_getHashAccountBalance_result__isset __isset;
|
|
|
|
void __set_success(const int32_t val) {
|
|
success = val;
|
|
}
|
|
|
|
bool operator == (const Pos_getHashAccountBalance_result & rhs) const
|
|
{
|
|
if (!(success == rhs.success))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const Pos_getHashAccountBalance_result &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const Pos_getHashAccountBalance_result & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _Pos_getHashAccountBalance_presult__isset {
|
|
_Pos_getHashAccountBalance_presult__isset() : success(false) {}
|
|
bool success;
|
|
} _Pos_getHashAccountBalance_presult__isset;
|
|
|
|
class Pos_getHashAccountBalance_presult {
|
|
public:
|
|
|
|
|
|
virtual ~Pos_getHashAccountBalance_presult() throw() {}
|
|
|
|
int32_t* success;
|
|
|
|
_Pos_getHashAccountBalance_presult__isset __isset;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
|
|
};
|
|
|
|
typedef struct _Pos_getIdAccountBalance_args__isset {
|
|
_Pos_getIdAccountBalance_args__isset() : account(false) {}
|
|
bool account;
|
|
} _Pos_getIdAccountBalance_args__isset;
|
|
|
|
class Pos_getIdAccountBalance_args {
|
|
public:
|
|
|
|
Pos_getIdAccountBalance_args() : account(0) {
|
|
}
|
|
|
|
virtual ~Pos_getIdAccountBalance_args() throw() {}
|
|
|
|
int32_t account;
|
|
|
|
_Pos_getIdAccountBalance_args__isset __isset;
|
|
|
|
void __set_account(const int32_t val) {
|
|
account = val;
|
|
}
|
|
|
|
bool operator == (const Pos_getIdAccountBalance_args & rhs) const
|
|
{
|
|
if (!(account == rhs.account))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const Pos_getIdAccountBalance_args &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const Pos_getIdAccountBalance_args & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
|
|
class Pos_getIdAccountBalance_pargs {
|
|
public:
|
|
|
|
|
|
virtual ~Pos_getIdAccountBalance_pargs() throw() {}
|
|
|
|
const int32_t* account;
|
|
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _Pos_getIdAccountBalance_result__isset {
|
|
_Pos_getIdAccountBalance_result__isset() : success(false) {}
|
|
bool success;
|
|
} _Pos_getIdAccountBalance_result__isset;
|
|
|
|
class Pos_getIdAccountBalance_result {
|
|
public:
|
|
|
|
Pos_getIdAccountBalance_result() : success(0) {
|
|
}
|
|
|
|
virtual ~Pos_getIdAccountBalance_result() throw() {}
|
|
|
|
int32_t success;
|
|
|
|
_Pos_getIdAccountBalance_result__isset __isset;
|
|
|
|
void __set_success(const int32_t val) {
|
|
success = val;
|
|
}
|
|
|
|
bool operator == (const Pos_getIdAccountBalance_result & rhs) const
|
|
{
|
|
if (!(success == rhs.success))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const Pos_getIdAccountBalance_result &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const Pos_getIdAccountBalance_result & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _Pos_getIdAccountBalance_presult__isset {
|
|
_Pos_getIdAccountBalance_presult__isset() : success(false) {}
|
|
bool success;
|
|
} _Pos_getIdAccountBalance_presult__isset;
|
|
|
|
class Pos_getIdAccountBalance_presult {
|
|
public:
|
|
|
|
|
|
virtual ~Pos_getIdAccountBalance_presult() throw() {}
|
|
|
|
int32_t* success;
|
|
|
|
_Pos_getIdAccountBalance_presult__isset __isset;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
|
|
};
|
|
|
|
typedef struct _Pos_getNameAccountBalance_args__isset {
|
|
_Pos_getNameAccountBalance_args__isset() : account(false) {}
|
|
bool account;
|
|
} _Pos_getNameAccountBalance_args__isset;
|
|
|
|
class Pos_getNameAccountBalance_args {
|
|
public:
|
|
|
|
Pos_getNameAccountBalance_args() : account("") {
|
|
}
|
|
|
|
virtual ~Pos_getNameAccountBalance_args() throw() {}
|
|
|
|
std::string account;
|
|
|
|
_Pos_getNameAccountBalance_args__isset __isset;
|
|
|
|
void __set_account(const std::string& val) {
|
|
account = val;
|
|
}
|
|
|
|
bool operator == (const Pos_getNameAccountBalance_args & rhs) const
|
|
{
|
|
if (!(account == rhs.account))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const Pos_getNameAccountBalance_args &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const Pos_getNameAccountBalance_args & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
|
|
class Pos_getNameAccountBalance_pargs {
|
|
public:
|
|
|
|
|
|
virtual ~Pos_getNameAccountBalance_pargs() throw() {}
|
|
|
|
const std::string* account;
|
|
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _Pos_getNameAccountBalance_result__isset {
|
|
_Pos_getNameAccountBalance_result__isset() : success(false) {}
|
|
bool success;
|
|
} _Pos_getNameAccountBalance_result__isset;
|
|
|
|
class Pos_getNameAccountBalance_result {
|
|
public:
|
|
|
|
Pos_getNameAccountBalance_result() : success(0) {
|
|
}
|
|
|
|
virtual ~Pos_getNameAccountBalance_result() throw() {}
|
|
|
|
int32_t success;
|
|
|
|
_Pos_getNameAccountBalance_result__isset __isset;
|
|
|
|
void __set_success(const int32_t val) {
|
|
success = val;
|
|
}
|
|
|
|
bool operator == (const Pos_getNameAccountBalance_result & rhs) const
|
|
{
|
|
if (!(success == rhs.success))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const Pos_getNameAccountBalance_result &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const Pos_getNameAccountBalance_result & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _Pos_getNameAccountBalance_presult__isset {
|
|
_Pos_getNameAccountBalance_presult__isset() : success(false) {}
|
|
bool success;
|
|
} _Pos_getNameAccountBalance_presult__isset;
|
|
|
|
class Pos_getNameAccountBalance_presult {
|
|
public:
|
|
|
|
|
|
virtual ~Pos_getNameAccountBalance_presult() throw() {}
|
|
|
|
int32_t* success;
|
|
|
|
_Pos_getNameAccountBalance_presult__isset __isset;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
|
|
};
|
|
|
|
typedef struct _Pos_associateHashWithId_args__isset {
|
|
_Pos_associateHashWithId_args__isset() : auth(false), dataToHash(false), account(false) {}
|
|
bool auth;
|
|
bool dataToHash;
|
|
bool account;
|
|
} _Pos_associateHashWithId_args__isset;
|
|
|
|
class Pos_associateHashWithId_args {
|
|
public:
|
|
|
|
Pos_associateHashWithId_args() : auth(""), dataToHash(""), account(0) {
|
|
}
|
|
|
|
virtual ~Pos_associateHashWithId_args() throw() {}
|
|
|
|
std::string auth;
|
|
std::string dataToHash;
|
|
int32_t account;
|
|
|
|
_Pos_associateHashWithId_args__isset __isset;
|
|
|
|
void __set_auth(const std::string& val) {
|
|
auth = val;
|
|
}
|
|
|
|
void __set_dataToHash(const std::string& val) {
|
|
dataToHash = val;
|
|
}
|
|
|
|
void __set_account(const int32_t val) {
|
|
account = val;
|
|
}
|
|
|
|
bool operator == (const Pos_associateHashWithId_args & rhs) const
|
|
{
|
|
if (!(auth == rhs.auth))
|
|
return false;
|
|
if (!(dataToHash == rhs.dataToHash))
|
|
return false;
|
|
if (!(account == rhs.account))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const Pos_associateHashWithId_args &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const Pos_associateHashWithId_args & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
|
|
class Pos_associateHashWithId_pargs {
|
|
public:
|
|
|
|
|
|
virtual ~Pos_associateHashWithId_pargs() throw() {}
|
|
|
|
const std::string* auth;
|
|
const std::string* dataToHash;
|
|
const int32_t* account;
|
|
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _Pos_associateHashWithId_result__isset {
|
|
_Pos_associateHashWithId_result__isset() : success(false) {}
|
|
bool success;
|
|
} _Pos_associateHashWithId_result__isset;
|
|
|
|
class Pos_associateHashWithId_result {
|
|
public:
|
|
|
|
Pos_associateHashWithId_result() : success(0) {
|
|
}
|
|
|
|
virtual ~Pos_associateHashWithId_result() throw() {}
|
|
|
|
int64_t success;
|
|
|
|
_Pos_associateHashWithId_result__isset __isset;
|
|
|
|
void __set_success(const int64_t val) {
|
|
success = val;
|
|
}
|
|
|
|
bool operator == (const Pos_associateHashWithId_result & rhs) const
|
|
{
|
|
if (!(success == rhs.success))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const Pos_associateHashWithId_result &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const Pos_associateHashWithId_result & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _Pos_associateHashWithId_presult__isset {
|
|
_Pos_associateHashWithId_presult__isset() : success(false) {}
|
|
bool success;
|
|
} _Pos_associateHashWithId_presult__isset;
|
|
|
|
class Pos_associateHashWithId_presult {
|
|
public:
|
|
|
|
|
|
virtual ~Pos_associateHashWithId_presult() throw() {}
|
|
|
|
int64_t* success;
|
|
|
|
_Pos_associateHashWithId_presult__isset __isset;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
|
|
};
|
|
|
|
typedef struct _Pos_associateHashWithName_args__isset {
|
|
_Pos_associateHashWithName_args__isset() : auth(false), dataToHash(false), account(false) {}
|
|
bool auth;
|
|
bool dataToHash;
|
|
bool account;
|
|
} _Pos_associateHashWithName_args__isset;
|
|
|
|
class Pos_associateHashWithName_args {
|
|
public:
|
|
|
|
Pos_associateHashWithName_args() : auth(""), dataToHash(""), account("") {
|
|
}
|
|
|
|
virtual ~Pos_associateHashWithName_args() throw() {}
|
|
|
|
std::string auth;
|
|
std::string dataToHash;
|
|
std::string account;
|
|
|
|
_Pos_associateHashWithName_args__isset __isset;
|
|
|
|
void __set_auth(const std::string& val) {
|
|
auth = val;
|
|
}
|
|
|
|
void __set_dataToHash(const std::string& val) {
|
|
dataToHash = val;
|
|
}
|
|
|
|
void __set_account(const std::string& val) {
|
|
account = val;
|
|
}
|
|
|
|
bool operator == (const Pos_associateHashWithName_args & rhs) const
|
|
{
|
|
if (!(auth == rhs.auth))
|
|
return false;
|
|
if (!(dataToHash == rhs.dataToHash))
|
|
return false;
|
|
if (!(account == rhs.account))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const Pos_associateHashWithName_args &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const Pos_associateHashWithName_args & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
|
|
class Pos_associateHashWithName_pargs {
|
|
public:
|
|
|
|
|
|
virtual ~Pos_associateHashWithName_pargs() throw() {}
|
|
|
|
const std::string* auth;
|
|
const std::string* dataToHash;
|
|
const std::string* account;
|
|
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _Pos_associateHashWithName_result__isset {
|
|
_Pos_associateHashWithName_result__isset() : success(false) {}
|
|
bool success;
|
|
} _Pos_associateHashWithName_result__isset;
|
|
|
|
class Pos_associateHashWithName_result {
|
|
public:
|
|
|
|
Pos_associateHashWithName_result() : success(0) {
|
|
}
|
|
|
|
virtual ~Pos_associateHashWithName_result() throw() {}
|
|
|
|
int64_t success;
|
|
|
|
_Pos_associateHashWithName_result__isset __isset;
|
|
|
|
void __set_success(const int64_t val) {
|
|
success = val;
|
|
}
|
|
|
|
bool operator == (const Pos_associateHashWithName_result & rhs) const
|
|
{
|
|
if (!(success == rhs.success))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const Pos_associateHashWithName_result &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const Pos_associateHashWithName_result & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _Pos_associateHashWithName_presult__isset {
|
|
_Pos_associateHashWithName_presult__isset() : success(false) {}
|
|
bool success;
|
|
} _Pos_associateHashWithName_presult__isset;
|
|
|
|
class Pos_associateHashWithName_presult {
|
|
public:
|
|
|
|
|
|
virtual ~Pos_associateHashWithName_presult() throw() {}
|
|
|
|
int64_t* success;
|
|
|
|
_Pos_associateHashWithName_presult__isset __isset;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
|
|
};
|
|
|
|
typedef struct _Pos_deassociateHash_args__isset {
|
|
_Pos_deassociateHash_args__isset() : auth(false), dataToHash(false) {}
|
|
bool auth;
|
|
bool dataToHash;
|
|
} _Pos_deassociateHash_args__isset;
|
|
|
|
class Pos_deassociateHash_args {
|
|
public:
|
|
|
|
Pos_deassociateHash_args() : auth(""), dataToHash("") {
|
|
}
|
|
|
|
virtual ~Pos_deassociateHash_args() throw() {}
|
|
|
|
std::string auth;
|
|
std::string dataToHash;
|
|
|
|
_Pos_deassociateHash_args__isset __isset;
|
|
|
|
void __set_auth(const std::string& val) {
|
|
auth = val;
|
|
}
|
|
|
|
void __set_dataToHash(const std::string& val) {
|
|
dataToHash = val;
|
|
}
|
|
|
|
bool operator == (const Pos_deassociateHash_args & rhs) const
|
|
{
|
|
if (!(auth == rhs.auth))
|
|
return false;
|
|
if (!(dataToHash == rhs.dataToHash))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const Pos_deassociateHash_args &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const Pos_deassociateHash_args & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
|
|
class Pos_deassociateHash_pargs {
|
|
public:
|
|
|
|
|
|
virtual ~Pos_deassociateHash_pargs() throw() {}
|
|
|
|
const std::string* auth;
|
|
const std::string* dataToHash;
|
|
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _Pos_deassociateHash_result__isset {
|
|
_Pos_deassociateHash_result__isset() : success(false) {}
|
|
bool success;
|
|
} _Pos_deassociateHash_result__isset;
|
|
|
|
class Pos_deassociateHash_result {
|
|
public:
|
|
|
|
Pos_deassociateHash_result() : success(0) {
|
|
}
|
|
|
|
virtual ~Pos_deassociateHash_result() throw() {}
|
|
|
|
int64_t success;
|
|
|
|
_Pos_deassociateHash_result__isset __isset;
|
|
|
|
void __set_success(const int64_t val) {
|
|
success = val;
|
|
}
|
|
|
|
bool operator == (const Pos_deassociateHash_result & rhs) const
|
|
{
|
|
if (!(success == rhs.success))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const Pos_deassociateHash_result &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const Pos_deassociateHash_result & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _Pos_deassociateHash_presult__isset {
|
|
_Pos_deassociateHash_presult__isset() : success(false) {}
|
|
bool success;
|
|
} _Pos_deassociateHash_presult__isset;
|
|
|
|
class Pos_deassociateHash_presult {
|
|
public:
|
|
|
|
|
|
virtual ~Pos_deassociateHash_presult() throw() {}
|
|
|
|
int64_t* success;
|
|
|
|
_Pos_deassociateHash_presult__isset __isset;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
|
|
};
|
|
|
|
typedef struct _Pos_getUPCPrice_args__isset {
|
|
_Pos_getUPCPrice_args__isset() : upc(false) {}
|
|
bool upc;
|
|
} _Pos_getUPCPrice_args__isset;
|
|
|
|
class Pos_getUPCPrice_args {
|
|
public:
|
|
|
|
Pos_getUPCPrice_args() : upc(0) {
|
|
}
|
|
|
|
virtual ~Pos_getUPCPrice_args() throw() {}
|
|
|
|
int64_t upc;
|
|
|
|
_Pos_getUPCPrice_args__isset __isset;
|
|
|
|
bool operator == (const Pos_getUPCPrice_args & rhs) const
|
|
{
|
|
if (!(upc == rhs.upc))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const Pos_getUPCPrice_args &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const Pos_getUPCPrice_args & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
|
|
class Pos_getUPCPrice_pargs {
|
|
public:
|
|
|
|
|
|
virtual ~Pos_getUPCPrice_pargs() throw() {}
|
|
|
|
const int64_t* upc;
|
|
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _Pos_getUPCPrice_result__isset {
|
|
_Pos_getUPCPrice_result__isset() : success(false) {}
|
|
bool success;
|
|
} _Pos_getUPCPrice_result__isset;
|
|
|
|
class Pos_getUPCPrice_result {
|
|
public:
|
|
|
|
Pos_getUPCPrice_result() : success(0) {
|
|
}
|
|
|
|
virtual ~Pos_getUPCPrice_result() throw() {}
|
|
|
|
int32_t success;
|
|
|
|
_Pos_getUPCPrice_result__isset __isset;
|
|
|
|
void __set_success(const int32_t val) {
|
|
success = val;
|
|
}
|
|
|
|
bool operator == (const Pos_getUPCPrice_result & rhs) const
|
|
{
|
|
if (!(success == rhs.success))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const Pos_getUPCPrice_result &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const Pos_getUPCPrice_result & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _Pos_getUPCPrice_presult__isset {
|
|
_Pos_getUPCPrice_presult__isset() : success(false) {}
|
|
bool success;
|
|
} _Pos_getUPCPrice_presult__isset;
|
|
|
|
class Pos_getUPCPrice_presult {
|
|
public:
|
|
|
|
|
|
virtual ~Pos_getUPCPrice_presult() throw() {}
|
|
|
|
int32_t* success;
|
|
|
|
_Pos_getUPCPrice_presult__isset __isset;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
|
|
};
|
|
|
|
typedef struct _Pos_setUPCPrice_args__isset {
|
|
_Pos_setUPCPrice_args__isset() : auth(false), upc(false), price(false) {}
|
|
bool auth;
|
|
bool upc;
|
|
bool price;
|
|
} _Pos_setUPCPrice_args__isset;
|
|
|
|
class Pos_setUPCPrice_args {
|
|
public:
|
|
|
|
Pos_setUPCPrice_args() : auth(""), upc(0), price(0) {
|
|
}
|
|
|
|
virtual ~Pos_setUPCPrice_args() throw() {}
|
|
|
|
std::string auth;
|
|
int64_t upc;
|
|
int32_t price;
|
|
|
|
_Pos_setUPCPrice_args__isset __isset;
|
|
|
|
void __set_auth(const std::string& val) {
|
|
auth = val;
|
|
}
|
|
|
|
void __set_price(const int32_t val) {
|
|
price = val;
|
|
}
|
|
|
|
bool operator == (const Pos_setUPCPrice_args & rhs) const
|
|
{
|
|
if (!(auth == rhs.auth))
|
|
return false;
|
|
if (!(upc == rhs.upc))
|
|
return false;
|
|
if (!(price == rhs.price))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const Pos_setUPCPrice_args &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const Pos_setUPCPrice_args & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
|
|
class Pos_setUPCPrice_pargs {
|
|
public:
|
|
|
|
|
|
virtual ~Pos_setUPCPrice_pargs() throw() {}
|
|
|
|
const std::string* auth;
|
|
const int64_t* upc;
|
|
const int32_t* price;
|
|
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _Pos_setUPCPrice_result__isset {
|
|
_Pos_setUPCPrice_result__isset() : success(false) {}
|
|
bool success;
|
|
} _Pos_setUPCPrice_result__isset;
|
|
|
|
class Pos_setUPCPrice_result {
|
|
public:
|
|
|
|
Pos_setUPCPrice_result() : success(0) {
|
|
}
|
|
|
|
virtual ~Pos_setUPCPrice_result() throw() {}
|
|
|
|
int64_t success;
|
|
|
|
_Pos_setUPCPrice_result__isset __isset;
|
|
|
|
void __set_success(const int64_t val) {
|
|
success = val;
|
|
}
|
|
|
|
bool operator == (const Pos_setUPCPrice_result & rhs) const
|
|
{
|
|
if (!(success == rhs.success))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const Pos_setUPCPrice_result &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const Pos_setUPCPrice_result & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _Pos_setUPCPrice_presult__isset {
|
|
_Pos_setUPCPrice_presult__isset() : success(false) {}
|
|
bool success;
|
|
} _Pos_setUPCPrice_presult__isset;
|
|
|
|
class Pos_setUPCPrice_presult {
|
|
public:
|
|
|
|
|
|
virtual ~Pos_setUPCPrice_presult() throw() {}
|
|
|
|
int64_t* success;
|
|
|
|
_Pos_setUPCPrice_presult__isset __isset;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
|
|
};
|
|
|
|
typedef struct _Pos_doTransactionOnHash_args__isset {
|
|
_Pos_doTransactionOnHash_args__isset() : auth(false), dataToHash(false), delta(false) {}
|
|
bool auth;
|
|
bool dataToHash;
|
|
bool delta;
|
|
} _Pos_doTransactionOnHash_args__isset;
|
|
|
|
class Pos_doTransactionOnHash_args {
|
|
public:
|
|
|
|
Pos_doTransactionOnHash_args() : auth(""), dataToHash(""), delta(0) {
|
|
}
|
|
|
|
virtual ~Pos_doTransactionOnHash_args() throw() {}
|
|
|
|
std::string auth;
|
|
std::string dataToHash;
|
|
int32_t delta;
|
|
|
|
_Pos_doTransactionOnHash_args__isset __isset;
|
|
|
|
void __set_auth(const std::string& val) {
|
|
auth = val;
|
|
}
|
|
|
|
void __set_dataToHash(const std::string& val) {
|
|
dataToHash = val;
|
|
}
|
|
|
|
void __set_delta(const int32_t val) {
|
|
delta = val;
|
|
}
|
|
|
|
bool operator == (const Pos_doTransactionOnHash_args & rhs) const
|
|
{
|
|
if (!(auth == rhs.auth))
|
|
return false;
|
|
if (!(dataToHash == rhs.dataToHash))
|
|
return false;
|
|
if (!(delta == rhs.delta))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const Pos_doTransactionOnHash_args &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const Pos_doTransactionOnHash_args & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
|
|
class Pos_doTransactionOnHash_pargs {
|
|
public:
|
|
|
|
|
|
virtual ~Pos_doTransactionOnHash_pargs() throw() {}
|
|
|
|
const std::string* auth;
|
|
const std::string* dataToHash;
|
|
const int32_t* delta;
|
|
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _Pos_doTransactionOnHash_result__isset {
|
|
_Pos_doTransactionOnHash_result__isset() : success(false) {}
|
|
bool success;
|
|
} _Pos_doTransactionOnHash_result__isset;
|
|
|
|
class Pos_doTransactionOnHash_result {
|
|
public:
|
|
|
|
Pos_doTransactionOnHash_result() : success(0) {
|
|
}
|
|
|
|
virtual ~Pos_doTransactionOnHash_result() throw() {}
|
|
|
|
int64_t success;
|
|
|
|
_Pos_doTransactionOnHash_result__isset __isset;
|
|
|
|
void __set_success(const int64_t val) {
|
|
success = val;
|
|
}
|
|
|
|
bool operator == (const Pos_doTransactionOnHash_result & rhs) const
|
|
{
|
|
if (!(success == rhs.success))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const Pos_doTransactionOnHash_result &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const Pos_doTransactionOnHash_result & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _Pos_doTransactionOnHash_presult__isset {
|
|
_Pos_doTransactionOnHash_presult__isset() : success(false) {}
|
|
bool success;
|
|
} _Pos_doTransactionOnHash_presult__isset;
|
|
|
|
class Pos_doTransactionOnHash_presult {
|
|
public:
|
|
|
|
|
|
virtual ~Pos_doTransactionOnHash_presult() throw() {}
|
|
|
|
int64_t* success;
|
|
|
|
_Pos_doTransactionOnHash_presult__isset __isset;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
|
|
};
|
|
|
|
typedef struct _Pos_doTransactionOnId_args__isset {
|
|
_Pos_doTransactionOnId_args__isset() : auth(false), account(false), delta(false) {}
|
|
bool auth;
|
|
bool account;
|
|
bool delta;
|
|
} _Pos_doTransactionOnId_args__isset;
|
|
|
|
class Pos_doTransactionOnId_args {
|
|
public:
|
|
|
|
Pos_doTransactionOnId_args() : auth(""), account(0), delta(0) {
|
|
}
|
|
|
|
virtual ~Pos_doTransactionOnId_args() throw() {}
|
|
|
|
std::string auth;
|
|
int32_t account;
|
|
int32_t delta;
|
|
|
|
_Pos_doTransactionOnId_args__isset __isset;
|
|
|
|
void __set_auth(const std::string& val) {
|
|
auth = val;
|
|
}
|
|
|
|
void __set_account(const int32_t val) {
|
|
account = val;
|
|
}
|
|
|
|
void __set_delta(const int32_t val) {
|
|
delta = val;
|
|
}
|
|
|
|
bool operator == (const Pos_doTransactionOnId_args & rhs) const
|
|
{
|
|
if (!(auth == rhs.auth))
|
|
return false;
|
|
if (!(account == rhs.account))
|
|
return false;
|
|
if (!(delta == rhs.delta))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const Pos_doTransactionOnId_args &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const Pos_doTransactionOnId_args & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
|
|
class Pos_doTransactionOnId_pargs {
|
|
public:
|
|
|
|
|
|
virtual ~Pos_doTransactionOnId_pargs() throw() {}
|
|
|
|
const std::string* auth;
|
|
const int32_t* account;
|
|
const int32_t* delta;
|
|
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _Pos_doTransactionOnId_result__isset {
|
|
_Pos_doTransactionOnId_result__isset() : success(false) {}
|
|
bool success;
|
|
} _Pos_doTransactionOnId_result__isset;
|
|
|
|
class Pos_doTransactionOnId_result {
|
|
public:
|
|
|
|
Pos_doTransactionOnId_result() : success(0) {
|
|
}
|
|
|
|
virtual ~Pos_doTransactionOnId_result() throw() {}
|
|
|
|
int64_t success;
|
|
|
|
_Pos_doTransactionOnId_result__isset __isset;
|
|
|
|
void __set_success(const int64_t val) {
|
|
success = val;
|
|
}
|
|
|
|
bool operator == (const Pos_doTransactionOnId_result & rhs) const
|
|
{
|
|
if (!(success == rhs.success))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const Pos_doTransactionOnId_result &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const Pos_doTransactionOnId_result & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _Pos_doTransactionOnId_presult__isset {
|
|
_Pos_doTransactionOnId_presult__isset() : success(false) {}
|
|
bool success;
|
|
} _Pos_doTransactionOnId_presult__isset;
|
|
|
|
class Pos_doTransactionOnId_presult {
|
|
public:
|
|
|
|
|
|
virtual ~Pos_doTransactionOnId_presult() throw() {}
|
|
|
|
int64_t* success;
|
|
|
|
_Pos_doTransactionOnId_presult__isset __isset;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
|
|
};
|
|
|
|
typedef struct _Pos_doTransactionOnName_args__isset {
|
|
_Pos_doTransactionOnName_args__isset() : auth(false), account(false), delta(false) {}
|
|
bool auth;
|
|
bool account;
|
|
bool delta;
|
|
} _Pos_doTransactionOnName_args__isset;
|
|
|
|
class Pos_doTransactionOnName_args {
|
|
public:
|
|
|
|
Pos_doTransactionOnName_args() : auth(""), account(""), delta(0) {
|
|
}
|
|
|
|
virtual ~Pos_doTransactionOnName_args() throw() {}
|
|
|
|
std::string auth;
|
|
std::string account;
|
|
int32_t delta;
|
|
|
|
_Pos_doTransactionOnName_args__isset __isset;
|
|
|
|
void __set_auth(const std::string& val) {
|
|
auth = val;
|
|
}
|
|
|
|
void __set_account(const std::string& val) {
|
|
account = val;
|
|
}
|
|
|
|
void __set_delta(const int32_t val) {
|
|
delta = val;
|
|
}
|
|
|
|
bool operator == (const Pos_doTransactionOnName_args & rhs) const
|
|
{
|
|
if (!(auth == rhs.auth))
|
|
return false;
|
|
if (!(account == rhs.account))
|
|
return false;
|
|
if (!(delta == rhs.delta))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const Pos_doTransactionOnName_args &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const Pos_doTransactionOnName_args & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
|
|
class Pos_doTransactionOnName_pargs {
|
|
public:
|
|
|
|
|
|
virtual ~Pos_doTransactionOnName_pargs() throw() {}
|
|
|
|
const std::string* auth;
|
|
const std::string* account;
|
|
const int32_t* delta;
|
|
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _Pos_doTransactionOnName_result__isset {
|
|
_Pos_doTransactionOnName_result__isset() : success(false) {}
|
|
bool success;
|
|
} _Pos_doTransactionOnName_result__isset;
|
|
|
|
class Pos_doTransactionOnName_result {
|
|
public:
|
|
|
|
Pos_doTransactionOnName_result() : success(0) {
|
|
}
|
|
|
|
virtual ~Pos_doTransactionOnName_result() throw() {}
|
|
|
|
int64_t success;
|
|
|
|
_Pos_doTransactionOnName_result__isset __isset;
|
|
|
|
void __set_success(const int64_t val) {
|
|
success = val;
|
|
}
|
|
|
|
bool operator == (const Pos_doTransactionOnName_result & rhs) const
|
|
{
|
|
if (!(success == rhs.success))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const Pos_doTransactionOnName_result &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const Pos_doTransactionOnName_result & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _Pos_doTransactionOnName_presult__isset {
|
|
_Pos_doTransactionOnName_presult__isset() : success(false) {}
|
|
bool success;
|
|
} _Pos_doTransactionOnName_presult__isset;
|
|
|
|
class Pos_doTransactionOnName_presult {
|
|
public:
|
|
|
|
|
|
virtual ~Pos_doTransactionOnName_presult() throw() {}
|
|
|
|
int64_t* success;
|
|
|
|
_Pos_doTransactionOnName_presult__isset __isset;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
|
|
};
|
|
|
|
typedef struct _Pos_revertTransaction_args__isset {
|
|
_Pos_revertTransaction_args__isset() : auth(false), serial(false) {}
|
|
bool auth;
|
|
bool serial;
|
|
} _Pos_revertTransaction_args__isset;
|
|
|
|
class Pos_revertTransaction_args {
|
|
public:
|
|
|
|
Pos_revertTransaction_args() : auth(""), serial(0) {
|
|
}
|
|
|
|
virtual ~Pos_revertTransaction_args() throw() {}
|
|
|
|
std::string auth;
|
|
int64_t serial;
|
|
|
|
_Pos_revertTransaction_args__isset __isset;
|
|
|
|
void __set_auth(const std::string& val) {
|
|
auth = val;
|
|
}
|
|
|
|
void __set_serial(const int64_t val) {
|
|
serial = val;
|
|
}
|
|
|
|
bool operator == (const Pos_revertTransaction_args & rhs) const
|
|
{
|
|
if (!(auth == rhs.auth))
|
|
return false;
|
|
if (!(serial == rhs.serial))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const Pos_revertTransaction_args &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const Pos_revertTransaction_args & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
|
|
class Pos_revertTransaction_pargs {
|
|
public:
|
|
|
|
|
|
virtual ~Pos_revertTransaction_pargs() throw() {}
|
|
|
|
const std::string* auth;
|
|
const int64_t* serial;
|
|
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _Pos_revertTransaction_result__isset {
|
|
_Pos_revertTransaction_result__isset() : success(false) {}
|
|
bool success;
|
|
} _Pos_revertTransaction_result__isset;
|
|
|
|
class Pos_revertTransaction_result {
|
|
public:
|
|
|
|
Pos_revertTransaction_result() : success(0) {
|
|
}
|
|
|
|
virtual ~Pos_revertTransaction_result() throw() {}
|
|
|
|
int64_t success;
|
|
|
|
_Pos_revertTransaction_result__isset __isset;
|
|
|
|
void __set_success(const int64_t val) {
|
|
success = val;
|
|
}
|
|
|
|
bool operator == (const Pos_revertTransaction_result & rhs) const
|
|
{
|
|
if (!(success == rhs.success))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const Pos_revertTransaction_result &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const Pos_revertTransaction_result & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _Pos_revertTransaction_presult__isset {
|
|
_Pos_revertTransaction_presult__isset() : success(false) {}
|
|
bool success;
|
|
} _Pos_revertTransaction_presult__isset;
|
|
|
|
class Pos_revertTransaction_presult {
|
|
public:
|
|
|
|
|
|
virtual ~Pos_revertTransaction_presult() throw() {}
|
|
|
|
int64_t* success;
|
|
|
|
_Pos_revertTransaction_presult__isset __isset;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
|
|
};
|
|
|
|
typedef struct _Pos_getStock_args__isset {
|
|
_Pos_getStock_args__isset() : upc(false) {}
|
|
bool upc;
|
|
} _Pos_getStock_args__isset;
|
|
|
|
class Pos_getStock_args {
|
|
public:
|
|
|
|
Pos_getStock_args() : upc(0) {
|
|
}
|
|
|
|
virtual ~Pos_getStock_args() throw() {}
|
|
|
|
int64_t upc;
|
|
|
|
_Pos_getStock_args__isset __isset;
|
|
|
|
bool operator == (const Pos_getStock_args & rhs) const
|
|
{
|
|
if (!(upc == rhs.upc))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const Pos_getStock_args &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const Pos_getStock_args & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
|
|
class Pos_getStock_pargs {
|
|
public:
|
|
|
|
|
|
virtual ~Pos_getStock_pargs() throw() {}
|
|
|
|
const int64_t* upc;
|
|
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _Pos_getStock_result__isset {
|
|
_Pos_getStock_result__isset() : success(false) {}
|
|
bool success;
|
|
} _Pos_getStock_result__isset;
|
|
|
|
class Pos_getStock_result {
|
|
public:
|
|
|
|
Pos_getStock_result() : success(0) {
|
|
}
|
|
|
|
virtual ~Pos_getStock_result() throw() {}
|
|
|
|
int32_t success;
|
|
|
|
_Pos_getStock_result__isset __isset;
|
|
|
|
void __set_success(const int32_t val) {
|
|
success = val;
|
|
}
|
|
|
|
bool operator == (const Pos_getStock_result & rhs) const
|
|
{
|
|
if (!(success == rhs.success))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const Pos_getStock_result &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const Pos_getStock_result & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _Pos_getStock_presult__isset {
|
|
_Pos_getStock_presult__isset() : success(false) {}
|
|
bool success;
|
|
} _Pos_getStock_presult__isset;
|
|
|
|
class Pos_getStock_presult {
|
|
public:
|
|
|
|
|
|
virtual ~Pos_getStock_presult() throw() {}
|
|
|
|
int32_t* success;
|
|
|
|
_Pos_getStock_presult__isset __isset;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
|
|
};
|
|
|
|
typedef struct _Pos_doStockChange_args__isset {
|
|
_Pos_doStockChange_args__isset() : auth(false), upc(false), delta(false) {}
|
|
bool auth;
|
|
bool upc;
|
|
bool delta;
|
|
} _Pos_doStockChange_args__isset;
|
|
|
|
class Pos_doStockChange_args {
|
|
public:
|
|
|
|
Pos_doStockChange_args() : auth(""), upc(0), delta(0) {
|
|
}
|
|
|
|
virtual ~Pos_doStockChange_args() throw() {}
|
|
|
|
std::string auth;
|
|
int64_t upc;
|
|
int32_t delta;
|
|
|
|
_Pos_doStockChange_args__isset __isset;
|
|
|
|
void __set_auth(const std::string& val) {
|
|
auth = val;
|
|
}
|
|
|
|
void __set_delta(const int32_t val) {
|
|
delta = val;
|
|
}
|
|
|
|
bool operator == (const Pos_doStockChange_args & rhs) const
|
|
{
|
|
if (!(auth == rhs.auth))
|
|
return false;
|
|
if (!(upc == rhs.upc))
|
|
return false;
|
|
if (!(delta == rhs.delta))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const Pos_doStockChange_args &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const Pos_doStockChange_args & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
|
|
class Pos_doStockChange_pargs {
|
|
public:
|
|
|
|
|
|
virtual ~Pos_doStockChange_pargs() throw() {}
|
|
|
|
const std::string* auth;
|
|
const int64_t* upc;
|
|
const int32_t* delta;
|
|
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _Pos_doStockChange_result__isset {
|
|
_Pos_doStockChange_result__isset() : success(false) {}
|
|
bool success;
|
|
} _Pos_doStockChange_result__isset;
|
|
|
|
class Pos_doStockChange_result {
|
|
public:
|
|
|
|
Pos_doStockChange_result() : success(0) {
|
|
}
|
|
|
|
virtual ~Pos_doStockChange_result() throw() {}
|
|
|
|
int64_t success;
|
|
|
|
_Pos_doStockChange_result__isset __isset;
|
|
|
|
void __set_success(const int64_t val) {
|
|
success = val;
|
|
}
|
|
|
|
bool operator == (const Pos_doStockChange_result & rhs) const
|
|
{
|
|
if (!(success == rhs.success))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const Pos_doStockChange_result &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const Pos_doStockChange_result & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _Pos_doStockChange_presult__isset {
|
|
_Pos_doStockChange_presult__isset() : success(false) {}
|
|
bool success;
|
|
} _Pos_doStockChange_presult__isset;
|
|
|
|
class Pos_doStockChange_presult {
|
|
public:
|
|
|
|
|
|
virtual ~Pos_doStockChange_presult() throw() {}
|
|
|
|
int64_t* success;
|
|
|
|
_Pos_doStockChange_presult__isset __isset;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
|
|
};
|
|
|
|
|
|
class Pos_toString_args {
|
|
public:
|
|
|
|
Pos_toString_args() {
|
|
}
|
|
|
|
virtual ~Pos_toString_args() throw() {}
|
|
|
|
|
|
bool operator == (const Pos_toString_args & /* rhs */) const
|
|
{
|
|
return true;
|
|
}
|
|
bool operator != (const Pos_toString_args &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const Pos_toString_args & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
|
|
class Pos_toString_pargs {
|
|
public:
|
|
|
|
|
|
virtual ~Pos_toString_pargs() throw() {}
|
|
|
|
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _Pos_toString_result__isset {
|
|
_Pos_toString_result__isset() : success(false) {}
|
|
bool success;
|
|
} _Pos_toString_result__isset;
|
|
|
|
class Pos_toString_result {
|
|
public:
|
|
|
|
Pos_toString_result() {
|
|
}
|
|
|
|
virtual ~Pos_toString_result() throw() {}
|
|
|
|
std::vector<std::string> success;
|
|
|
|
_Pos_toString_result__isset __isset;
|
|
|
|
void __set_success(const std::vector<std::string> & val) {
|
|
success = val;
|
|
}
|
|
|
|
bool operator == (const Pos_toString_result & rhs) const
|
|
{
|
|
if (!(success == rhs.success))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const Pos_toString_result &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const Pos_toString_result & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _Pos_toString_presult__isset {
|
|
_Pos_toString_presult__isset() : success(false) {}
|
|
bool success;
|
|
} _Pos_toString_presult__isset;
|
|
|
|
class Pos_toString_presult {
|
|
public:
|
|
|
|
|
|
virtual ~Pos_toString_presult() throw() {}
|
|
|
|
std::vector<std::string> * success;
|
|
|
|
_Pos_toString_presult__isset __isset;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
|
|
};
|
|
|
|
class PosClient : virtual public PosIf {
|
|
public:
|
|
PosClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) :
|
|
piprot_(prot),
|
|
poprot_(prot) {
|
|
iprot_ = prot.get();
|
|
oprot_ = prot.get();
|
|
}
|
|
PosClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, boost::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) :
|
|
piprot_(iprot),
|
|
poprot_(oprot) {
|
|
iprot_ = iprot.get();
|
|
oprot_ = oprot.get();
|
|
}
|
|
boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() {
|
|
return piprot_;
|
|
}
|
|
boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() {
|
|
return poprot_;
|
|
}
|
|
void ping();
|
|
void send_ping();
|
|
void recv_ping();
|
|
void getSalt(std::string& _return);
|
|
void send_getSalt();
|
|
void recv_getSalt(std::string& _return);
|
|
int32_t getAccountFromHash(const std::string& dataToHash);
|
|
void send_getAccountFromHash(const std::string& dataToHash);
|
|
int32_t recv_getAccountFromHash();
|
|
void getHashesFromAccountId(std::vector<std::string> & _return, const int32_t account);
|
|
void send_getHashesFromAccountId(const int32_t account);
|
|
void recv_getHashesFromAccountId(std::vector<std::string> & _return);
|
|
void getHashesFromAccountName(std::vector<std::string> & _return, const std::string& account);
|
|
void send_getHashesFromAccountName(const std::string& account);
|
|
void recv_getHashesFromAccountName(std::vector<std::string> & _return);
|
|
int32_t getHashAccountBalance(const std::string& dataToHash);
|
|
void send_getHashAccountBalance(const std::string& dataToHash);
|
|
int32_t recv_getHashAccountBalance();
|
|
int32_t getIdAccountBalance(const int32_t account);
|
|
void send_getIdAccountBalance(const int32_t account);
|
|
int32_t recv_getIdAccountBalance();
|
|
int32_t getNameAccountBalance(const std::string& account);
|
|
void send_getNameAccountBalance(const std::string& account);
|
|
int32_t recv_getNameAccountBalance();
|
|
int64_t associateHashWithId(const std::string& auth, const std::string& dataToHash, const int32_t account);
|
|
void send_associateHashWithId(const std::string& auth, const std::string& dataToHash, const int32_t account);
|
|
int64_t recv_associateHashWithId();
|
|
int64_t associateHashWithName(const std::string& auth, const std::string& dataToHash, const std::string& account);
|
|
void send_associateHashWithName(const std::string& auth, const std::string& dataToHash, const std::string& account);
|
|
int64_t recv_associateHashWithName();
|
|
int64_t deassociateHash(const std::string& auth, const std::string& dataToHash);
|
|
void send_deassociateHash(const std::string& auth, const std::string& dataToHash);
|
|
int64_t recv_deassociateHash();
|
|
int32_t getUPCPrice(const int64_t upc);
|
|
void send_getUPCPrice(const int64_t upc);
|
|
int32_t recv_getUPCPrice();
|
|
int64_t setUPCPrice(const std::string& auth, const int64_t upc, const int32_t price);
|
|
void send_setUPCPrice(const std::string& auth, const int64_t upc, const int32_t price);
|
|
int64_t recv_setUPCPrice();
|
|
int64_t doTransactionOnHash(const std::string& auth, const std::string& dataToHash, const int32_t delta);
|
|
void send_doTransactionOnHash(const std::string& auth, const std::string& dataToHash, const int32_t delta);
|
|
int64_t recv_doTransactionOnHash();
|
|
int64_t doTransactionOnId(const std::string& auth, const int32_t account, const int32_t delta);
|
|
void send_doTransactionOnId(const std::string& auth, const int32_t account, const int32_t delta);
|
|
int64_t recv_doTransactionOnId();
|
|
int64_t doTransactionOnName(const std::string& auth, const std::string& account, const int32_t delta);
|
|
void send_doTransactionOnName(const std::string& auth, const std::string& account, const int32_t delta);
|
|
int64_t recv_doTransactionOnName();
|
|
int64_t revertTransaction(const std::string& auth, const int64_t serial);
|
|
void send_revertTransaction(const std::string& auth, const int64_t serial);
|
|
int64_t recv_revertTransaction();
|
|
int32_t getStock(const int64_t upc);
|
|
void send_getStock(const int64_t upc);
|
|
int32_t recv_getStock();
|
|
int64_t doStockChange(const std::string& auth, const int64_t upc, const int32_t delta);
|
|
void send_doStockChange(const std::string& auth, const int64_t upc, const int32_t delta);
|
|
int64_t recv_doStockChange();
|
|
void toString(std::vector<std::string> & _return);
|
|
void send_toString();
|
|
void recv_toString(std::vector<std::string> & _return);
|
|
protected:
|
|
boost::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_;
|
|
boost::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_;
|
|
::apache::thrift::protocol::TProtocol* iprot_;
|
|
::apache::thrift::protocol::TProtocol* oprot_;
|
|
};
|
|
|
|
class PosProcessor : virtual public ::apache::thrift::TProcessor {
|
|
protected:
|
|
boost::shared_ptr<PosIf> iface_;
|
|
virtual bool process_fn(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, std::string& fname, int32_t seqid, void* callContext);
|
|
private:
|
|
std::map<std::string, void (PosProcessor::*)(int32_t, ::apache::thrift::protocol::TProtocol*, ::apache::thrift::protocol::TProtocol*, void*)> processMap_;
|
|
void process_ping(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
|
|
void process_getSalt(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
|
|
void process_getAccountFromHash(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
|
|
void process_getHashesFromAccountId(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
|
|
void process_getHashesFromAccountName(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
|
|
void process_getHashAccountBalance(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
|
|
void process_getIdAccountBalance(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
|
|
void process_getNameAccountBalance(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
|
|
void process_associateHashWithId(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
|
|
void process_associateHashWithName(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
|
|
void process_deassociateHash(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
|
|
void process_getUPCPrice(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
|
|
void process_setUPCPrice(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
|
|
void process_doTransactionOnHash(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
|
|
void process_doTransactionOnId(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
|
|
void process_doTransactionOnName(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
|
|
void process_revertTransaction(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
|
|
void process_getStock(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
|
|
void process_doStockChange(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
|
|
void process_toString(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
|
|
public:
|
|
PosProcessor(boost::shared_ptr<PosIf> iface) :
|
|
iface_(iface) {
|
|
processMap_["ping"] = &PosProcessor::process_ping;
|
|
processMap_["getSalt"] = &PosProcessor::process_getSalt;
|
|
processMap_["getAccountFromHash"] = &PosProcessor::process_getAccountFromHash;
|
|
processMap_["getHashesFromAccountId"] = &PosProcessor::process_getHashesFromAccountId;
|
|
processMap_["getHashesFromAccountName"] = &PosProcessor::process_getHashesFromAccountName;
|
|
processMap_["getHashAccountBalance"] = &PosProcessor::process_getHashAccountBalance;
|
|
processMap_["getIdAccountBalance"] = &PosProcessor::process_getIdAccountBalance;
|
|
processMap_["getNameAccountBalance"] = &PosProcessor::process_getNameAccountBalance;
|
|
processMap_["associateHashWithId"] = &PosProcessor::process_associateHashWithId;
|
|
processMap_["associateHashWithName"] = &PosProcessor::process_associateHashWithName;
|
|
processMap_["deassociateHash"] = &PosProcessor::process_deassociateHash;
|
|
processMap_["getUPCPrice"] = &PosProcessor::process_getUPCPrice;
|
|
processMap_["setUPCPrice"] = &PosProcessor::process_setUPCPrice;
|
|
processMap_["doTransactionOnHash"] = &PosProcessor::process_doTransactionOnHash;
|
|
processMap_["doTransactionOnId"] = &PosProcessor::process_doTransactionOnId;
|
|
processMap_["doTransactionOnName"] = &PosProcessor::process_doTransactionOnName;
|
|
processMap_["revertTransaction"] = &PosProcessor::process_revertTransaction;
|
|
processMap_["getStock"] = &PosProcessor::process_getStock;
|
|
processMap_["doStockChange"] = &PosProcessor::process_doStockChange;
|
|
processMap_["toString"] = &PosProcessor::process_toString;
|
|
}
|
|
|
|
virtual bool process(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot, void* callContext);
|
|
virtual ~PosProcessor() {}
|
|
};
|
|
|
|
class PosMultiface : virtual public PosIf {
|
|
public:
|
|
PosMultiface(std::vector<boost::shared_ptr<PosIf> >& ifaces) : ifaces_(ifaces) {
|
|
}
|
|
virtual ~PosMultiface() {}
|
|
protected:
|
|
std::vector<boost::shared_ptr<PosIf> > ifaces_;
|
|
PosMultiface() {}
|
|
void add(boost::shared_ptr<PosIf> iface) {
|
|
ifaces_.push_back(iface);
|
|
}
|
|
public:
|
|
void ping() {
|
|
size_t sz = ifaces_.size();
|
|
for (size_t i = 0; i < sz; ++i) {
|
|
ifaces_[i]->ping();
|
|
}
|
|
}
|
|
|
|
void getSalt(std::string& _return) {
|
|
size_t sz = ifaces_.size();
|
|
for (size_t i = 0; i < sz; ++i) {
|
|
if (i == sz - 1) {
|
|
ifaces_[i]->getSalt(_return);
|
|
return;
|
|
} else {
|
|
ifaces_[i]->getSalt(_return);
|
|
}
|
|
}
|
|
}
|
|
|
|
int32_t getAccountFromHash(const std::string& dataToHash) {
|
|
size_t sz = ifaces_.size();
|
|
for (size_t i = 0; i < sz; ++i) {
|
|
if (i == sz - 1) {
|
|
return ifaces_[i]->getAccountFromHash(dataToHash);
|
|
} else {
|
|
ifaces_[i]->getAccountFromHash(dataToHash);
|
|
}
|
|
}
|
|
}
|
|
|
|
void getHashesFromAccountId(std::vector<std::string> & _return, const int32_t account) {
|
|
size_t sz = ifaces_.size();
|
|
for (size_t i = 0; i < sz; ++i) {
|
|
if (i == sz - 1) {
|
|
ifaces_[i]->getHashesFromAccountId(_return, account);
|
|
return;
|
|
} else {
|
|
ifaces_[i]->getHashesFromAccountId(_return, account);
|
|
}
|
|
}
|
|
}
|
|
|
|
void getHashesFromAccountName(std::vector<std::string> & _return, const std::string& account) {
|
|
size_t sz = ifaces_.size();
|
|
for (size_t i = 0; i < sz; ++i) {
|
|
if (i == sz - 1) {
|
|
ifaces_[i]->getHashesFromAccountName(_return, account);
|
|
return;
|
|
} else {
|
|
ifaces_[i]->getHashesFromAccountName(_return, account);
|
|
}
|
|
}
|
|
}
|
|
|
|
int32_t getHashAccountBalance(const std::string& dataToHash) {
|
|
size_t sz = ifaces_.size();
|
|
for (size_t i = 0; i < sz; ++i) {
|
|
if (i == sz - 1) {
|
|
return ifaces_[i]->getHashAccountBalance(dataToHash);
|
|
} else {
|
|
ifaces_[i]->getHashAccountBalance(dataToHash);
|
|
}
|
|
}
|
|
}
|
|
|
|
int32_t getIdAccountBalance(const int32_t account) {
|
|
size_t sz = ifaces_.size();
|
|
for (size_t i = 0; i < sz; ++i) {
|
|
if (i == sz - 1) {
|
|
return ifaces_[i]->getIdAccountBalance(account);
|
|
} else {
|
|
ifaces_[i]->getIdAccountBalance(account);
|
|
}
|
|
}
|
|
}
|
|
|
|
int32_t getNameAccountBalance(const std::string& account) {
|
|
size_t sz = ifaces_.size();
|
|
for (size_t i = 0; i < sz; ++i) {
|
|
if (i == sz - 1) {
|
|
return ifaces_[i]->getNameAccountBalance(account);
|
|
} else {
|
|
ifaces_[i]->getNameAccountBalance(account);
|
|
}
|
|
}
|
|
}
|
|
|
|
int64_t associateHashWithId(const std::string& auth, const std::string& dataToHash, const int32_t account) {
|
|
size_t sz = ifaces_.size();
|
|
for (size_t i = 0; i < sz; ++i) {
|
|
if (i == sz - 1) {
|
|
return ifaces_[i]->associateHashWithId(auth, dataToHash, account);
|
|
} else {
|
|
ifaces_[i]->associateHashWithId(auth, dataToHash, account);
|
|
}
|
|
}
|
|
}
|
|
|
|
int64_t associateHashWithName(const std::string& auth, const std::string& dataToHash, const std::string& account) {
|
|
size_t sz = ifaces_.size();
|
|
for (size_t i = 0; i < sz; ++i) {
|
|
if (i == sz - 1) {
|
|
return ifaces_[i]->associateHashWithName(auth, dataToHash, account);
|
|
} else {
|
|
ifaces_[i]->associateHashWithName(auth, dataToHash, account);
|
|
}
|
|
}
|
|
}
|
|
|
|
int64_t deassociateHash(const std::string& auth, const std::string& dataToHash) {
|
|
size_t sz = ifaces_.size();
|
|
for (size_t i = 0; i < sz; ++i) {
|
|
if (i == sz - 1) {
|
|
return ifaces_[i]->deassociateHash(auth, dataToHash);
|
|
} else {
|
|
ifaces_[i]->deassociateHash(auth, dataToHash);
|
|
}
|
|
}
|
|
}
|
|
|
|
int32_t getUPCPrice(const int64_t upc) {
|
|
size_t sz = ifaces_.size();
|
|
for (size_t i = 0; i < sz; ++i) {
|
|
if (i == sz - 1) {
|
|
return ifaces_[i]->getUPCPrice(upc);
|
|
} else {
|
|
ifaces_[i]->getUPCPrice(upc);
|
|
}
|
|
}
|
|
}
|
|
|
|
int64_t setUPCPrice(const std::string& auth, const int64_t upc, const int32_t price) {
|
|
size_t sz = ifaces_.size();
|
|
for (size_t i = 0; i < sz; ++i) {
|
|
if (i == sz - 1) {
|
|
return ifaces_[i]->setUPCPrice(auth, upc, price);
|
|
} else {
|
|
ifaces_[i]->setUPCPrice(auth, upc, price);
|
|
}
|
|
}
|
|
}
|
|
|
|
int64_t doTransactionOnHash(const std::string& auth, const std::string& dataToHash, const int32_t delta) {
|
|
size_t sz = ifaces_.size();
|
|
for (size_t i = 0; i < sz; ++i) {
|
|
if (i == sz - 1) {
|
|
return ifaces_[i]->doTransactionOnHash(auth, dataToHash, delta);
|
|
} else {
|
|
ifaces_[i]->doTransactionOnHash(auth, dataToHash, delta);
|
|
}
|
|
}
|
|
}
|
|
|
|
int64_t doTransactionOnId(const std::string& auth, const int32_t account, const int32_t delta) {
|
|
size_t sz = ifaces_.size();
|
|
for (size_t i = 0; i < sz; ++i) {
|
|
if (i == sz - 1) {
|
|
return ifaces_[i]->doTransactionOnId(auth, account, delta);
|
|
} else {
|
|
ifaces_[i]->doTransactionOnId(auth, account, delta);
|
|
}
|
|
}
|
|
}
|
|
|
|
int64_t doTransactionOnName(const std::string& auth, const std::string& account, const int32_t delta) {
|
|
size_t sz = ifaces_.size();
|
|
for (size_t i = 0; i < sz; ++i) {
|
|
if (i == sz - 1) {
|
|
return ifaces_[i]->doTransactionOnName(auth, account, delta);
|
|
} else {
|
|
ifaces_[i]->doTransactionOnName(auth, account, delta);
|
|
}
|
|
}
|
|
}
|
|
|
|
int64_t revertTransaction(const std::string& auth, const int64_t serial) {
|
|
size_t sz = ifaces_.size();
|
|
for (size_t i = 0; i < sz; ++i) {
|
|
if (i == sz - 1) {
|
|
return ifaces_[i]->revertTransaction(auth, serial);
|
|
} else {
|
|
ifaces_[i]->revertTransaction(auth, serial);
|
|
}
|
|
}
|
|
}
|
|
|
|
int32_t getStock(const int64_t upc) {
|
|
size_t sz = ifaces_.size();
|
|
for (size_t i = 0; i < sz; ++i) {
|
|
if (i == sz - 1) {
|
|
return ifaces_[i]->getStock(upc);
|
|
} else {
|
|
ifaces_[i]->getStock(upc);
|
|
}
|
|
}
|
|
}
|
|
|
|
int64_t doStockChange(const std::string& auth, const int64_t upc, const int32_t delta) {
|
|
size_t sz = ifaces_.size();
|
|
for (size_t i = 0; i < sz; ++i) {
|
|
if (i == sz - 1) {
|
|
return ifaces_[i]->doStockChange(auth, upc, delta);
|
|
} else {
|
|
ifaces_[i]->doStockChange(auth, upc, delta);
|
|
}
|
|
}
|
|
}
|
|
|
|
void toString(std::vector<std::string> & _return) {
|
|
size_t sz = ifaces_.size();
|
|
for (size_t i = 0; i < sz; ++i) {
|
|
if (i == sz - 1) {
|
|
ifaces_[i]->toString(_return);
|
|
return;
|
|
} else {
|
|
ifaces_[i]->toString(_return);
|
|
}
|
|
}
|
|
}
|
|
|
|
};
|
|
|
|
} // namespace
|
|
|
|
#endif
|