buildsys: switch source download to quincy

[ceph.git] / ceph / src / jaegertracing / jaeger-client-cpp / src / jaegertracing / thrift-gen / sampling_types.h

/**
 * Autogenerated by Thrift Compiler (0.11.0)
 *
 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 *  @generated
 */
#ifndef sampling_TYPES_H
#define sampling_TYPES_H

#include <iosfwd>

#include <thrift/Thrift.h>
#include <thrift/TApplicationException.h>
#include <thrift/TBase.h>
#include <thrift/protocol/TProtocol.h>
#include <thrift/transport/TTransport.h>




namespace jaegertracing { namespace sampling_manager { namespace thrift {

struct SamplingStrategyType {
  enum type {
    PROBABILISTIC = 0,
    RATE_LIMITING = 1
  };
};

extern const std::map<int, const char*> _SamplingStrategyType_VALUES_TO_NAMES;

std::ostream& operator<<(std::ostream& out, const SamplingStrategyType::type& val);

class ProbabilisticSamplingStrategy;

class RateLimitingSamplingStrategy;

class OperationSamplingStrategy;

class PerOperationSamplingStrategies;

class SamplingStrategyResponse;


class ProbabilisticSamplingStrategy : public virtual ::apache::thrift::TBase {
 public:

  ProbabilisticSamplingStrategy(const ProbabilisticSamplingStrategy&);
  ProbabilisticSamplingStrategy& operator=(const ProbabilisticSamplingStrategy&);
  ProbabilisticSamplingStrategy() : samplingRate(0) {
  }

  virtual ~ProbabilisticSamplingStrategy() throw();
  double samplingRate;

  void __set_samplingRate(const double val);

  bool operator == (const ProbabilisticSamplingStrategy & rhs) const
  {
    if (!(samplingRate == rhs.samplingRate))
      return false;
    return true;
  }
  bool operator != (const ProbabilisticSamplingStrategy &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ProbabilisticSamplingStrategy & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

  virtual void printTo(std::ostream& out) const;
};

void swap(ProbabilisticSamplingStrategy &a, ProbabilisticSamplingStrategy &b);

std::ostream& operator<<(std::ostream& out, const ProbabilisticSamplingStrategy& obj);


class RateLimitingSamplingStrategy : public virtual ::apache::thrift::TBase {
 public:

  RateLimitingSamplingStrategy(const RateLimitingSamplingStrategy&);
  RateLimitingSamplingStrategy& operator=(const RateLimitingSamplingStrategy&);
  RateLimitingSamplingStrategy() : maxTracesPerSecond(0) {
  }

  virtual ~RateLimitingSamplingStrategy() throw();
  int16_t maxTracesPerSecond;

  void __set_maxTracesPerSecond(const int16_t val);

  bool operator == (const RateLimitingSamplingStrategy & rhs) const
  {
    if (!(maxTracesPerSecond == rhs.maxTracesPerSecond))
      return false;
    return true;
  }
  bool operator != (const RateLimitingSamplingStrategy &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const RateLimitingSamplingStrategy & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

  virtual void printTo(std::ostream& out) const;
};

void swap(RateLimitingSamplingStrategy &a, RateLimitingSamplingStrategy &b);

std::ostream& operator<<(std::ostream& out, const RateLimitingSamplingStrategy& obj);


class OperationSamplingStrategy : public virtual ::apache::thrift::TBase {
 public:

  OperationSamplingStrategy(const OperationSamplingStrategy&);
  OperationSamplingStrategy& operator=(const OperationSamplingStrategy&);
  OperationSamplingStrategy() : operation() {
  }

  virtual ~OperationSamplingStrategy() throw();
  std::string operation;
  ProbabilisticSamplingStrategy probabilisticSampling;

  void __set_operation(const std::string& val);

  void __set_probabilisticSampling(const ProbabilisticSamplingStrategy& val);

  bool operator == (const OperationSamplingStrategy & rhs) const
  {
    if (!(operation == rhs.operation))
      return false;
    if (!(probabilisticSampling == rhs.probabilisticSampling))
      return false;
    return true;
  }
  bool operator != (const OperationSamplingStrategy &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const OperationSamplingStrategy & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

  virtual void printTo(std::ostream& out) const;
};

void swap(OperationSamplingStrategy &a, OperationSamplingStrategy &b);

std::ostream& operator<<(std::ostream& out, const OperationSamplingStrategy& obj);

typedef struct _PerOperationSamplingStrategies__isset {
  _PerOperationSamplingStrategies__isset() : defaultUpperBoundTracesPerSecond(false) {}
  bool defaultUpperBoundTracesPerSecond :1;
} _PerOperationSamplingStrategies__isset;

class PerOperationSamplingStrategies : public virtual ::apache::thrift::TBase {
 public:

