You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@airavata.apache.org by sm...@apache.org on 2015/07/21 06:41:58 UTC
[15/44] airavata git commit: changing few API methods to adhere to
security solution.
http://git-wip-us.apache.org/repos/asf/airavata/blob/dc524490/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/airavata_data_models_types.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/airavata_data_models_types.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/airavata_data_models_types.h
new file mode 100644
index 0000000..88946ff
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/airavata_data_models_types.h
@@ -0,0 +1,52 @@
+/**
+ * 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.2)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+#ifndef airavata_data_models_TYPES_H
+#define airavata_data_models_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 "airavata_commons_types.h"
+#include "workspace_model_types.h"
+#include "airavata_errors_types.h"
+#include "messaging_events_types.h"
+#include "security_model_types.h"
+#include "experiment_model_types.h"
+#include "job_model_types.h"
+#include "task_model_types.h"
+#include "process_model_types.h"
+#include "scheduling_model_types.h"
+#include "status_models_types.h"
+
+
+namespace apache { namespace airavata { namespace model {
+
+}}} // namespace
+
+#endif
http://git-wip-us.apache.org/repos/asf/airavata/blob/dc524490/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/airavata_errors_constants.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/airavata_errors_constants.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/airavata_errors_constants.cpp
new file mode 100644
index 0000000..078ca39
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/airavata_errors_constants.cpp
@@ -0,0 +1,34 @@
+/**
+ * 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.2)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+#include "airavata_errors_constants.h"
+
+namespace apache { namespace airavata { namespace api { namespace error {
+
+const airavata_errorsConstants g_airavata_errors_constants;
+
+airavata_errorsConstants::airavata_errorsConstants() {
+}
+
+}}}} // namespace
+
http://git-wip-us.apache.org/repos/asf/airavata/blob/dc524490/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/airavata_errors_constants.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/airavata_errors_constants.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/airavata_errors_constants.h
new file mode 100644
index 0000000..9f80fcb
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/airavata_errors_constants.h
@@ -0,0 +1,41 @@
+/**
+ * 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.2)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+#ifndef airavata_errors_CONSTANTS_H
+#define airavata_errors_CONSTANTS_H
+
+#include "airavata_errors_types.h"
+
+namespace apache { namespace airavata { namespace api { namespace error {
+
+class airavata_errorsConstants {
+ public:
+ airavata_errorsConstants();
+
+};
+
+extern const airavata_errorsConstants g_airavata_errors_constants;
+
+}}}} // namespace
+
+#endif
http://git-wip-us.apache.org/repos/asf/airavata/blob/dc524490/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/airavata_errors_types.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/airavata_errors_types.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/airavata_errors_types.cpp
new file mode 100644
index 0000000..de38fb2
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/airavata_errors_types.cpp
@@ -0,0 +1,1169 @@
+/**
+ * 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.2)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+#include "airavata_errors_types.h"
+
+#include <algorithm>
+#include <ostream>
+
+#include <thrift/TToString.h>
+
+namespace apache { namespace airavata { namespace api { namespace error {
+
+int _kAiravataErrorTypeValues[] = {
+ AiravataErrorType::UNKNOWN,
+ AiravataErrorType::PERMISSION_DENIED,
+ AiravataErrorType::INTERNAL_ERROR,
+ AiravataErrorType::AUTHENTICATION_FAILURE,
+ AiravataErrorType::INVALID_AUTHORIZATION,
+ AiravataErrorType::AUTHORIZATION_EXPIRED,
+ AiravataErrorType::UNKNOWN_GATEWAY_ID,
+ AiravataErrorType::UNSUPPORTED_OPERATION
+};
+const char* _kAiravataErrorTypeNames[] = {
+ "UNKNOWN",
+ "PERMISSION_DENIED",
+ "INTERNAL_ERROR",
+ "AUTHENTICATION_FAILURE",
+ "INVALID_AUTHORIZATION",
+ "AUTHORIZATION_EXPIRED",
+ "UNKNOWN_GATEWAY_ID",
+ "UNSUPPORTED_OPERATION"
+};
+const std::map<int, const char*> _AiravataErrorType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(8, _kAiravataErrorTypeValues, _kAiravataErrorTypeNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
+
+
+ExperimentNotFoundException::~ExperimentNotFoundException() throw() {
+}
+
+
+void ExperimentNotFoundException::__set_message(const std::string& val) {
+ this->message = val;
+}
+
+const char* ExperimentNotFoundException::ascii_fingerprint = "EFB929595D312AC8F305D5A794CFEDA1";
+const uint8_t ExperimentNotFoundException::binary_fingerprint[16] = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
+
+uint32_t ExperimentNotFoundException::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_message = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->message);
+ isset_message = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_message)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t ExperimentNotFoundException::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ oprot->incrementRecursionDepth();
+ xfer += oprot->writeStructBegin("ExperimentNotFoundException");
+
+ xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->message);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ oprot->decrementRecursionDepth();
+ return xfer;
+}
+
+void swap(ExperimentNotFoundException &a, ExperimentNotFoundException &b) {
+ using ::std::swap;
+ swap(a.message, b.message);
+}
+
+ExperimentNotFoundException::ExperimentNotFoundException(const ExperimentNotFoundException& other0) : TException() {
+ message = other0.message;
+}
+ExperimentNotFoundException& ExperimentNotFoundException::operator=(const ExperimentNotFoundException& other1) {
+ message = other1.message;
+ return *this;
+}
+std::ostream& operator<<(std::ostream& out, const ExperimentNotFoundException& obj) {
+ using apache::thrift::to_string;
+ out << "ExperimentNotFoundException(";
+ out << "message=" << to_string(obj.message);
+ out << ")";
+ return out;
+}
+
+
+ProjectNotFoundException::~ProjectNotFoundException() throw() {
+}
+
+
+void ProjectNotFoundException::__set_message(const std::string& val) {
+ this->message = val;
+}
+
+const char* ProjectNotFoundException::ascii_fingerprint = "EFB929595D312AC8F305D5A794CFEDA1";
+const uint8_t ProjectNotFoundException::binary_fingerprint[16] = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
+
+uint32_t ProjectNotFoundException::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_message = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->message);
+ isset_message = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_message)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t ProjectNotFoundException::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ oprot->incrementRecursionDepth();
+ xfer += oprot->writeStructBegin("ProjectNotFoundException");
+
+ xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->message);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ oprot->decrementRecursionDepth();
+ return xfer;
+}
+
+void swap(ProjectNotFoundException &a, ProjectNotFoundException &b) {
+ using ::std::swap;
+ swap(a.message, b.message);
+}
+
+ProjectNotFoundException::ProjectNotFoundException(const ProjectNotFoundException& other2) : TException() {
+ message = other2.message;
+}
+ProjectNotFoundException& ProjectNotFoundException::operator=(const ProjectNotFoundException& other3) {
+ message = other3.message;
+ return *this;
+}
+std::ostream& operator<<(std::ostream& out, const ProjectNotFoundException& obj) {
+ using apache::thrift::to_string;
+ out << "ProjectNotFoundException(";
+ out << "message=" << to_string(obj.message);
+ out << ")";
+ return out;
+}
+
+
+InvalidRequestException::~InvalidRequestException() throw() {
+}
+
+
+void InvalidRequestException::__set_message(const std::string& val) {
+ this->message = val;
+}
+
+const char* InvalidRequestException::ascii_fingerprint = "EFB929595D312AC8F305D5A794CFEDA1";
+const uint8_t InvalidRequestException::binary_fingerprint[16] = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
+
+uint32_t InvalidRequestException::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_message = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->message);
+ isset_message = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_message)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t InvalidRequestException::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ oprot->incrementRecursionDepth();
+ xfer += oprot->writeStructBegin("InvalidRequestException");
+
+ xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->message);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ oprot->decrementRecursionDepth();
+ return xfer;
+}
+
+void swap(InvalidRequestException &a, InvalidRequestException &b) {
+ using ::std::swap;
+ swap(a.message, b.message);
+}
+
+InvalidRequestException::InvalidRequestException(const InvalidRequestException& other4) : TException() {
+ message = other4.message;
+}
+InvalidRequestException& InvalidRequestException::operator=(const InvalidRequestException& other5) {
+ message = other5.message;
+ return *this;
+}
+std::ostream& operator<<(std::ostream& out, const InvalidRequestException& obj) {
+ using apache::thrift::to_string;
+ out << "InvalidRequestException(";
+ out << "message=" << to_string(obj.message);
+ out << ")";
+ return out;
+}
+
+
+TimedOutException::~TimedOutException() throw() {
+}
+
+
+const char* TimedOutException::ascii_fingerprint = "99914B932BD37A50B983C5E7C90AE93B";
+const uint8_t TimedOutException::binary_fingerprint[16] = {0x99,0x91,0x4B,0x93,0x2B,0xD3,0x7A,0x50,0xB9,0x83,0xC5,0xE7,0xC9,0x0A,0xE9,0x3B};
+
+uint32_t TimedOutException::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ xfer += iprot->skip(ftype);
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t TimedOutException::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ oprot->incrementRecursionDepth();
+ xfer += oprot->writeStructBegin("TimedOutException");
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ oprot->decrementRecursionDepth();
+ return xfer;
+}
+
+void swap(TimedOutException &a, TimedOutException &b) {
+ using ::std::swap;
+ (void) a;
+ (void) b;
+}
+
+TimedOutException::TimedOutException(const TimedOutException& other6) : TException() {
+ (void) other6;
+}
+TimedOutException& TimedOutException::operator=(const TimedOutException& other7) {
+ (void) other7;
+ return *this;
+}
+std::ostream& operator<<(std::ostream& out, const TimedOutException& obj) {
+ using apache::thrift::to_string;
+ (void) obj;
+ out << "TimedOutException(";
+ out << ")";
+ return out;
+}
+
+
+AuthenticationException::~AuthenticationException() throw() {
+}
+
+
+void AuthenticationException::__set_message(const std::string& val) {
+ this->message = val;
+}
+
+const char* AuthenticationException::ascii_fingerprint = "EFB929595D312AC8F305D5A794CFEDA1";
+const uint8_t AuthenticationException::binary_fingerprint[16] = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
+
+uint32_t AuthenticationException::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_message = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->message);
+ isset_message = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_message)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t AuthenticationException::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ oprot->incrementRecursionDepth();
+ xfer += oprot->writeStructBegin("AuthenticationException");
+
+ xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->message);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ oprot->decrementRecursionDepth();
+ return xfer;
+}
+
+void swap(AuthenticationException &a, AuthenticationException &b) {
+ using ::std::swap;
+ swap(a.message, b.message);
+}
+
+AuthenticationException::AuthenticationException(const AuthenticationException& other8) : TException() {
+ message = other8.message;
+}
+AuthenticationException& AuthenticationException::operator=(const AuthenticationException& other9) {
+ message = other9.message;
+ return *this;
+}
+std::ostream& operator<<(std::ostream& out, const AuthenticationException& obj) {
+ using apache::thrift::to_string;
+ out << "AuthenticationException(";
+ out << "message=" << to_string(obj.message);
+ out << ")";
+ return out;
+}
+
+
+AuthorizationException::~AuthorizationException() throw() {
+}
+
+
+void AuthorizationException::__set_message(const std::string& val) {
+ this->message = val;
+}
+
+const char* AuthorizationException::ascii_fingerprint = "EFB929595D312AC8F305D5A794CFEDA1";
+const uint8_t AuthorizationException::binary_fingerprint[16] = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
+
+uint32_t AuthorizationException::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_message = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->message);
+ isset_message = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_message)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t AuthorizationException::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ oprot->incrementRecursionDepth();
+ xfer += oprot->writeStructBegin("AuthorizationException");
+
+ xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->message);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ oprot->decrementRecursionDepth();
+ return xfer;
+}
+
+void swap(AuthorizationException &a, AuthorizationException &b) {
+ using ::std::swap;
+ swap(a.message, b.message);
+}
+
+AuthorizationException::AuthorizationException(const AuthorizationException& other10) : TException() {
+ message = other10.message;
+}
+AuthorizationException& AuthorizationException::operator=(const AuthorizationException& other11) {
+ message = other11.message;
+ return *this;
+}
+std::ostream& operator<<(std::ostream& out, const AuthorizationException& obj) {
+ using apache::thrift::to_string;
+ out << "AuthorizationException(";
+ out << "message=" << to_string(obj.message);
+ out << ")";
+ return out;
+}
+
+
+AiravataClientException::~AiravataClientException() throw() {
+}
+
+
+void AiravataClientException::__set_airavataErrorType(const AiravataErrorType::type val) {
+ this->airavataErrorType = val;
+}
+
+void AiravataClientException::__set_parameter(const std::string& val) {
+ this->parameter = val;
+__isset.parameter = true;
+}
+
+const char* AiravataClientException::ascii_fingerprint = "24652790C81ECE22B629CB60A19F1E93";
+const uint8_t AiravataClientException::binary_fingerprint[16] = {0x24,0x65,0x27,0x90,0xC8,0x1E,0xCE,0x22,0xB6,0x29,0xCB,0x60,0xA1,0x9F,0x1E,0x93};
+
+uint32_t AiravataClientException::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_airavataErrorType = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ int32_t ecast12;
+ xfer += iprot->readI32(ecast12);
+ this->airavataErrorType = (AiravataErrorType::type)ecast12;
+ isset_airavataErrorType = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->parameter);
+ this->__isset.parameter = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_airavataErrorType)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t AiravataClientException::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ oprot->incrementRecursionDepth();
+ xfer += oprot->writeStructBegin("AiravataClientException");
+
+ xfer += oprot->writeFieldBegin("airavataErrorType", ::apache::thrift::protocol::T_I32, 1);
+ xfer += oprot->writeI32((int32_t)this->airavataErrorType);
+ xfer += oprot->writeFieldEnd();
+
+ if (this->__isset.parameter) {
+ xfer += oprot->writeFieldBegin("parameter", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->parameter);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ oprot->decrementRecursionDepth();
+ return xfer;
+}
+
+void swap(AiravataClientException &a, AiravataClientException &b) {
+ using ::std::swap;
+ swap(a.airavataErrorType, b.airavataErrorType);
+ swap(a.parameter, b.parameter);
+ swap(a.__isset, b.__isset);
+}
+
+AiravataClientException::AiravataClientException(const AiravataClientException& other13) : TException() {
+ airavataErrorType = other13.airavataErrorType;
+ parameter = other13.parameter;
+ __isset = other13.__isset;
+}
+AiravataClientException& AiravataClientException::operator=(const AiravataClientException& other14) {
+ airavataErrorType = other14.airavataErrorType;
+ parameter = other14.parameter;
+ __isset = other14.__isset;
+ return *this;
+}
+std::ostream& operator<<(std::ostream& out, const AiravataClientException& obj) {
+ using apache::thrift::to_string;
+ out << "AiravataClientException(";
+ out << "airavataErrorType=" << to_string(obj.airavataErrorType);
+ out << ", " << "parameter="; (obj.__isset.parameter ? (out << to_string(obj.parameter)) : (out << "<null>"));
+ out << ")";
+ return out;
+}
+
+
+ValidatorResult::~ValidatorResult() throw() {
+}
+
+
+void ValidatorResult::__set_result(const bool val) {
+ this->result = val;
+}
+
+void ValidatorResult::__set_errorDetails(const std::string& val) {
+ this->errorDetails = val;
+__isset.errorDetails = true;
+}
+
+const char* ValidatorResult::ascii_fingerprint = "EB04A806CFFC9025AEE48CFFDC378A86";
+const uint8_t ValidatorResult::binary_fingerprint[16] = {0xEB,0x04,0xA8,0x06,0xCF,0xFC,0x90,0x25,0xAE,0xE4,0x8C,0xFF,0xDC,0x37,0x8A,0x86};
+
+uint32_t ValidatorResult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_result = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->result);
+ isset_result = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->errorDetails);
+ this->__isset.errorDetails = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_result)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t ValidatorResult::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ oprot->incrementRecursionDepth();
+ xfer += oprot->writeStructBegin("ValidatorResult");
+
+ xfer += oprot->writeFieldBegin("result", ::apache::thrift::protocol::T_BOOL, 1);
+ xfer += oprot->writeBool(this->result);
+ xfer += oprot->writeFieldEnd();
+
+ if (this->__isset.errorDetails) {
+ xfer += oprot->writeFieldBegin("errorDetails", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->errorDetails);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ oprot->decrementRecursionDepth();
+ return xfer;
+}
+
+void swap(ValidatorResult &a, ValidatorResult &b) {
+ using ::std::swap;
+ swap(a.result, b.result);
+ swap(a.errorDetails, b.errorDetails);
+ swap(a.__isset, b.__isset);
+}
+
+ValidatorResult::ValidatorResult(const ValidatorResult& other15) {
+ result = other15.result;
+ errorDetails = other15.errorDetails;
+ __isset = other15.__isset;
+}
+ValidatorResult& ValidatorResult::operator=(const ValidatorResult& other16) {
+ result = other16.result;
+ errorDetails = other16.errorDetails;
+ __isset = other16.__isset;
+ return *this;
+}
+std::ostream& operator<<(std::ostream& out, const ValidatorResult& obj) {
+ using apache::thrift::to_string;
+ out << "ValidatorResult(";
+ out << "result=" << to_string(obj.result);
+ out << ", " << "errorDetails="; (obj.__isset.errorDetails ? (out << to_string(obj.errorDetails)) : (out << "<null>"));
+ out << ")";
+ return out;
+}
+
+
+ValidationResults::~ValidationResults() throw() {
+}
+
+
+void ValidationResults::__set_validationState(const bool val) {
+ this->validationState = val;
+}
+
+void ValidationResults::__set_validationResultList(const std::vector<ValidatorResult> & val) {
+ this->validationResultList = val;
+}
+
+const char* ValidationResults::ascii_fingerprint = "E73BC8630EE405DA5FB801ED852143D2";
+const uint8_t ValidationResults::binary_fingerprint[16] = {0xE7,0x3B,0xC8,0x63,0x0E,0xE4,0x05,0xDA,0x5F,0xB8,0x01,0xED,0x85,0x21,0x43,0xD2};
+
+uint32_t ValidationResults::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_validationState = false;
+ bool isset_validationResultList = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->validationState);
+ isset_validationState = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->validationResultList.clear();
+ uint32_t _size17;
+ ::apache::thrift::protocol::TType _etype20;
+ xfer += iprot->readListBegin(_etype20, _size17);
+ this->validationResultList.resize(_size17);
+ uint32_t _i21;
+ for (_i21 = 0; _i21 < _size17; ++_i21)
+ {
+ xfer += this->validationResultList[_i21].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ isset_validationResultList = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_validationState)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_validationResultList)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t ValidationResults::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ oprot->incrementRecursionDepth();
+ xfer += oprot->writeStructBegin("ValidationResults");
+
+ xfer += oprot->writeFieldBegin("validationState", ::apache::thrift::protocol::T_BOOL, 1);
+ xfer += oprot->writeBool(this->validationState);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("validationResultList", ::apache::thrift::protocol::T_LIST, 2);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->validationResultList.size()));
+ std::vector<ValidatorResult> ::const_iterator _iter22;
+ for (_iter22 = this->validationResultList.begin(); _iter22 != this->validationResultList.end(); ++_iter22)
+ {
+ xfer += (*_iter22).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ oprot->decrementRecursionDepth();
+ return xfer;
+}
+
+void swap(ValidationResults &a, ValidationResults &b) {
+ using ::std::swap;
+ swap(a.validationState, b.validationState);
+ swap(a.validationResultList, b.validationResultList);
+}
+
+ValidationResults::ValidationResults(const ValidationResults& other23) {
+ validationState = other23.validationState;
+ validationResultList = other23.validationResultList;
+}
+ValidationResults& ValidationResults::operator=(const ValidationResults& other24) {
+ validationState = other24.validationState;
+ validationResultList = other24.validationResultList;
+ return *this;
+}
+std::ostream& operator<<(std::ostream& out, const ValidationResults& obj) {
+ using apache::thrift::to_string;
+ out << "ValidationResults(";
+ out << "validationState=" << to_string(obj.validationState);
+ out << ", " << "validationResultList=" << to_string(obj.validationResultList);
+ out << ")";
+ return out;
+}
+
+
+LaunchValidationException::~LaunchValidationException() throw() {
+}
+
+
+void LaunchValidationException::__set_validationResult(const ValidationResults& val) {
+ this->validationResult = val;
+}
+
+void LaunchValidationException::__set_errorMessage(const std::string& val) {
+ this->errorMessage = val;
+__isset.errorMessage = true;
+}
+
+const char* LaunchValidationException::ascii_fingerprint = "99E9D28CC9613B8567277FD2B86021FA";
+const uint8_t LaunchValidationException::binary_fingerprint[16] = {0x99,0xE9,0xD2,0x8C,0xC9,0x61,0x3B,0x85,0x67,0x27,0x7F,0xD2,0xB8,0x60,0x21,0xFA};
+
+uint32_t LaunchValidationException::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_validationResult = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->validationResult.read(iprot);
+ isset_validationResult = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->errorMessage);
+ this->__isset.errorMessage = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_validationResult)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t LaunchValidationException::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ oprot->incrementRecursionDepth();
+ xfer += oprot->writeStructBegin("LaunchValidationException");
+
+ xfer += oprot->writeFieldBegin("validationResult", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->validationResult.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ if (this->__isset.errorMessage) {
+ xfer += oprot->writeFieldBegin("errorMessage", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->errorMessage);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ oprot->decrementRecursionDepth();
+ return xfer;
+}
+
+void swap(LaunchValidationException &a, LaunchValidationException &b) {
+ using ::std::swap;
+ swap(a.validationResult, b.validationResult);
+ swap(a.errorMessage, b.errorMessage);
+ swap(a.__isset, b.__isset);
+}
+
+LaunchValidationException::LaunchValidationException(const LaunchValidationException& other25) : TException() {
+ validationResult = other25.validationResult;
+ errorMessage = other25.errorMessage;
+ __isset = other25.__isset;
+}
+LaunchValidationException& LaunchValidationException::operator=(const LaunchValidationException& other26) {
+ validationResult = other26.validationResult;
+ errorMessage = other26.errorMessage;
+ __isset = other26.__isset;
+ return *this;
+}
+std::ostream& operator<<(std::ostream& out, const LaunchValidationException& obj) {
+ using apache::thrift::to_string;
+ out << "LaunchValidationException(";
+ out << "validationResult=" << to_string(obj.validationResult);
+ out << ", " << "errorMessage="; (obj.__isset.errorMessage ? (out << to_string(obj.errorMessage)) : (out << "<null>"));
+ out << ")";
+ return out;
+}
+
+
+AiravataSystemException::~AiravataSystemException() throw() {
+}
+
+
+void AiravataSystemException::__set_airavataErrorType(const AiravataErrorType::type val) {
+ this->airavataErrorType = val;
+}
+
+void AiravataSystemException::__set_message(const std::string& val) {
+ this->message = val;
+__isset.message = true;
+}
+
+const char* AiravataSystemException::ascii_fingerprint = "24652790C81ECE22B629CB60A19F1E93";
+const uint8_t AiravataSystemException::binary_fingerprint[16] = {0x24,0x65,0x27,0x90,0xC8,0x1E,0xCE,0x22,0xB6,0x29,0xCB,0x60,0xA1,0x9F,0x1E,0x93};
+
+uint32_t AiravataSystemException::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_airavataErrorType = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ int32_t ecast27;
+ xfer += iprot->readI32(ecast27);
+ this->airavataErrorType = (AiravataErrorType::type)ecast27;
+ isset_airavataErrorType = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->message);
+ this->__isset.message = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_airavataErrorType)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t AiravataSystemException::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ oprot->incrementRecursionDepth();
+ xfer += oprot->writeStructBegin("AiravataSystemException");
+
+ xfer += oprot->writeFieldBegin("airavataErrorType", ::apache::thrift::protocol::T_I32, 1);
+ xfer += oprot->writeI32((int32_t)this->airavataErrorType);
+ xfer += oprot->writeFieldEnd();
+
+ if (this->__isset.message) {
+ xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->message);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ oprot->decrementRecursionDepth();
+ return xfer;
+}
+
+void swap(AiravataSystemException &a, AiravataSystemException &b) {
+ using ::std::swap;
+ swap(a.airavataErrorType, b.airavataErrorType);
+ swap(a.message, b.message);
+ swap(a.__isset, b.__isset);
+}
+
+AiravataSystemException::AiravataSystemException(const AiravataSystemException& other28) : TException() {
+ airavataErrorType = other28.airavataErrorType;
+ message = other28.message;
+ __isset = other28.__isset;
+}
+AiravataSystemException& AiravataSystemException::operator=(const AiravataSystemException& other29) {
+ airavataErrorType = other29.airavataErrorType;
+ message = other29.message;
+ __isset = other29.__isset;
+ return *this;
+}
+std::ostream& operator<<(std::ostream& out, const AiravataSystemException& obj) {
+ using apache::thrift::to_string;
+ out << "AiravataSystemException(";
+ out << "airavataErrorType=" << to_string(obj.airavataErrorType);
+ out << ", " << "message="; (obj.__isset.message ? (out << to_string(obj.message)) : (out << "<null>"));
+ out << ")";
+ return out;
+}
+
+}}}} // namespace
http://git-wip-us.apache.org/repos/asf/airavata/blob/dc524490/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/airavata_errors_types.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/airavata_errors_types.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/airavata_errors_types.h
new file mode 100644
index 0000000..6ae818d
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/airavata_errors_types.h
@@ -0,0 +1,538 @@
+/**
+ * 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.2)
+ *
+ * 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 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(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;
+
+ friend std::ostream& operator<<(std::ostream& out, const ExperimentNotFoundException& obj);
+};
+
+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(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;
+
+ friend std::ostream& operator<<(std::ostream& out, const ProjectNotFoundException& obj);
+};
+
+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(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;
+
+ friend std::ostream& operator<<(std::ostream& out, const InvalidRequestException& obj);
+};
+
+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(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;
+
+ friend std::ostream& operator<<(std::ostream& out, const TimedOutException& obj);
+};
+
+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(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;
+
+ friend std::ostream& operator<<(std::ostream& out, const AuthenticationException& obj);
+};
+
+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(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;
+
+ friend std::ostream& operator<<(std::ostream& out, const AuthorizationException& obj);
+};
+
+void swap(AuthorizationException &a, AuthorizationException &b);
+
+typedef struct _AiravataClientException__isset {
+ _AiravataClientException__isset() : parameter(false) {}
+ bool parameter :1;
+} _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(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;
+
+ friend std::ostream& operator<<(std::ostream& out, const AiravataClientException& obj);
+};
+
+void swap(AiravataClientException &a, AiravataClientException &b);
+
+typedef struct _ValidatorResult__isset {
+ _ValidatorResult__isset() : errorDetails(false) {}
+ bool errorDetails :1;
+} _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(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;
+
+ friend std::ostream& operator<<(std::ostream& out, const ValidatorResult& obj);
+};
+
+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(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;
+
+ friend std::ostream& operator<<(std::ostream& out, const ValidationResults& obj);
+};
+
+void swap(ValidationResults &a, ValidationResults &b);
+
+typedef struct _LaunchValidationException__isset {
+ _LaunchValidationException__isset() : errorMessage(false) {}
+ bool errorMessage :1;
+} _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(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;
+
+ friend std::ostream& operator<<(std::ostream& out, const LaunchValidationException& obj);
+};
+
+void swap(LaunchValidationException &a, LaunchValidationException &b);
+
+typedef struct _AiravataSystemException__isset {
+ _AiravataSystemException__isset() : message(false) {}
+ bool message :1;
+} _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(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;
+
+ friend std::ostream& operator<<(std::ostream& out, const AiravataSystemException& obj);
+};
+
+void swap(AiravataSystemException &a, AiravataSystemException &b);
+
+}}}} // namespace
+
+#endif
http://git-wip-us.apache.org/repos/asf/airavata/blob/dc524490/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/application_deployment_model_constants.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/application_deployment_model_constants.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/application_deployment_model_constants.cpp
new file mode 100644
index 0000000..2229772
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/application_deployment_model_constants.cpp
@@ -0,0 +1,34 @@
+/**
+ * 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.2)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+#include "application_deployment_model_constants.h"
+
+namespace apache { namespace airavata { namespace model { namespace appcatalog { namespace appdeployment {
+
+const application_deployment_modelConstants g_application_deployment_model_constants;
+
+application_deployment_modelConstants::application_deployment_modelConstants() {
+}
+
+}}}}} // namespace
+
http://git-wip-us.apache.org/repos/asf/airavata/blob/dc524490/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/application_deployment_model_constants.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/application_deployment_model_constants.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/application_deployment_model_constants.h
new file mode 100644
index 0000000..7c78282
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/application_deployment_model_constants.h
@@ -0,0 +1,41 @@
+/**
+ * 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.2)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+#ifndef application_deployment_model_CONSTANTS_H
+#define application_deployment_model_CONSTANTS_H
+
+#include "application_deployment_model_types.h"
+
+namespace apache { namespace airavata { namespace model { namespace appcatalog { namespace appdeployment {
+
+class application_deployment_modelConstants {
+ public:
+ application_deployment_modelConstants();
+
+};
+
+extern const application_deployment_modelConstants g_application_deployment_model_constants;
+
+}}}}} // namespace
+
+#endif