| /** |
| * 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.3) |
| * |
| * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING |
| * @generated |
| */ |
| #ifndef airavata_errors_TYPES_H |
| #define airavata_errors_TYPES_H |
| |
| #include <iosfwd> |
| |
| #include <thrift/Thrift.h> |
| #include <thrift/TApplicationException.h> |
| #include <thrift/protocol/TProtocol.h> |
| #include <thrift/transport/TTransport.h> |
| |
| #include <thrift/cxxfunctional.h> |
| #include "experiment_model_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; |
| |
| class ProjectNotFoundException; |
| |
| class InvalidRequestException; |
| |
| class TimedOutException; |
| |
| class AuthenticationException; |
| |
| class AuthorizationException; |
| |
| class AiravataClientException; |
| |
| class ValidatorResult; |
| |
| class ValidationResults; |
| |
| class LaunchValidationException; |
| |
| class AiravataSystemException; |
| |
| class DataManagerServiceException; |
| |
| |
| class ExperimentNotFoundException : public ::apache::thrift::TException { |
| public: |
| |
| ExperimentNotFoundException(const ExperimentNotFoundException&); |
| ExperimentNotFoundException& operator=(const ExperimentNotFoundException&); |
| ExperimentNotFoundException() : message() { |
| } |
| |
| virtual ~ExperimentNotFoundException() throw(); |
| std::string message; |
| |
| void __set_message(const std::string& 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; |
| |
| virtual void printTo(std::ostream& out) const; |
| mutable std::string thriftTExceptionMessageHolder_; |
| const char* what() const throw(); |
| }; |
| |
| void swap(ExperimentNotFoundException &a, ExperimentNotFoundException &b); |
| |
| inline std::ostream& operator<<(std::ostream& out, const ExperimentNotFoundException& obj) |
| { |
| obj.printTo(out); |
| return out; |
| } |
| |
| |
| class ProjectNotFoundException : public ::apache::thrift::TException { |
| public: |
| |
| ProjectNotFoundException(const ProjectNotFoundException&); |
| ProjectNotFoundException& operator=(const ProjectNotFoundException&); |
| ProjectNotFoundException() : message() { |
| } |
| |
| virtual ~ProjectNotFoundException() throw(); |
| std::string message; |
| |
| void __set_message(const std::string& 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; |
| |
| virtual void printTo(std::ostream& out) const; |
| mutable std::string thriftTExceptionMessageHolder_; |
| const char* what() const throw(); |
| }; |
| |
| void swap(ProjectNotFoundException &a, ProjectNotFoundException &b); |
| |
| inline std::ostream& operator<<(std::ostream& out, const ProjectNotFoundException& obj) |
| { |
| obj.printTo(out); |
| return out; |
| } |
| |
| |
| class InvalidRequestException : public ::apache::thrift::TException { |
| public: |
| |
| InvalidRequestException(const InvalidRequestException&); |
| InvalidRequestException& operator=(const InvalidRequestException&); |
| InvalidRequestException() : message() { |
| } |
| |
| virtual ~InvalidRequestException() throw(); |
| std::string message; |
| |
| void __set_message(const std::string& 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; |
| |
| virtual void printTo(std::ostream& out) const; |
| mutable std::string thriftTExceptionMessageHolder_; |
| const char* what() const throw(); |
| }; |
| |
| void swap(InvalidRequestException &a, InvalidRequestException &b); |
| |
| inline std::ostream& operator<<(std::ostream& out, const InvalidRequestException& obj) |
| { |
| obj.printTo(out); |
| return out; |
| } |
| |
| |
| class TimedOutException : public ::apache::thrift::TException { |
| public: |
| |
| TimedOutException(const TimedOutException&); |
| TimedOutException& operator=(const TimedOutException&); |
| 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; |
| |
| virtual void printTo(std::ostream& out) const; |
| mutable std::string thriftTExceptionMessageHolder_; |
| const char* what() const throw(); |
| }; |
| |
| void swap(TimedOutException &a, TimedOutException &b); |
| |
| inline std::ostream& operator<<(std::ostream& out, const TimedOutException& obj) |
| { |
| obj.printTo(out); |
| return out; |
| } |
| |
| |
| class AuthenticationException : public ::apache::thrift::TException { |
| public: |
| |
| AuthenticationException(const AuthenticationException&); |
| AuthenticationException& operator=(const AuthenticationException&); |
| AuthenticationException() : message() { |
| } |
| |
| virtual ~AuthenticationException() throw(); |
| std::string message; |
| |
| void __set_message(const std::string& 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; |
| |
| virtual void printTo(std::ostream& out) const; |
| mutable std::string thriftTExceptionMessageHolder_; |
| const char* what() const throw(); |
| }; |
| |
| void swap(AuthenticationException &a, AuthenticationException &b); |
| |
| inline std::ostream& operator<<(std::ostream& out, const AuthenticationException& obj) |
| { |
| obj.printTo(out); |
| return out; |
| } |
| |
| |
| class AuthorizationException : public ::apache::thrift::TException { |
| public: |
| |
| AuthorizationException(const AuthorizationException&); |
| AuthorizationException& operator=(const AuthorizationException&); |
| AuthorizationException() : message() { |
| } |
| |
| virtual ~AuthorizationException() throw(); |
| std::string message; |
| |
| void __set_message(const std::string& 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; |
| |
| virtual void printTo(std::ostream& out) const; |
| mutable std::string thriftTExceptionMessageHolder_; |
| const char* what() const throw(); |
| }; |
| |
| void swap(AuthorizationException &a, AuthorizationException &b); |
| |
| inline std::ostream& operator<<(std::ostream& out, const AuthorizationException& obj) |
| { |
| obj.printTo(out); |
| return out; |
| } |
| |
| typedef struct _AiravataClientException__isset { |
| _AiravataClientException__isset() : parameter(false) {} |
| bool parameter :1; |
| } _AiravataClientException__isset; |
| |
| class AiravataClientException : public ::apache::thrift::TException { |
| public: |
| |
| AiravataClientException(const AiravataClientException&); |
| AiravataClientException& operator=(const AiravataClientException&); |
| 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); |
| |
| void __set_parameter(const std::string& val); |
| |
| 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; |
| |
| virtual void printTo(std::ostream& out) const; |
| mutable std::string thriftTExceptionMessageHolder_; |
| const char* what() const throw(); |
| }; |
| |
| void swap(AiravataClientException &a, AiravataClientException &b); |
| |
| inline std::ostream& operator<<(std::ostream& out, const AiravataClientException& obj) |
| { |
| obj.printTo(out); |
| return out; |
| } |
| |
| typedef struct _ValidatorResult__isset { |
| _ValidatorResult__isset() : errorDetails(false) {} |
| bool errorDetails :1; |
| } _ValidatorResult__isset; |
| |
| class ValidatorResult { |
| public: |
| |
| ValidatorResult(const ValidatorResult&); |
| ValidatorResult& operator=(const ValidatorResult&); |
| ValidatorResult() : result(0), errorDetails() { |
| } |
| |
| virtual ~ValidatorResult() throw(); |
| bool result; |
| std::string errorDetails; |
| |
| _ValidatorResult__isset __isset; |
| |
| void __set_result(const bool val); |
| |
| void __set_errorDetails(const std::string& val); |
| |
| 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; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(ValidatorResult &a, ValidatorResult &b); |
| |
| inline std::ostream& operator<<(std::ostream& out, const ValidatorResult& obj) |
| { |
| obj.printTo(out); |
| return out; |
| } |
| |
| |
| class ValidationResults { |
| public: |
| |
| ValidationResults(const ValidationResults&); |
| ValidationResults& operator=(const ValidationResults&); |
| ValidationResults() : validationState(0) { |
| } |
| |
| virtual ~ValidationResults() throw(); |
| bool validationState; |
| std::vector<ValidatorResult> validationResultList; |
| |
| void __set_validationState(const bool val); |
| |
| void __set_validationResultList(const std::vector<ValidatorResult> & 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; |
| |
| virtual void printTo(std::ostream& out) const; |
| }; |
| |
| void swap(ValidationResults &a, ValidationResults &b); |
| |
| inline std::ostream& operator<<(std::ostream& out, const ValidationResults& obj) |
| { |
| obj.printTo(out); |
| return out; |
| } |
| |
| typedef struct _LaunchValidationException__isset { |
| _LaunchValidationException__isset() : errorMessage(false) {} |
| bool errorMessage :1; |
| } _LaunchValidationException__isset; |
| |
| class LaunchValidationException : public ::apache::thrift::TException { |
| public: |
| |
| LaunchValidationException(const LaunchValidationException&); |
| LaunchValidationException& operator=(const LaunchValidationException&); |
| LaunchValidationException() : errorMessage() { |
| } |
| |
| virtual ~LaunchValidationException() throw(); |
| ValidationResults validationResult; |
| std::string errorMessage; |
| |
| _LaunchValidationException__isset __isset; |
| |
| void __set_validationResult(const ValidationResults& val); |
| |
| void __set_errorMessage(const std::string& val); |
| |
| 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; |
| |
| virtual void printTo(std::ostream& out) const; |
| mutable std::string thriftTExceptionMessageHolder_; |
| const char* what() const throw(); |
| }; |
| |
| void swap(LaunchValidationException &a, LaunchValidationException &b); |
| |
| inline std::ostream& operator<<(std::ostream& out, const LaunchValidationException& obj) |
| { |
| obj.printTo(out); |
| return out; |
| } |
| |
| typedef struct _AiravataSystemException__isset { |
| _AiravataSystemException__isset() : message(false) {} |
| bool message :1; |
| } _AiravataSystemException__isset; |
| |
| class AiravataSystemException : public ::apache::thrift::TException { |
| public: |
| |
| AiravataSystemException(const AiravataSystemException&); |
| AiravataSystemException& operator=(const AiravataSystemException&); |
| 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); |
| |
| void __set_message(const std::string& val); |
| |
| 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; |
| |
| virtual void printTo(std::ostream& out) const; |
| mutable std::string thriftTExceptionMessageHolder_; |
| const char* what() const throw(); |
| }; |
| |
| void swap(AiravataSystemException &a, AiravataSystemException &b); |
| |
| inline std::ostream& operator<<(std::ostream& out, const AiravataSystemException& obj) |
| { |
| obj.printTo(out); |
| return out; |
| } |
| |
| |
| class DataManagerServiceException : public ::apache::thrift::TException { |
| public: |
| |
| DataManagerServiceException(const DataManagerServiceException&); |
| DataManagerServiceException& operator=(const DataManagerServiceException&); |
| DataManagerServiceException() : message() { |
| } |
| |
| virtual ~DataManagerServiceException() throw(); |
| std::string message; |
| |
| void __set_message(const std::string& val); |
| |
| bool operator == (const DataManagerServiceException & rhs) const |
| { |
| if (!(message == rhs.message)) |
| return false; |
| return true; |
| } |
| bool operator != (const DataManagerServiceException &rhs) const { |
| return !(*this == rhs); |
| } |
| |
| bool operator < (const DataManagerServiceException & ) 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 throw(); |
| }; |
| |
| void swap(DataManagerServiceException &a, DataManagerServiceException &b); |
| |
| inline std::ostream& operator<<(std::ostream& out, const DataManagerServiceException& obj) |
| { |
| obj.printTo(out); |
| return out; |
| } |
| |
| }}}} // namespace |
| |
| #endif |