text: /**
   * Licensed to the Apache Software Foundation (ASF) under one or more
   * contributor license agreements.  See the NOTICE file distributed with
   * this work for additional information regarding copyright ownership.
   * The ASF licenses this file to You under the Apache License, Version 2.0
   * (the "License"); you may not use this file except in compliance with
   * the License.  You may obtain a copy of the License at
   *
   *     http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  /**
   * Autogenerated by Thrift Compiler (0.9.1)
   *
   * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
   *  @generated
   */
  #ifndef airavataErrors_TYPES_H
  #define airavataErrors_TYPES_H
  
  #include <thrift/Thrift.h>
  #include <thrift/TApplicationException.h>
  #include <thrift/protocol/TProtocol.h>
  #include <thrift/transport/TTransport.h>
  
  #include <thrift/cxxfunctional.h>
  #include "experimentModel_types.h"
  
  
  namespace apache { namespace airavata { namespace api { namespace error {
  
  struct AiravataErrorType {
    enum type {
      UNKNOWN = 0,
      PERMISSION_DENIED = 1,
      INTERNAL_ERROR = 2,
      AUTHENTICATION_FAILURE = 3,
      INVALID_AUTHORIZATION = 4,
      AUTHORIZATION_EXPIRED = 5,
      UNKNOWN_GATEWAY_ID = 6,
      UNSUPPORTED_OPERATION = 7
    };
  };
  
  extern const std::map<int, const char*> _AiravataErrorType_VALUES_TO_NAMES;
  
  
  class ExperimentNotFoundException : public ::apache::thrift::TException {
   public:
  
    static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1";
    static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
  
    ExperimentNotFoundException() : message() {
    }
  
    virtual ~ExperimentNotFoundException() throw() {}
  
    std::string message;
  
    void __set_message(const std::string& val) {
      message = val;
    }
  
    bool operator == (const ExperimentNotFoundException & rhs) const
    {
      if (!(message == rhs.message))
        return false;
      return true;
    }
    bool operator != (const ExperimentNotFoundException &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ExperimentNotFoundException & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  void swap(ExperimentNotFoundException &a, ExperimentNotFoundException &b);
  
  
  class ProjectNotFoundException : public ::apache::thrift::TException {
   public:
  
    static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1";
    static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
  
    ProjectNotFoundException() : message() {
    }
  
    virtual ~ProjectNotFoundException() throw() {}
  
    std::string message;
  
    void __set_message(const std::string& val) {
      message = val;
    }
  
    bool operator == (const ProjectNotFoundException & rhs) const
    {
      if (!(message == rhs.message))
        return false;
      return true;
    }
    bool operator != (const ProjectNotFoundException &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ProjectNotFoundException & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  void swap(ProjectNotFoundException &a, ProjectNotFoundException &b);
  
  
  class InvalidRequestException : public ::apache::thrift::TException {
   public:
  
    static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1";
    static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
  
    InvalidRequestException() : message() {
    }
  
    virtual ~InvalidRequestException() throw() {}
  
    std::string message;
  
    void __set_message(const std::string& val) {
      message = val;
    }
  
    bool operator == (const InvalidRequestException & rhs) const
    {
      if (!(message == rhs.message))
        return false;
      return true;
    }
    bool operator != (const InvalidRequestException &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const InvalidRequestException & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  void swap(InvalidRequestException &a, InvalidRequestException &b);
  
  
  class TimedOutException : public ::apache::thrift::TException {
   public:
  
    static const char* ascii_fingerprint; // = "99914B932BD37A50B983C5E7C90AE93B";
    static const uint8_t binary_fingerprint[16]; // = {0x99,0x91,0x4B,0x93,0x2B,0xD3,0x7A,0x50,0xB9,0x83,0xC5,0xE7,0xC9,0x0A,0xE9,0x3B};
  
    TimedOutException() {
    }
  
    virtual ~TimedOutException() throw() {}
  
  
    bool operator == (const TimedOutException & /* rhs */) const
    {
      return true;
    }
    bool operator != (const TimedOutException &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const TimedOutException & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  void swap(TimedOutException &a, TimedOutException &b);
  
  
  class AuthenticationException : public ::apache::thrift::TException {
   public:
  
    static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1";
    static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
  
    AuthenticationException() : message() {
    }
  
    virtual ~AuthenticationException() throw() {}
  
    std::string message;
  
    void __set_message(const std::string& val) {
      message = val;
    }
  
    bool operator == (const AuthenticationException & rhs) const
    {
      if (!(message == rhs.message))
        return false;
      return true;
    }
    bool operator != (const AuthenticationException &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const AuthenticationException & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  void swap(AuthenticationException &a, AuthenticationException &b);
  
  
  class AuthorizationException : public ::apache::thrift::TException {
   public:
  
    static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1";
    static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
  
    AuthorizationException() : message() {
    }
  
    virtual ~AuthorizationException() throw() {}
  
    std::string message;
  
    void __set_message(const std::string& val) {
      message = val;
    }
  
    bool operator == (const AuthorizationException & rhs) const
    {
      if (!(message == rhs.message))
        return false;
      return true;
    }
    bool operator != (const AuthorizationException &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const AuthorizationException & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  void swap(AuthorizationException &a, AuthorizationException &b);
  
  typedef struct _AiravataClientException__isset {
    _AiravataClientException__isset() : parameter(false) {}
    bool parameter;
  } _AiravataClientException__isset;
  
  class AiravataClientException : public ::apache::thrift::TException {
   public:
  
    static const char* ascii_fingerprint; // = "24652790C81ECE22B629CB60A19F1E93";
    static const uint8_t binary_fingerprint[16]; // = {0x24,0x65,0x27,0x90,0xC8,0x1E,0xCE,0x22,0xB6,0x29,0xCB,0x60,0xA1,0x9F,0x1E,0x93};
  
    AiravataClientException() : airavataErrorType((AiravataErrorType::type)0), parameter() {
    }
  
    virtual ~AiravataClientException() throw() {}
  
    AiravataErrorType::type airavataErrorType;
    std::string parameter;
  
    _AiravataClientException__isset __isset;
  
    void __set_airavataErrorType(const AiravataErrorType::type val) {
      airavataErrorType = val;
    }
  
    void __set_parameter(const std::string& val) {
      parameter = val;
      __isset.parameter = true;
    }
  
    bool operator == (const AiravataClientException & rhs) const
    {
      if (!(airavataErrorType == rhs.airavataErrorType))
        return false;
      if (__isset.parameter != rhs.__isset.parameter)
        return false;
      else if (__isset.parameter && !(parameter == rhs.parameter))
        return false;
      return true;
    }
    bool operator != (const AiravataClientException &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const AiravataClientException & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  void swap(AiravataClientException &a, AiravataClientException &b);
  
  typedef struct _ValidatorResult__isset {
    _ValidatorResult__isset() : errorDetails(false) {}
    bool errorDetails;
  } _ValidatorResult__isset;
  
  class ValidatorResult {
   public:
  
    static const char* ascii_fingerprint; // = "EB04A806CFFC9025AEE48CFFDC378A86";
    static const uint8_t binary_fingerprint[16]; // = {0xEB,0x04,0xA8,0x06,0xCF,0xFC,0x90,0x25,0xAE,0xE4,0x8C,0xFF,0xDC,0x37,0x8A,0x86};
  
    ValidatorResult() : result(0), errorDetails() {
    }
  
    virtual ~ValidatorResult() throw() {}
  
    bool result;
    std::string errorDetails;
  
    _ValidatorResult__isset __isset;
  
    void __set_result(const bool val) {
      result = val;
    }
  
    void __set_errorDetails(const std::string& val) {
      errorDetails = val;
      __isset.errorDetails = true;
    }
  
    bool operator == (const ValidatorResult & rhs) const
    {
      if (!(result == rhs.result))
        return false;
      if (__isset.errorDetails != rhs.__isset.errorDetails)
        return false;
      else if (__isset.errorDetails && !(errorDetails == rhs.errorDetails))
        return false;
      return true;
    }
    bool operator != (const ValidatorResult &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ValidatorResult & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  void swap(ValidatorResult &a, ValidatorResult &b);
  
  
  class ValidationResults {
   public:
  
    static const char* ascii_fingerprint; // = "E73BC8630EE405DA5FB801ED852143D2";
    static const uint8_t binary_fingerprint[16]; // = {0xE7,0x3B,0xC8,0x63,0x0E,0xE4,0x05,0xDA,0x5F,0xB8,0x01,0xED,0x85,0x21,0x43,0xD2};
  
    ValidationResults() : validationState(0) {
    }
  
    virtual ~ValidationResults() throw() {}
  
    bool validationState;
    std::vector<ValidatorResult>  validationResultList;
  
    void __set_validationState(const bool val) {
      validationState = val;
    }
  
    void __set_validationResultList(const std::vector<ValidatorResult> & val) {
      validationResultList = val;
    }
  
    bool operator == (const ValidationResults & rhs) const
    {
      if (!(validationState == rhs.validationState))
        return false;
      if (!(validationResultList == rhs.validationResultList))
        return false;
      return true;
    }
    bool operator != (const ValidationResults &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ValidationResults & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  void swap(ValidationResults &a, ValidationResults &b);
  
  typedef struct _LaunchValidationException__isset {
    _LaunchValidationException__isset() : errorMessage(false) {}
    bool errorMessage;
  } _LaunchValidationException__isset;
  
  class LaunchValidationException : public ::apache::thrift::TException {
   public:
  
    static const char* ascii_fingerprint; // = "99E9D28CC9613B8567277FD2B86021FA";
    static const uint8_t binary_fingerprint[16]; // = {0x99,0xE9,0xD2,0x8C,0xC9,0x61,0x3B,0x85,0x67,0x27,0x7F,0xD2,0xB8,0x60,0x21,0xFA};
  
    LaunchValidationException() : errorMessage() {
    }
  
    virtual ~LaunchValidationException() throw() {}
  
    ValidationResults validationResult;
    std::string errorMessage;
  
    _LaunchValidationException__isset __isset;
  
    void __set_validationResult(const ValidationResults& val) {
      validationResult = val;
    }
  
    void __set_errorMessage(const std::string& val) {
      errorMessage = val;
      __isset.errorMessage = true;
    }
  
    bool operator == (const LaunchValidationException & rhs) const
    {
      if (!(validationResult == rhs.validationResult))
        return false;
      if (__isset.errorMessage != rhs.__isset.errorMessage)
        return false;
      else if (__isset.errorMessage && !(errorMessage == rhs.errorMessage))
        return false;
      return true;
    }
    bool operator != (const LaunchValidationException &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const LaunchValidationException & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  void swap(LaunchValidationException &a, LaunchValidationException &b);
  
  typedef struct _AiravataSystemException__isset {
    _AiravataSystemException__isset() : message(false) {}
    bool message;
  } _AiravataSystemException__isset;
  
  class AiravataSystemException : public ::apache::thrift::TException {
   public:
  
    static const char* ascii_fingerprint; // = "24652790C81ECE22B629CB60A19F1E93";
    static const uint8_t binary_fingerprint[16]; // = {0x24,0x65,0x27,0x90,0xC8,0x1E,0xCE,0x22,0xB6,0x29,0xCB,0x60,0xA1,0x9F,0x1E,0x93};
  
    AiravataSystemException() : airavataErrorType((AiravataErrorType::type)0), message() {
    }
  
    virtual ~AiravataSystemException() throw() {}
  
    AiravataErrorType::type airavataErrorType;
    std::string message;
  
    _AiravataSystemException__isset __isset;
  
    void __set_airavataErrorType(const AiravataErrorType::type val) {
      airavataErrorType = val;
    }
  
    void __set_message(const std::string& val) {
      message = val;
      __isset.message = true;
    }
  
    bool operator == (const AiravataSystemException & rhs) const
    {
      if (!(airavataErrorType == rhs.airavataErrorType))
        return false;
      if (__isset.message != rhs.__isset.message)
        return false;
      else if (__isset.message && !(message == rhs.message))
        return false;
      return true;
    }
    bool operator != (const AiravataSystemException &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const AiravataSystemException & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  void swap(AiravataSystemException &a, AiravataSystemException &b);
  
  }}}} // namespace
  
  #endif
  