diff options
Diffstat (limited to '')
-rw-r--r-- | src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/BaggageRestrictionManager.h | 304 |
1 files changed, 304 insertions, 0 deletions
diff --git a/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/BaggageRestrictionManager.h b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/BaggageRestrictionManager.h new file mode 100644 index 000000000..442dc12a5 --- /dev/null +++ b/src/jaegertracing/jaeger-client-cpp/src/jaegertracing/thrift-gen/BaggageRestrictionManager.h @@ -0,0 +1,304 @@ +/** + * Autogenerated by Thrift Compiler (0.11.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#ifndef BaggageRestrictionManager_H +#define BaggageRestrictionManager_H + +#include <thrift/TDispatchProcessor.h> +#include <thrift/async/TConcurrentClientSyncInfo.h> +#include "baggage_types.h" + +namespace jaegertracing { namespace thrift { + +#ifdef _MSC_VER + #pragma warning( push ) + #pragma warning (disable : 4250 ) //inheriting methods via dominance +#endif + +class BaggageRestrictionManagerIf { + public: + virtual ~BaggageRestrictionManagerIf() {} + + /** + * getBaggageRestrictions retrieves the baggage restrictions for a specific service. + * Usually, baggageRestrictions apply to all services however there may be situations + * where a baggageKey might only be allowed to be set by a specific service. + * + * @param serviceName + */ + virtual void getBaggageRestrictions(std::vector<BaggageRestriction> & _return, const std::string& serviceName) = 0; +}; + +class BaggageRestrictionManagerIfFactory { + public: + typedef BaggageRestrictionManagerIf Handler; + + virtual ~BaggageRestrictionManagerIfFactory() {} + + virtual BaggageRestrictionManagerIf* getHandler(const ::apache::thrift::TConnectionInfo& connInfo) = 0; + virtual void releaseHandler(BaggageRestrictionManagerIf* /* handler */) = 0; +}; + +class BaggageRestrictionManagerIfSingletonFactory : virtual public BaggageRestrictionManagerIfFactory { + public: + BaggageRestrictionManagerIfSingletonFactory(const ::std::shared_ptr<BaggageRestrictionManagerIf>& iface) : iface_(iface) {} + virtual ~BaggageRestrictionManagerIfSingletonFactory() {} + + virtual BaggageRestrictionManagerIf* getHandler(const ::apache::thrift::TConnectionInfo&) { + return iface_.get(); + } + virtual void releaseHandler(BaggageRestrictionManagerIf* /* handler */) {} + + protected: + ::std::shared_ptr<BaggageRestrictionManagerIf> iface_; +}; + +class BaggageRestrictionManagerNull : virtual public BaggageRestrictionManagerIf { + public: + virtual ~BaggageRestrictionManagerNull() {} + void getBaggageRestrictions(std::vector<BaggageRestriction> & /* _return */, const std::string& /* serviceName */) { + return; + } +}; + +typedef struct _BaggageRestrictionManager_getBaggageRestrictions_args__isset { + _BaggageRestrictionManager_getBaggageRestrictions_args__isset() : serviceName(false) {} + bool serviceName :1; +} _BaggageRestrictionManager_getBaggageRestrictions_args__isset; + +class BaggageRestrictionManager_getBaggageRestrictions_args { + public: + + BaggageRestrictionManager_getBaggageRestrictions_args(const BaggageRestrictionManager_getBaggageRestrictions_args&); + BaggageRestrictionManager_getBaggageRestrictions_args& operator=(const BaggageRestrictionManager_getBaggageRestrictions_args&); + BaggageRestrictionManager_getBaggageRestrictions_args() : serviceName() { + } + + virtual ~BaggageRestrictionManager_getBaggageRestrictions_args() throw(); + std::string serviceName; + + _BaggageRestrictionManager_getBaggageRestrictions_args__isset __isset; + + void __set_serviceName(const std::string& val); + + bool operator == (const BaggageRestrictionManager_getBaggageRestrictions_args & rhs) const + { + if (!(serviceName == rhs.serviceName)) + return false; + return true; + } + bool operator != (const BaggageRestrictionManager_getBaggageRestrictions_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const BaggageRestrictionManager_getBaggageRestrictions_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class BaggageRestrictionManager_getBaggageRestrictions_pargs { + public: + + + virtual ~BaggageRestrictionManager_getBaggageRestrictions_pargs() throw(); + const std::string* serviceName; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _BaggageRestrictionManager_getBaggageRestrictions_result__isset { + _BaggageRestrictionManager_getBaggageRestrictions_result__isset() : success(false) {} + bool success :1; +} _BaggageRestrictionManager_getBaggageRestrictions_result__isset; + +class BaggageRestrictionManager_getBaggageRestrictions_result { + public: + + BaggageRestrictionManager_getBaggageRestrictions_result(const BaggageRestrictionManager_getBaggageRestrictions_result&); + BaggageRestrictionManager_getBaggageRestrictions_result& operator=(const BaggageRestrictionManager_getBaggageRestrictions_result&); + BaggageRestrictionManager_getBaggageRestrictions_result() { + } + + virtual ~BaggageRestrictionManager_getBaggageRestrictions_result() throw(); + std::vector<BaggageRestriction> success; + + _BaggageRestrictionManager_getBaggageRestrictions_result__isset __isset; + + void __set_success(const std::vector<BaggageRestriction> & val); + + bool operator == (const BaggageRestrictionManager_getBaggageRestrictions_result & rhs) const + { + if (!(success == rhs.success)) + return false; + return true; + } + bool operator != (const BaggageRestrictionManager_getBaggageRestrictions_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const BaggageRestrictionManager_getBaggageRestrictions_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _BaggageRestrictionManager_getBaggageRestrictions_presult__isset { + _BaggageRestrictionManager_getBaggageRestrictions_presult__isset() : success(false) {} + bool success :1; +} _BaggageRestrictionManager_getBaggageRestrictions_presult__isset; + +class BaggageRestrictionManager_getBaggageRestrictions_presult { + public: + + + virtual ~BaggageRestrictionManager_getBaggageRestrictions_presult() throw(); + std::vector<BaggageRestriction> * success; + + _BaggageRestrictionManager_getBaggageRestrictions_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +class BaggageRestrictionManagerClient : virtual public BaggageRestrictionManagerIf { + public: + BaggageRestrictionManagerClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) { + setProtocol(prot); + } + BaggageRestrictionManagerClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) { + setProtocol(iprot,oprot); + } + private: + void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) { + setProtocol(prot,prot); + } + void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) { + piprot_=iprot; + poprot_=oprot; + iprot_ = iprot.get(); + oprot_ = oprot.get(); + } + public: + std::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() { + return piprot_; + } + std::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() { + return poprot_; + } + void getBaggageRestrictions(std::vector<BaggageRestriction> & _return, const std::string& serviceName); + void send_getBaggageRestrictions(const std::string& serviceName); + void recv_getBaggageRestrictions(std::vector<BaggageRestriction> & _return); + protected: + std::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_; + std::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_; + ::apache::thrift::protocol::TProtocol* iprot_; + ::apache::thrift::protocol::TProtocol* oprot_; +}; + +class BaggageRestrictionManagerProcessor : public ::apache::thrift::TDispatchProcessor { + protected: + ::std::shared_ptr<BaggageRestrictionManagerIf> iface_; + virtual bool dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext); + private: + typedef void (BaggageRestrictionManagerProcessor::*ProcessFunction)(int32_t, ::apache::thrift::protocol::TProtocol*, ::apache::thrift::protocol::TProtocol*, void*); + typedef std::map<std::string, ProcessFunction> ProcessMap; + ProcessMap processMap_; + void process_getBaggageRestrictions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + public: + BaggageRestrictionManagerProcessor(::std::shared_ptr<BaggageRestrictionManagerIf> iface) : + iface_(iface) { + processMap_["getBaggageRestrictions"] = &BaggageRestrictionManagerProcessor::process_getBaggageRestrictions; + } + + virtual ~BaggageRestrictionManagerProcessor() {} +}; + +class BaggageRestrictionManagerProcessorFactory : public ::apache::thrift::TProcessorFactory { + public: + BaggageRestrictionManagerProcessorFactory(const ::std::shared_ptr< BaggageRestrictionManagerIfFactory >& handlerFactory) : + handlerFactory_(handlerFactory) {} + + ::std::shared_ptr< ::apache::thrift::TProcessor > getProcessor(const ::apache::thrift::TConnectionInfo& connInfo); + + protected: + ::std::shared_ptr< BaggageRestrictionManagerIfFactory > handlerFactory_; +}; + +class BaggageRestrictionManagerMultiface : virtual public BaggageRestrictionManagerIf { + public: + BaggageRestrictionManagerMultiface(std::vector<std::shared_ptr<BaggageRestrictionManagerIf> >& ifaces) : ifaces_(ifaces) { + } + virtual ~BaggageRestrictionManagerMultiface() {} + protected: + std::vector<std::shared_ptr<BaggageRestrictionManagerIf> > ifaces_; + BaggageRestrictionManagerMultiface() {} + void add(::std::shared_ptr<BaggageRestrictionManagerIf> iface) { + ifaces_.push_back(iface); + } + public: + void getBaggageRestrictions(std::vector<BaggageRestriction> & _return, const std::string& serviceName) { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->getBaggageRestrictions(_return, serviceName); + } + ifaces_[i]->getBaggageRestrictions(_return, serviceName); + return; + } + +}; + +// The 'concurrent' client is a thread safe client that correctly handles +// out of order responses. It is slower than the regular client, so should +// only be used when you need to share a connection among multiple threads +class BaggageRestrictionManagerConcurrentClient : virtual public BaggageRestrictionManagerIf { + public: + BaggageRestrictionManagerConcurrentClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) { + setProtocol(prot); + } + BaggageRestrictionManagerConcurrentClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) { + setProtocol(iprot,oprot); + } + private: + void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) { + setProtocol(prot,prot); + } + void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) { + piprot_=iprot; + poprot_=oprot; + iprot_ = iprot.get(); + oprot_ = oprot.get(); + } + public: + std::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() { + return piprot_; + } + std::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() { + return poprot_; + } + void getBaggageRestrictions(std::vector<BaggageRestriction> & _return, const std::string& serviceName); + int32_t send_getBaggageRestrictions(const std::string& serviceName); + void recv_getBaggageRestrictions(std::vector<BaggageRestriction> & _return, const int32_t seqid); + protected: + std::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_; + std::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_; + ::apache::thrift::protocol::TProtocol* iprot_; + ::apache::thrift::protocol::TProtocol* oprot_; + ::apache::thrift::async::TConcurrentClientSyncInfo sync_; +}; + +#ifdef _MSC_VER + #pragma warning( pop ) +#endif + +}} // namespace + +#endif |