/**
 * 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_high, const int64_t upc_low) = 0;
  virtual int64_t setUPCPrice(const std::string& auth, const int64_t upc_high, const int64_t upc_low, 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_high, const int64_t upc_low) = 0;
  virtual int64_t doStockChange(const std::string& auth, const int64_t upc_high, const int64_t upc_low, 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_high */, const int64_t /* upc_low */) {
    int32_t _return = 0;
    return _return;
  }
  int64_t setUPCPrice(const std::string& /* auth */, const int64_t /* upc_high */, const int64_t /* upc_low */, 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_high */, const int64_t /* upc_low */) {
    int32_t _return = 0;
    return _return;
  }
  int64_t doStockChange(const std::string& /* auth */, const int64_t /* upc_high */, const int64_t /* upc_low */, 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_high(false), upc_low(false) {}
  bool upc_high;
  bool upc_low;
} _Pos_getUPCPrice_args__isset;

class Pos_getUPCPrice_args {
 public:

  Pos_getUPCPrice_args() : upc_high(0), upc_low(0) {
  }

  virtual ~Pos_getUPCPrice_args() throw() {}

  int64_t upc_high;
  int64_t upc_low;

  _Pos_getUPCPrice_args__isset __isset;

  void __set_upc_high(const int64_t val) {
    upc_high = val;
  }

  void __set_upc_low(const int64_t val) {
    upc_low = val;
  }

  bool operator == (const Pos_getUPCPrice_args & rhs) const
  {
    if (!(upc_high == rhs.upc_high))
      return false;
    if (!(upc_low == rhs.upc_low))
      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_high;
  const int64_t* upc_low;

  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_high(false), upc_low(false), price(false) {}
  bool auth;
  bool upc_high;
  bool upc_low;
  bool price;
} _Pos_setUPCPrice_args__isset;

class Pos_setUPCPrice_args {
 public:

  Pos_setUPCPrice_args() : auth(""), upc_high(0), upc_low(0), price(0) {
  }

  virtual ~Pos_setUPCPrice_args() throw() {}

  std::string auth;
  int64_t upc_high;
  int64_t upc_low;
  int32_t price;

  _Pos_setUPCPrice_args__isset __isset;

  void __set_auth(const std::string& val) {
    auth = val;
  }

  void __set_upc_high(const int64_t val) {
    upc_high = val;
  }

  void __set_upc_low(const int64_t val) {
    upc_low = 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_high == rhs.upc_high))
      return false;
    if (!(upc_low == rhs.upc_low))
      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_high;
  const int64_t* upc_low;
  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_high(false), upc_low(false) {}
  bool upc_high;
  bool upc_low;
} _Pos_getStock_args__isset;

class Pos_getStock_args {
 public:

  Pos_getStock_args() : upc_high(0), upc_low(0) {
  }

  virtual ~Pos_getStock_args() throw() {}

  int64_t upc_high;
  int64_t upc_low;

  _Pos_getStock_args__isset __isset;

  void __set_upc_high(const int64_t val) {
    upc_high = val;
  }

  void __set_upc_low(const int64_t val) {
    upc_low = val;
  }

  bool operator == (const Pos_getStock_args & rhs) const
  {
    if (!(upc_high == rhs.upc_high))
      return false;
    if (!(upc_low == rhs.upc_low))
      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_high;
  const int64_t* upc_low;

  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_high(false), upc_low(false), delta(false) {}
  bool auth;
  bool upc_high;
  bool upc_low;
  bool delta;
} _Pos_doStockChange_args__isset;

class Pos_doStockChange_args {
 public:

  Pos_doStockChange_args() : auth(""), upc_high(0), upc_low(0), delta(0) {
  }

  virtual ~Pos_doStockChange_args() throw() {}

  std::string auth;
  int64_t upc_high;
  int64_t upc_low;
  int32_t delta;

  _Pos_doStockChange_args__isset __isset;

  void __set_auth(const std::string& val) {
    auth = val;
  }

  void __set_upc_high(const int64_t val) {
    upc_high = val;
  }

  void __set_upc_low(const int64_t val) {
    upc_low = 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_high == rhs.upc_high))
      return false;
    if (!(upc_low == rhs.upc_low))
      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_high;
  const int64_t* upc_low;
  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_high, const int64_t upc_low);
  void send_getUPCPrice(const int64_t upc_high, const int64_t upc_low);
  int32_t recv_getUPCPrice();
  int64_t setUPCPrice(const std::string& auth, const int64_t upc_high, const int64_t upc_low, const int32_t price);
  void send_setUPCPrice(const std::string& auth, const int64_t upc_high, const int64_t upc_low, 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_high, const int64_t upc_low);
  void send_getStock(const int64_t upc_high, const int64_t upc_low);
  int32_t recv_getStock();
  int64_t doStockChange(const std::string& auth, const int64_t upc_high, const int64_t upc_low, const int32_t delta);
  void send_doStockChange(const std::string& auth, const int64_t upc_high, const int64_t upc_low, 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_high, const int64_t upc_low) {
    size_t sz = ifaces_.size();
    for (size_t i = 0; i < sz; ++i) {
      if (i == sz - 1) {
        return ifaces_[i]->getUPCPrice(upc_high, upc_low);
      } else {
        ifaces_[i]->getUPCPrice(upc_high, upc_low);
      }
    }
  }

  int64_t setUPCPrice(const std::string& auth, const int64_t upc_high, const int64_t upc_low, 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_high, upc_low, price);
      } else {
        ifaces_[i]->setUPCPrice(auth, upc_high, upc_low, 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_high, const int64_t upc_low) {
    size_t sz = ifaces_.size();
    for (size_t i = 0; i < sz; ++i) {
      if (i == sz - 1) {
        return ifaces_[i]->getStock(upc_high, upc_low);
      } else {
        ifaces_[i]->getStock(upc_high, upc_low);
      }
    }
  }

  int64_t doStockChange(const std::string& auth, const int64_t upc_high, const int64_t upc_low, 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_high, upc_low, delta);
      } else {
        ifaces_[i]->doStockChange(auth, upc_high, upc_low, 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