  PerOperationSamplingStrategies(const PerOperationSamplingStrategies&);
  PerOperationSamplingStrategies& operator=(const PerOperationSamplingStrategies&);
  PerOperationSamplingStrategies() : defaultSamplingProbability(0), defaultLowerBoundTracesPerSecond(0), defaultUpperBoundTracesPerSecond(0) {
  }

  virtual ~PerOperationSamplingStrategies() throw();
  double defaultSamplingProbability;
  double defaultLowerBoundTracesPerSecond;
  std::vector<OperationSamplingStrategy>  perOperationStrategies;
  double defaultUpperBoundTracesPerSecond;

  _PerOperationSamplingStrategies__isset __isset;

  void __set_defaultSamplingProbability(const double val);

  void __set_defaultLowerBoundTracesPerSecond(const double val);

  void __set_perOperationStrategies(const std::vector<OperationSamplingStrategy> & val);

  void __set_defaultUpperBoundTracesPerSecond(const double val);

  bool operator == (const PerOperationSamplingStrategies & rhs) const
  {
    if (!(defaultSamplingProbability == rhs.defaultSamplingProbability))
      return false;
    if (!(defaultLowerBoundTracesPerSecond == rhs.defaultLowerBoundTracesPerSecond))
      return false;
    if (!(perOperationStrategies == rhs.perOperationStrategies))
      return false;
    if (__isset.defaultUpperBoundTracesPerSecond != rhs.__isset.defaultUpperBoundTracesPerSecond)
      return false;
    else if (__isset.defaultUpperBoundTracesPerSecond && !(defaultUpperBoundTracesPerSecond == rhs.defaultUpperBoundTracesPerSecond))
      return false;
    return true;
  }
  bool operator != (const PerOperationSamplingStrategies &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const PerOperationSamplingStrategies & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

  virtual void printTo(std::ostream& out) const;
};

void swap(PerOperationSamplingStrategies &a, PerOperationSamplingStrategies &b);

std::ostream& operator<<(std::ostream& out, const PerOperationSamplingStrategies& obj);

typedef struct _SamplingStrategyResponse__isset {
  _SamplingStrategyResponse__isset() : probabilisticSampling(false), rateLimitingSampling(false), operationSampling(false) {}
  bool probabilisticSampling :1;
  bool rateLimitingSampling :1;
  bool operationSampling :1;
} _SamplingStrategyResponse__isset;

class SamplingStrategyResponse : public virtual ::apache::thrift::TBase {
 public:

  SamplingStrategyResponse(const SamplingStrategyResponse&);
  SamplingStrategyResponse& operator=(const SamplingStrategyResponse&);
  SamplingStrategyResponse() : strategyType((SamplingStrategyType::type)0) {
  }

  virtual ~SamplingStrategyResponse() throw();
  SamplingStrategyType::type strategyType;
  ProbabilisticSamplingStrategy probabilisticSampling;
  RateLimitingSamplingStrategy rateLimitingSampling;
  PerOperationSamplingStrategies operationSampling;

  _SamplingStrategyResponse__isset __isset;

  void __set_strategyType(const SamplingStrategyType::type val);

  void __set_probabilisticSampling(const ProbabilisticSamplingStrategy& val);

  void __set_rateLimitingSampling(const RateLimitingSamplingStrategy& val);

  void __set_operationSampling(const PerOperationSamplingStrategies& val);

  bool operator == (const SamplingStrategyResponse & rhs) const
  {
    if (!(strategyType == rhs.strategyType))
      return false;
    if (__isset.probabilisticSampling != rhs.__isset.probabilisticSampling)
      return false;
    else if (__isset.probabilisticSampling && !(probabilisticSampling == rhs.probabilisticSampling))
      return false;
    if (__isset.rateLimitingSampling != rhs.__isset.rateLimitingSampling)
      return false;
    else if (__isset.rateLimitingSampling && !(rateLimitingSampling == rhs.rateLimitingSampling))
      return false;
    if (__isset.operationSampling != rhs.__isset.operationSampling)
      return false;
    else if (__isset.operationSampling && !(operationSampling == rhs.operationSampling))
      return false;
    return true;
  }
  bool operator != (const SamplingStrategyResponse &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const SamplingStrategyResponse & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

  virtual void printTo(std::ostream& out) const;
};

void swap(SamplingStrategyResponse &a, SamplingStrategyResponse &b);

std::ostream& operator<<(std::ostream& out, const SamplingStrategyResponse& obj);

}}} // namespace

#endif