remote/gen-cpp/shared_types.h

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

struct Style {
  enum type {
    SOLID = 0,
    DOT = 1,
    DASH = 2,
    NONE = 3
  };
};

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

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

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

class RObject;

class ResponseHeaders;

class ResponseData;

class PostDataElement;

class PostData;

class KeyEvent;

class Cookie;

class Range;

class Color;

class CompositionUnderline;

typedef struct _RObject__isset {
  _RObject__isset() : flags(false), objInfo(false) {}
  bool flags :1;
  bool objInfo :1;
} _RObject__isset;

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

  RObject(const RObject&);
  RObject& operator=(const RObject&);
  RObject() noexcept
          : isNull(true),
            objId(-1),
            flags(0) {
  }

  virtual ~RObject() noexcept;
  bool isNull;
  int32_t objId;
  int32_t flags;
  std::map<std::string, std::string>  objInfo;

  _RObject__isset __isset;

  void __set_isNull(const bool val);

  void __set_objId(const int32_t val);

  void __set_flags(const int32_t val);

  void __set_objInfo(const std::map<std::string, std::string> & val);

  bool operator == (const RObject & rhs) const
  {
    if (!(isNull == rhs.isNull))
      return false;
    if (!(objId == rhs.objId))
      return false;
    if (__isset.flags != rhs.__isset.flags)
      return false;
    else if (__isset.flags && !(flags == rhs.flags))
      return false;
    if (__isset.objInfo != rhs.__isset.objInfo)
      return false;
    else if (__isset.objInfo && !(objInfo == rhs.objInfo))
      return false;
    return true;
  }
  bool operator != (const RObject &rhs) const {
    return !(*this == rhs);
  }

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

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

typedef struct _ResponseHeaders__isset {
  _ResponseHeaders__isset() : redirectUrl(false) {}
  bool redirectUrl :1;
} _ResponseHeaders__isset;

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

  ResponseHeaders(const ResponseHeaders&);
  ResponseHeaders& operator=(const ResponseHeaders&);
  ResponseHeaders() noexcept
                  : length(0),
                    redirectUrl() {
  }

  virtual ~ResponseHeaders() noexcept;
  int32_t length;
  std::string redirectUrl;

  _ResponseHeaders__isset __isset;

  void __set_length(const int32_t val);

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

  bool operator == (const ResponseHeaders & rhs) const
  {
    if (!(length == rhs.length))
      return false;
    if (__isset.redirectUrl != rhs.__isset.redirectUrl)
      return false;
    else if (__isset.redirectUrl && !(redirectUrl == rhs.redirectUrl))
      return false;
    return true;
  }
  bool operator != (const ResponseHeaders &rhs) const {
    return !(*this == rhs);
  }

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

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

typedef struct _ResponseData__isset {
  _ResponseData__isset() : continueRead(false), data(false), bytes_read(false) {}
  bool continueRead :1;
  bool data :1;
  bool bytes_read :1;
} _ResponseData__isset;

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

  ResponseData(const ResponseData&);
  ResponseData& operator=(const ResponseData&);
  ResponseData() noexcept
               : continueRead(0),
                 data(),
                 bytes_read(0) {
  }

  virtual ~ResponseData() noexcept;
  bool continueRead;
  std::string data;
  int32_t bytes_read;

  _ResponseData__isset __isset;

  void __set_continueRead(const bool val);

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

  void __set_bytes_read(const int32_t val);

  bool operator == (const ResponseData & rhs) const
  {
    if (__isset.continueRead != rhs.__isset.continueRead)
      return false;
    else if (__isset.continueRead && !(continueRead == rhs.continueRead))
      return false;
    if (__isset.data != rhs.__isset.data)
      return false;
    else if (__isset.data && !(data == rhs.data))
      return false;
    if (__isset.bytes_read != rhs.__isset.bytes_read)
      return false;
    else if (__isset.bytes_read && !(bytes_read == rhs.bytes_read))
      return false;
    return true;
  }
  bool operator != (const ResponseData &rhs) const {
    return !(*this == rhs);
  }

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

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

