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




struct weekdays {
  enum type {
    SUNDAY = 0,
    MONDAY = 1,
    TUESDAY = 2,
    WEDNESDAY = 3,
    THURSDAY = 4,
    FRIDAY = 5,
    SATURDAY = 6
  };
};

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

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

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

typedef std::vector<int32_t>  int_linked_list;

typedef std::string non_latin_string;

typedef std::vector<double>  tiny_float_list;

typedef std::string seasons;

class foo;

class foo_error;

class ostr_default;

class ostr_custom;

typedef struct _foo__isset {
  _foo__isset() : bar(false), baz(false), qux(false), bop(false) {}
  bool bar :1;
  bool baz :1;
  bool qux :1;
  bool bop :1;
} _foo__isset;

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

  foo(const foo&);
  foo& operator=(const foo&);
  foo() : bar(0), baz(0), qux(0), bop(0) {
  }

  virtual ~foo() noexcept;
  int32_t bar;
  int32_t baz;
  int32_t qux;
  int32_t bop;

  _foo__isset __isset;

  void __set_bar(const int32_t val);

  void __set_baz(const int32_t val);

  void __set_qux(const int32_t val);

  void __set_bop(const int32_t val);

  bool operator == (const foo & rhs) const
  {
    if (!(bar == rhs.bar))
      return false;
    if (!(baz == rhs.baz))
      return false;
    if (!(qux == rhs.qux))
      return false;
    if (!(bop == rhs.bop))
      return false;
    return true;
  }
  bool operator != (const foo &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const foo & ) 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(foo &a, foo &b);

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

typedef struct _foo_error__isset {
  _foo_error__isset() : error_code(false), error_msg(false) {}
  bool error_code :1;
  bool error_msg :1;
} _foo_error__isset;

class foo_error : public ::apache::thrift::TException {
 public:

  foo_error(const foo_error&);
  foo_error& operator=(const foo_error&);
  foo_error() : error_code(0), error_msg() {
  }

  virtual ~foo_error() noexcept;
  int32_t error_code;
  std::string error_msg;

  _foo_error__isset __isset;

  void __set_error_code(const int32_t val);

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

  bool operator == (const foo_error & rhs) const
  {
    if (!(error_code == rhs.error_code))
      return false;
    if (!(error_msg == rhs.error_msg))
      return false;
    return true;
  }
  bool operator != (const foo_error &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const foo_error & ) 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;
  mutable std::string thriftTExceptionMessageHolder_;
  const char* what() const noexcept;
};

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

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

typedef struct _ostr_default__isset {
  _ostr_default__isset() : bar(false) {}
  bool bar :1;
} _ostr_default__isset;

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

  ostr_default(const ostr_default&);
  ostr_default& operator=(const ostr_default&);
  ostr_default() : bar(0) {
  }

  virtual ~ostr_default() noexcept;
  int32_t bar;

  _ostr_default__isset __isset;

  void __set_bar(const int32_t val);

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

  bool operator < (const ostr_default & ) 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(ostr_default &a, ostr_default &b);

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

typedef struct _ostr_custom__isset {
  _ostr_custom__isset() : bar(false) {}
  bool bar :1;
} _ostr_custom__isset;

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

  ostr_custom(const ostr_custom&);
  ostr_custom& operator=(const ostr_custom&);
  ostr_custom() : bar(0) {
  }

  virtual ~ostr_custom() noexcept;
  int32_t bar;

  _ostr_custom__isset __isset;

  void __set_bar(const int32_t val);

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

  bool operator < (const ostr_custom & ) const;

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

};

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

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



#endif
