--- /dev/null
+/**
+ * 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
projects / ceph.git / blobdiff