typedef struct _PostDataElement__isset {
  _PostDataElement__isset() : file(false), bytes(false) {}
  bool file :1;
  bool bytes :1;
} _PostDataElement__isset;

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

  PostDataElement(const PostDataElement&);
  PostDataElement& operator=(const PostDataElement&);
  PostDataElement() noexcept
                  : isReadOnly(0),
                    type(0),
                    file(),
                    bytes() {
  }

  virtual ~PostDataElement() noexcept;
  bool isReadOnly;
  int32_t type;
  std::string file;
  std::string bytes;

  _PostDataElement__isset __isset;

  void __set_isReadOnly(const bool val);

  void __set_type(const int32_t val);

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

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

  bool operator == (const PostDataElement & rhs) const
  {
    if (!(isReadOnly == rhs.isReadOnly))
      return false;
    if (!(type == rhs.type))
      return false;
    if (__isset.file != rhs.__isset.file)
      return false;
    else if (__isset.file && !(file == rhs.file))
      return false;
    if (__isset.bytes != rhs.__isset.bytes)
      return false;
    else if (__isset.bytes && !(bytes == rhs.bytes))
      return false;
    return true;
  }
  bool operator != (const PostDataElement &rhs) const {
    return !(*this == rhs);
  }

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

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

typedef struct _PostData__isset {
  _PostData__isset() : elements(false) {}
  bool elements :1;
} _PostData__isset;

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

  PostData(const PostData&);
  PostData& operator=(const PostData&);
  PostData() noexcept
           : isNull(true),
             isReadOnly(0),
             hasExcludedElements(0) {
  }

  virtual ~PostData() noexcept;
  bool isNull;
  bool isReadOnly;
  bool hasExcludedElements;
  std::vector<PostDataElement>  elements;

  _PostData__isset __isset;

  void __set_isNull(const bool val);

  void __set_isReadOnly(const bool val);

  void __set_hasExcludedElements(const bool val);

  void __set_elements(const std::vector<PostDataElement> & val);

  bool operator == (const PostData & rhs) const
  {
    if (!(isNull == rhs.isNull))
      return false;
    if (!(isReadOnly == rhs.isReadOnly))
      return false;
    if (!(hasExcludedElements == rhs.hasExcludedElements))
      return false;
    if (__isset.elements != rhs.__isset.elements)
      return false;
    else if (__isset.elements && !(elements == rhs.elements))
      return false;
    return true;
  }
  bool operator != (const PostData &rhs) const {
    return !(*this == rhs);
  }

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

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


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

  KeyEvent(const KeyEvent&);
  KeyEvent& operator=(const KeyEvent&);
  KeyEvent() noexcept
           : type(),
             modifiers(0),
             windows_key_code(0),
             native_key_code(0),
             is_system_key(0),
             character(0),
             unmodified_character(0),
             focus_on_editable_field(0) {
  }

  virtual ~KeyEvent() noexcept;
  std::string type;
  int32_t modifiers;
  int32_t windows_key_code;
  int32_t native_key_code;
  bool is_system_key;
  int16_t character;
  int16_t unmodified_character;
  bool focus_on_editable_field;

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

  void __set_modifiers(const int32_t val);

  void __set_windows_key_code(const int32_t val);

  void __set_native_key_code(const int32_t val);

  void __set_is_system_key(const bool val);

  void __set_character(const int16_t val);

  void __set_unmodified_character(const int16_t val);

  void __set_focus_on_editable_field(const bool val);

  bool operator == (const KeyEvent & rhs) const
  {
    if (!(type == rhs.type))
      return false;
    if (!(modifiers == rhs.modifiers))
      return false;
    if (!(windows_key_code == rhs.windows_key_code))
      return false;
    if (!(native_key_code == rhs.native_key_code))
      return false;
    if (!(is_system_key == rhs.is_system_key))
      return false;
    if (!(character == rhs.character))
      return false;
    if (!(unmodified_character == rhs.unmodified_character))
      return false;
    if (!(focus_on_editable_field == rhs.focus_on_editable_field))
      return false;
    return true;
  }
  bool operator != (const KeyEvent &rhs) const {
    return !(*this == rhs);
  }

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

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

