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




class RecTree;

class RecList;

class CoRec;

class CoRec2;

class VectorTest;

typedef struct _RecTree__isset {
  _RecTree__isset() : children(false), item(false) {}
  bool children :1;
  bool item :1;
} _RecTree__isset;

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

  RecTree(const RecTree&);
  RecTree& operator=(const RecTree&);
  RecTree() : item(0) {
  }

  virtual ~RecTree() noexcept;
  std::vector<RecTree>  children;
  int16_t item;

  _RecTree__isset __isset;

  void __set_children(const std::vector<RecTree> & val);

  void __set_item(const int16_t val);

  bool operator == (const RecTree & rhs) const
  {
    if (!(children == rhs.children))
      return false;
    if (!(item == rhs.item))
      return false;
    return true;
  }
  bool operator != (const RecTree &rhs) const {
    return !(*this == rhs);
  }

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

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

typedef struct _RecList__isset {
  _RecList__isset() : nextitem(false), item(false) {}
  bool nextitem :1;
  bool item :1;
} _RecList__isset;

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

  RecList(const RecList&);
  RecList& operator=(const RecList&);
  RecList() : nextitem(), item(0) {
  }

  virtual ~RecList() noexcept;
  ::std::shared_ptr<RecList> nextitem;
  int16_t item;

  _RecList__isset __isset;

  void __set_nextitem(::std::shared_ptr<RecList> val);

  void __set_item(const int16_t val);

  bool operator == (const RecList & rhs) const
  {
    if (!(nextitem == rhs.nextitem))
      return false;
    if (!(item == rhs.item))
      return false;
    return true;
  }
  bool operator != (const RecList &rhs) const {
    return !(*this == rhs);
  }

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

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

typedef struct _CoRec__isset {
  _CoRec__isset() : other(false) {}
  bool other :1;
} _CoRec__isset;

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

  CoRec(const CoRec&);
  CoRec& operator=(const CoRec&);
  CoRec() : other() {
  }

  virtual ~CoRec() noexcept;
  ::std::shared_ptr<CoRec2> other;

  _CoRec__isset __isset;

  void __set_other(::std::shared_ptr<CoRec2> val);

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

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

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

typedef struct _CoRec2__isset {
  _CoRec2__isset() : other(false) {}
  bool other :1;
} _CoRec2__isset;

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

  CoRec2(const CoRec2&);
  CoRec2& operator=(const CoRec2&);
  CoRec2() {
  }

  virtual ~CoRec2() noexcept;
  CoRec other;

  _CoRec2__isset __isset;

  void __set_other(const CoRec& val);

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

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

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

typedef struct _VectorTest__isset {
  _VectorTest__isset() : lister(false) {}
  bool lister :1;
} _VectorTest__isset;

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

  VectorTest(const VectorTest&);
  VectorTest& operator=(const VectorTest&);
  VectorTest() {
  }

  virtual ~VectorTest() noexcept;
  std::vector<RecList>  lister;

  _VectorTest__isset __isset;

  void __set_lister(const std::vector<RecList> & val);

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

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

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



#endif
