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