text: /**
   * Autogenerated by Thrift Compiler (0.13.0)
   *
   * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
   *  @generated
   */
  #ifndef core_TYPES_H
  #define core_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 MMIStandard {
  
  class MIPAddress;
  
  class MBoolResponse;
  
  class MParameter;
  
  class MExecutableDescription;
  
  class MServiceDescription;
  
  
  class MIPAddress : public virtual ::apache::thrift::TBase {
   public:
  
    MIPAddress(const MIPAddress&);
    MIPAddress& operator=(const MIPAddress&);
    MIPAddress() : Address(), Port(0) {
    }
  
    virtual ~MIPAddress() noexcept;
    std::string Address;
    int32_t Port;
  
    void __set_Address(const std::string& val);
  
    void __set_Port(const int32_t val);
  
    bool operator == (const MIPAddress & rhs) const
    {
      if (!(Address == rhs.Address))
        return false;
      if (!(Port == rhs.Port))
        return false;
      return true;
    }
    bool operator != (const MIPAddress &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const MIPAddress & ) 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(MIPAddress &a, MIPAddress &b);
  
  std::ostream& operator<<(std::ostream& out, const MIPAddress& obj);
  
  typedef struct _MBoolResponse__isset {
    _MBoolResponse__isset() : LogData(false) {}
    bool LogData :1;
  } _MBoolResponse__isset;
  
  class MBoolResponse : public virtual ::apache::thrift::TBase {
   public:
  
    MBoolResponse(const MBoolResponse&);
    MBoolResponse& operator=(const MBoolResponse&);
    MBoolResponse() : Successful(0) {
    }
  
    virtual ~MBoolResponse() noexcept;
    bool Successful;
    std::vector<std::string>  LogData;
  
    _MBoolResponse__isset __isset;
  
    void __set_Successful(const bool val);
  
    void __set_LogData(const std::vector<std::string> & val);
  
    bool operator == (const MBoolResponse & rhs) const
    {
      if (!(Successful == rhs.Successful))
        return false;
      if (__isset.LogData != rhs.__isset.LogData)
        return false;
      else if (__isset.LogData && !(LogData == rhs.LogData))
        return false;
      return true;
    }
    bool operator != (const MBoolResponse &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const MBoolResponse & ) 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(MBoolResponse &a, MBoolResponse &b);
  
  std::ostream& operator<<(std::ostream& out, const MBoolResponse& obj);
  
  
  class MParameter : public virtual ::apache::thrift::TBase {
   public:
  
    MParameter(const MParameter&);
    MParameter& operator=(const MParameter&);
    MParameter() : Name(), Type(), Description(), Required(0) {
    }
  
    virtual ~MParameter() noexcept;
    std::string Name;
    std::string Type;
    std::string Description;
    bool Required;
  
    void __set_Name(const std::string& val);
  
    void __set_Type(const std::string& val);
  
    void __set_Description(const std::string& val);
  
    void __set_Required(const bool val);
  
    bool operator == (const MParameter & rhs) const
    {
      if (!(Name == rhs.Name))
        return false;
      if (!(Type == rhs.Type))
        return false;
      if (!(Description == rhs.Description))
        return false;
      if (!(Required == rhs.Required))
        return false;
      return true;
    }
    bool operator != (const MParameter &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const MParameter & ) 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(MParameter &a, MParameter &b);
  
  std::ostream& operator<<(std::ostream& out, const MParameter& obj);
  
  typedef struct _MExecutableDescription__isset {
    _MExecutableDescription__isset() : Dependencies(false), Vendor(false), VendorDomain(false), ServiceUrl(false), UpdateUrl(false) {}
    bool Dependencies :1;
    bool Vendor :1;
    bool VendorDomain :1;
    bool ServiceUrl :1;
    bool UpdateUrl :1;
  } _MExecutableDescription__isset;
  
  class MExecutableDescription : public virtual ::apache::thrift::TBase {
   public:
  
    MExecutableDescription(const MExecutableDescription&);
    MExecutableDescription& operator=(const MExecutableDescription&);
    MExecutableDescription() : Name(), ID(), Language(), ExecutableName(), Author(), Version(), Vendor(), VendorDomain(), ServiceUrl(), UpdateUrl() {
    }
  
    virtual ~MExecutableDescription() noexcept;
    std::string Name;
    std::string ID;
    std::string Language;
    std::string ExecutableName;
    std::string Author;
    std::string Version;
    std::vector<std::string>  Dependencies;
    std::string Vendor;
    std::string VendorDomain;
    std::string ServiceUrl;
    std::string UpdateUrl;
  
    _MExecutableDescription__isset __isset;
  
    void __set_Name(const std::string& val);
  
    void __set_ID(const std::string& val);
  
    void __set_Language(const std::string& val);
  
    void __set_ExecutableName(const std::string& val);
  
    void __set_Author(const std::string& val);
  
    void __set_Version(const std::string& val);
  
    void __set_Dependencies(const std::vector<std::string> & val);
  
    void __set_Vendor(const std::string& val);
  
    void __set_VendorDomain(const std::string& val);
  
    void __set_ServiceUrl(const std::string& val);
  
    void __set_UpdateUrl(const std::string& val);
  
    bool operator == (const MExecutableDescription & rhs) const
    {
      if (!(Name == rhs.Name))
        return false;
      if (!(ID == rhs.ID))
        return false;
      if (!(Language == rhs.Language))
        return false;
      if (!(ExecutableName == rhs.ExecutableName))
        return false;
      if (!(Author == rhs.Author))
        return false;
      if (!(Version == rhs.Version))
        return false;
      if (__isset.Dependencies != rhs.__isset.Dependencies)
        return false;
      else if (__isset.Dependencies && !(Dependencies == rhs.Dependencies))
        return false;
      if (__isset.Vendor != rhs.__isset.Vendor)
        return false;
      else if (__isset.Vendor && !(Vendor == rhs.Vendor))
        return false;
      if (__isset.VendorDomain != rhs.__isset.VendorDomain)
        return false;
      else if (__isset.VendorDomain && !(VendorDomain == rhs.VendorDomain))
        return false;
      if (__isset.ServiceUrl != rhs.__isset.ServiceUrl)
        return false;
      else if (__isset.ServiceUrl && !(ServiceUrl == rhs.ServiceUrl))
        return false;
      if (__isset.UpdateUrl != rhs.__isset.UpdateUrl)
        return false;
      else if (__isset.UpdateUrl && !(UpdateUrl == rhs.UpdateUrl))
        return false;
      return true;
    }
    bool operator != (const MExecutableDescription &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const MExecutableDescription & ) 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(MExecutableDescription &a, MExecutableDescription &b);
  
  std::ostream& operator<<(std::ostream& out, const MExecutableDescription& obj);
  
  typedef struct _MServiceDescription__isset {
    _MServiceDescription__isset() : Properties(false), Parameters(false) {}
    bool Properties :1;
    bool Parameters :1;
  } _MServiceDescription__isset;
  
  class MServiceDescription : public virtual ::apache::thrift::TBase {
   public:
  
    MServiceDescription(const MServiceDescription&);
    MServiceDescription& operator=(const MServiceDescription&);
    MServiceDescription() : Name(), ID(), Language() {
    }
  
    virtual ~MServiceDescription() noexcept;
    std::string Name;
    std::string ID;
    std::string Language;
    std::vector<MIPAddress>  Addresses;
    std::map<std::string, std::string>  Properties;
    std::vector<MParameter>  Parameters;
  
    _MServiceDescription__isset __isset;
  
    void __set_Name(const std::string& val);
  
    void __set_ID(const std::string& val);
  
    void __set_Language(const std::string& val);
  
    void __set_Addresses(const std::vector<MIPAddress> & val);
  
    void __set_Properties(const std::map<std::string, std::string> & val);
  
    void __set_Parameters(const std::vector<MParameter> & val);
  
    bool operator == (const MServiceDescription & rhs) const
    {
      if (!(Name == rhs.Name))
        return false;
      if (!(ID == rhs.ID))
        return false;
      if (!(Language == rhs.Language))
        return false;
      if (!(Addresses == rhs.Addresses))
        return false;
      if (__isset.Properties != rhs.__isset.Properties)
        return false;
      else if (__isset.Properties && !(Properties == rhs.Properties))
        return false;
      if (__isset.Parameters != rhs.__isset.Parameters)
        return false;
      else if (__isset.Parameters && !(Parameters == rhs.Parameters))
        return false;
      return true;
    }
    bool operator != (const MServiceDescription &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const MServiceDescription & ) 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(MServiceDescription &a, MServiceDescription &b);
  
  std::ostream& operator<<(std::ostream& out, const MServiceDescription& obj);
  
  } // namespace
  
  #endif
  