/**
 * Autogenerated by Thrift Compiler (0.22.0)
 *
 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 *  @generated
 */
#ifndef gnuradio_TYPES_H
#define gnuradio_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>

#include <functional>
#include <memory>


namespace GNURadio {

struct BaseTypes {
  enum type {
    BOOL = 0,
    BYTE = 1,
    SHORT = 2,
    INT = 3,
    LONG = 4,
    DOUBLE = 5,
    STRING = 6,
    COMPLEX = 7,
    F32VECTOR = 8,
    F64VECTOR = 9,
    S64VECTOR = 10,
    S32VECTOR = 11,
    S16VECTOR = 12,
    S8VECTOR = 13,
    C32VECTOR = 14
  };
};

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

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

std::string to_string(const BaseTypes::type& val);

struct KnobType {
  enum type {
    KNOBBOOL = 0,
    KNOBCHAR = 1,
    KNOBINT = 2,
    KNOBDOUBLE = 3,
    KNOBSTRING = 4,
    KNOBLONG = 5,
    KNOBVECBOOL = 6,
    KNOBVECCHAR = 7,
    KNOBVECINT = 8,
    KNOBVECDOUBLE = 9,
    KNOBVECSTRING = 10,
    KNOBVECLONG = 11,
    KNOBSHORT = 12
  };
};

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

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

std::string to_string(const KnobType::type& val);

typedef std::vector<bool>  VectorB;

typedef std::string VectorC;

typedef std::vector<int16_t>  VectorT;

typedef std::vector<int32_t>  VectorI;

typedef std::vector<int64_t>  VectorL;

typedef std::vector<double>  VectorF;

typedef std::vector<double>  VectorD;

typedef std::vector<std::string>  VectorS;

typedef std::vector<class complex>  VectorZ;

typedef std::vector<std::string>  KnobIDList;

typedef std::map<std::string, class Knob>  KnobMap;

typedef std::map<std::string, class KnobProp>  KnobPropMap;

typedef std::map<std::string, std::string>  WaveformArgMap;

class complex;

class KnobBase;

class Knob;

class KnobProp;

typedef struct _complex__isset {
  _complex__isset() : re(false), im(false) {}
  bool re :1;
  bool im :1;
} _complex__isset;

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

  complex(const complex&) noexcept;
  complex& operator=(const complex&) noexcept;
  complex() noexcept;

  virtual ~complex() noexcept;
  double re;
  double im;

  _complex__isset __isset;

  void __set_re(const double val);

  void __set_im(const double val);

  bool operator == (const complex & rhs) const;
  bool operator != (const complex &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const complex & ) const;

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

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

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

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

typedef struct _KnobBase__isset {
  _KnobBase__isset() : a_bool(false), a_byte(false), a_short(false), a_int(false), a_long(false), a_double(false), a_string(false), a_complex(false), a_f32vector(false), a_f64vector(false), a_s64vector(false), a_s32vector(false), a_s16vector(false), a_s8vector(false), a_c32vector(false) {}
  bool a_bool :1;
  bool a_byte :1;
  bool a_short :1;
  bool a_int :1;
  bool a_long :1;
  bool a_double :1;
  bool a_string :1;
  bool a_complex :1;
  bool a_f32vector :1;
  bool a_f64vector :1;
  bool a_s64vector :1;
  bool a_s32vector :1;
  bool a_s16vector :1;
  bool a_s8vector :1;
  bool a_c32vector :1;
} _KnobBase__isset;

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

  KnobBase(const KnobBase&);
  KnobBase& operator=(const KnobBase&);
  KnobBase() noexcept;

  virtual ~KnobBase() noexcept;
  bool a_bool;
  int8_t a_byte;
  int16_t a_short;
  int32_t a_int;
  int64_t a_long;
  double a_double;
  std::string a_string;
  complex a_complex;
  VectorF a_f32vector;
  VectorD a_f64vector;
  VectorL a_s64vector;
  VectorI a_s32vector;
  VectorT a_s16vector;
  VectorC a_s8vector;
  VectorZ a_c32vector;

  _KnobBase__isset __isset;

  void __set_a_bool(const bool val);

  void __set_a_byte(const int8_t val);

  void __set_a_short(const int16_t val);

  void __set_a_int(const int32_t val);

  void __set_a_long(const int64_t val);

  void __set_a_double(const double val);

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

  void __set_a_complex(const complex& val);

  void __set_a_f32vector(const VectorF& val);

  void __set_a_f64vector(const VectorD& val);

  void __set_a_s64vector(const VectorL& val);

  void __set_a_s32vector(const VectorI& val);

  void __set_a_s16vector(const VectorT& val);

  void __set_a_s8vector(const VectorC& val);

  void __set_a_c32vector(const VectorZ& val);

  bool operator == (const KnobBase & rhs) const;
  bool operator != (const KnobBase &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const KnobBase & ) const;

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

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

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

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

typedef struct _Knob__isset {
  _Knob__isset() : type(false), value(false) {}
  bool type :1;
  bool value :1;
} _Knob__isset;

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

  Knob(const Knob&);
  Knob& operator=(const Knob&);
  Knob() noexcept;

  virtual ~Knob() noexcept;
  /**
   * 
   * @see BaseTypes
   */
  BaseTypes::type type;
  KnobBase value;

  _Knob__isset __isset;

  void __set_type(const BaseTypes::type val);

  void __set_value(const KnobBase& val);

  bool operator == (const Knob & rhs) const;
  bool operator != (const Knob &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Knob & ) const;

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

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

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

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

typedef struct _KnobProp__isset {
  _KnobProp__isset() : type(false), units(false), description(false), display(false), min(false), max(false), defaultvalue(false) {}
  bool type :1;
  bool units :1;
  bool description :1;
  bool display :1;
  bool min :1;
  bool max :1;
  bool defaultvalue :1;
} _KnobProp__isset;

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

  KnobProp(const KnobProp&);
  KnobProp& operator=(const KnobProp&);
  KnobProp() noexcept;

  virtual ~KnobProp() noexcept;
  /**
   * 
   * @see KnobType
   */
  KnobType::type type;
  std::string units;
  std::string description;
  int32_t display;
  Knob min;
  Knob max;
  Knob defaultvalue;

  _KnobProp__isset __isset;

  void __set_type(const KnobType::type val);

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

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

  void __set_display(const int32_t val);

  void __set_min(const Knob& val);

  void __set_max(const Knob& val);

  void __set_defaultvalue(const Knob& val);

  bool operator == (const KnobProp & rhs) const;
  bool operator != (const KnobProp &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const KnobProp & ) const;

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

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

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

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

} // namespace

#endif