typedef struct _Cookie__isset {
  _Cookie__isset() : expires(false) {}
  bool expires :1;
} _Cookie__isset;

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

  Cookie(const Cookie&);
  Cookie& operator=(const Cookie&);
  Cookie() noexcept
         : name(),
           value(),
           domain(),
           path(),
           secure(0),
           httponly(0),
           creation(0),
           lastAccess(0),
           expires(0) {
  }

  virtual ~Cookie() noexcept;
  std::string name;
  std::string value;
  std::string domain;
  std::string path;
  bool secure;
  bool httponly;
  int64_t creation;
  int64_t lastAccess;
  int64_t expires;

  _Cookie__isset __isset;

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

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

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

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

  void __set_secure(const bool val);

  void __set_httponly(const bool val);

  void __set_creation(const int64_t val);

  void __set_lastAccess(const int64_t val);

  void __set_expires(const int64_t val);

  bool operator == (const Cookie & rhs) const
  {
    if (!(name == rhs.name))
      return false;
    if (!(value == rhs.value))
      return false;
    if (!(domain == rhs.domain))
      return false;
    if (!(path == rhs.path))
      return false;
    if (!(secure == rhs.secure))
      return false;
    if (!(httponly == rhs.httponly))
      return false;
    if (!(creation == rhs.creation))
      return false;
    if (!(lastAccess == rhs.lastAccess))
      return false;
    if (__isset.expires != rhs.__isset.expires)
      return false;
    else if (__isset.expires && !(expires == rhs.expires))
      return false;
    return true;
  }
  bool operator != (const Cookie &rhs) const {
    return !(*this == rhs);
  }

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

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


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

  Range(const Range&) noexcept;
  Range& operator=(const Range&) noexcept;
  Range() noexcept
        : from(0),
          to(0) {
  }

  virtual ~Range() noexcept;
  int64_t from;
  int64_t to;

  void __set_from(const int64_t val);

  void __set_to(const int64_t val);

  bool operator == (const Range & rhs) const
  {
    if (!(from == rhs.from))
      return false;
    if (!(to == rhs.to))
      return false;
    return true;
  }
  bool operator != (const Range &rhs) const {
    return !(*this == rhs);
  }

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

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

typedef struct _Color__isset {
  _Color__isset() : red(false), green(false), blue(false), alpha(false) {}
  bool red :1;
  bool green :1;
  bool blue :1;
  bool alpha :1;
} _Color__isset;

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

  Color(const Color&) noexcept;
  Color& operator=(const Color&) noexcept;
  Color() noexcept
        : red(0),
          green(0),
          blue(0),
          alpha(0) {
  }

  virtual ~Color() noexcept;
  int32_t red;
  int32_t green;
  int32_t blue;
  int32_t alpha;

  _Color__isset __isset;

  void __set_red(const int32_t val);

  void __set_green(const int32_t val);

  void __set_blue(const int32_t val);

  void __set_alpha(const int32_t val);

  bool operator == (const Color & rhs) const
  {
    if (!(red == rhs.red))
      return false;
    if (!(green == rhs.green))
      return false;
    if (!(blue == rhs.blue))
      return false;
    if (!(alpha == rhs.alpha))
      return false;
    return true;
  }
  bool operator != (const Color &rhs) const {
    return !(*this == rhs);
  }

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

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


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

  CompositionUnderline(const CompositionUnderline&) noexcept;
  CompositionUnderline& operator=(const CompositionUnderline&) noexcept;
  CompositionUnderline() noexcept
                       : thick(0),
                         style(static_cast<Style::type>(0)) {
  }

  virtual ~CompositionUnderline() noexcept;
  Range range;
  Color color;
  Color backgroundColor;
  int32_t thick;
  /**
   * 
   * @see Style
   */
  Style::type style;

  void __set_range(const Range& val);

  void __set_color(const Color& val);

  void __set_backgroundColor(const Color& val);

  void __set_thick(const int32_t val);

  void __set_style(const Style::type val);

  bool operator == (const CompositionUnderline & rhs) const
  {
    if (!(range == rhs.range))
      return false;
    if (!(color == rhs.color))
      return false;
    if (!(backgroundColor == rhs.backgroundColor))
      return false;
    if (!(thick == rhs.thick))
      return false;
    if (!(style == rhs.style))
      return false;
    return true;
  }
  bool operator != (const CompositionUnderline &rhs) const {
    return !(*this == rhs);
  }

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

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

} // namespace

#endif