You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@airavata.apache.org by go...@apache.org on 2017/05/02 19:59:11 UTC
[13/17] airavata git commit: Add Tenant Profile Thrift Model
http://git-wip-us.apache.org/repos/asf/airavata/blob/ddb95c12/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
index 12cfa2a..469b9b4 100644
--- 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
@@ -37,6 +37,7 @@
#include "airavata_errors_types.h"
#include "messaging_events_types.h"
#include "security_model_types.h"
+#include "db_event_model_types.h"
#include "experiment_model_types.h"
#include "job_model_types.h"
#include "task_model_types.h"
@@ -47,6 +48,7 @@
#include "replica_catalog_models_types.h"
#include "user_profile_model_types.h"
#include "group_manager_model_types.h"
+#include "tenant_profile_model_types.h"
#include "credential_store_data_models_types.h"
http://git-wip-us.apache.org/repos/asf/airavata/blob/ddb95c12/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
index 08c02cf..589de8e 100644
--- 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
@@ -611,6 +611,103 @@ const char* AuthorizationException::what() const throw() {
}
+DuplicateEntryException::~DuplicateEntryException() throw() {
+}
+
+
+void DuplicateEntryException::__set_message(const std::string& val) {
+ this->message = val;
+}
+
+uint32_t DuplicateEntryException::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ apache::thrift::protocol::TInputRecursionTracker tracker(*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 DuplicateEntryException::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("DuplicateEntryException");
+
+ xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->message);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(DuplicateEntryException &a, DuplicateEntryException &b) {
+ using ::std::swap;
+ swap(a.message, b.message);
+}
+
+DuplicateEntryException::DuplicateEntryException(const DuplicateEntryException& other12) : TException() {
+ message = other12.message;
+}
+DuplicateEntryException& DuplicateEntryException::operator=(const DuplicateEntryException& other13) {
+ message = other13.message;
+ return *this;
+}
+void DuplicateEntryException::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "DuplicateEntryException(";
+ out << "message=" << to_string(message);
+ out << ")";
+}
+
+const char* DuplicateEntryException::what() const throw() {
+ try {
+ std::stringstream ss;
+ ss << "TException - service has thrown: " << *this;
+ this->thriftTExceptionMessageHolder_ = ss.str();
+ return this->thriftTExceptionMessageHolder_.c_str();
+ } catch (const std::exception&) {
+ return "TException - service has thrown: DuplicateEntryException";
+ }
+}
+
+
AiravataClientException::~AiravataClientException() throw() {
}
@@ -648,9 +745,9 @@ uint32_t AiravataClientException::read(::apache::thrift::protocol::TProtocol* ip
{
case 1:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast12;
- xfer += iprot->readI32(ecast12);
- this->airavataErrorType = (AiravataErrorType::type)ecast12;
+ int32_t ecast14;
+ xfer += iprot->readI32(ecast14);
+ this->airavataErrorType = (AiravataErrorType::type)ecast14;
isset_airavataErrorType = true;
} else {
xfer += iprot->skip(ftype);
@@ -704,15 +801,15 @@ void swap(AiravataClientException &a, AiravataClientException &b) {
swap(a.__isset, b.__isset);
}
-AiravataClientException::AiravataClientException(const AiravataClientException& other13) : TException() {
- airavataErrorType = other13.airavataErrorType;
- parameter = other13.parameter;
- __isset = other13.__isset;
+AiravataClientException::AiravataClientException(const AiravataClientException& other15) : TException() {
+ airavataErrorType = other15.airavataErrorType;
+ parameter = other15.parameter;
+ __isset = other15.__isset;
}
-AiravataClientException& AiravataClientException::operator=(const AiravataClientException& other14) {
- airavataErrorType = other14.airavataErrorType;
- parameter = other14.parameter;
- __isset = other14.__isset;
+AiravataClientException& AiravataClientException::operator=(const AiravataClientException& other16) {
+ airavataErrorType = other16.airavataErrorType;
+ parameter = other16.parameter;
+ __isset = other16.__isset;
return *this;
}
void AiravataClientException::printTo(std::ostream& out) const {
@@ -826,15 +923,15 @@ void swap(ValidatorResult &a, ValidatorResult &b) {
swap(a.__isset, b.__isset);
}
-ValidatorResult::ValidatorResult(const ValidatorResult& other15) {
- result = other15.result;
- errorDetails = other15.errorDetails;
- __isset = other15.__isset;
+ValidatorResult::ValidatorResult(const ValidatorResult& other17) {
+ result = other17.result;
+ errorDetails = other17.errorDetails;
+ __isset = other17.__isset;
}
-ValidatorResult& ValidatorResult::operator=(const ValidatorResult& other16) {
- result = other16.result;
- errorDetails = other16.errorDetails;
- __isset = other16.__isset;
+ValidatorResult& ValidatorResult::operator=(const ValidatorResult& other18) {
+ result = other18.result;
+ errorDetails = other18.errorDetails;
+ __isset = other18.__isset;
return *this;
}
void ValidatorResult::printTo(std::ostream& out) const {
@@ -893,14 +990,14 @@ uint32_t ValidationResults::read(::apache::thrift::protocol::TProtocol* iprot) {
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)
+ uint32_t _size19;
+ ::apache::thrift::protocol::TType _etype22;
+ xfer += iprot->readListBegin(_etype22, _size19);
+ this->validationResultList.resize(_size19);
+ uint32_t _i23;
+ for (_i23 = 0; _i23 < _size19; ++_i23)
{
- xfer += this->validationResultList[_i21].read(iprot);
+ xfer += this->validationResultList[_i23].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -937,10 +1034,10 @@ uint32_t ValidationResults::write(::apache::thrift::protocol::TProtocol* oprot)
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)
+ std::vector<ValidatorResult> ::const_iterator _iter24;
+ for (_iter24 = this->validationResultList.begin(); _iter24 != this->validationResultList.end(); ++_iter24)
{
- xfer += (*_iter22).write(oprot);
+ xfer += (*_iter24).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -957,13 +1054,13 @@ void swap(ValidationResults &a, ValidationResults &b) {
swap(a.validationResultList, b.validationResultList);
}
-ValidationResults::ValidationResults(const ValidationResults& other23) {
- validationState = other23.validationState;
- validationResultList = other23.validationResultList;
+ValidationResults::ValidationResults(const ValidationResults& other25) {
+ validationState = other25.validationState;
+ validationResultList = other25.validationResultList;
}
-ValidationResults& ValidationResults::operator=(const ValidationResults& other24) {
- validationState = other24.validationState;
- validationResultList = other24.validationResultList;
+ValidationResults& ValidationResults::operator=(const ValidationResults& other26) {
+ validationState = other26.validationState;
+ validationResultList = other26.validationResultList;
return *this;
}
void ValidationResults::printTo(std::ostream& out) const {
@@ -1066,15 +1163,15 @@ void swap(LaunchValidationException &a, LaunchValidationException &b) {
swap(a.__isset, b.__isset);
}
-LaunchValidationException::LaunchValidationException(const LaunchValidationException& other25) : TException() {
- validationResult = other25.validationResult;
- errorMessage = other25.errorMessage;
- __isset = other25.__isset;
+LaunchValidationException::LaunchValidationException(const LaunchValidationException& other27) : TException() {
+ validationResult = other27.validationResult;
+ errorMessage = other27.errorMessage;
+ __isset = other27.__isset;
}
-LaunchValidationException& LaunchValidationException::operator=(const LaunchValidationException& other26) {
- validationResult = other26.validationResult;
- errorMessage = other26.errorMessage;
- __isset = other26.__isset;
+LaunchValidationException& LaunchValidationException::operator=(const LaunchValidationException& other28) {
+ validationResult = other28.validationResult;
+ errorMessage = other28.errorMessage;
+ __isset = other28.__isset;
return *this;
}
void LaunchValidationException::printTo(std::ostream& out) const {
@@ -1134,9 +1231,9 @@ uint32_t AiravataSystemException::read(::apache::thrift::protocol::TProtocol* ip
{
case 1:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast27;
- xfer += iprot->readI32(ecast27);
- this->airavataErrorType = (AiravataErrorType::type)ecast27;
+ int32_t ecast29;
+ xfer += iprot->readI32(ecast29);
+ this->airavataErrorType = (AiravataErrorType::type)ecast29;
isset_airavataErrorType = true;
} else {
xfer += iprot->skip(ftype);
@@ -1190,15 +1287,15 @@ void swap(AiravataSystemException &a, AiravataSystemException &b) {
swap(a.__isset, b.__isset);
}
-AiravataSystemException::AiravataSystemException(const AiravataSystemException& other28) : TException() {
- airavataErrorType = other28.airavataErrorType;
- message = other28.message;
- __isset = other28.__isset;
+AiravataSystemException::AiravataSystemException(const AiravataSystemException& other30) : TException() {
+ airavataErrorType = other30.airavataErrorType;
+ message = other30.message;
+ __isset = other30.__isset;
}
-AiravataSystemException& AiravataSystemException::operator=(const AiravataSystemException& other29) {
- airavataErrorType = other29.airavataErrorType;
- message = other29.message;
- __isset = other29.__isset;
+AiravataSystemException& AiravataSystemException::operator=(const AiravataSystemException& other31) {
+ airavataErrorType = other31.airavataErrorType;
+ message = other31.message;
+ __isset = other31.__isset;
return *this;
}
void AiravataSystemException::printTo(std::ostream& out) const {
http://git-wip-us.apache.org/repos/asf/airavata/blob/ddb95c12/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
index e756d0a..daa533d 100644
--- 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
@@ -64,6 +64,8 @@ class AuthenticationException;
class AuthorizationException;
+class DuplicateEntryException;
+
class AiravataClientException;
class ValidatorResult;
@@ -321,6 +323,48 @@ inline std::ostream& operator<<(std::ostream& out, const AuthorizationException&
return out;
}
+
+class DuplicateEntryException : public ::apache::thrift::TException {
+ public:
+
+ DuplicateEntryException(const DuplicateEntryException&);
+ DuplicateEntryException& operator=(const DuplicateEntryException&);
+ DuplicateEntryException() : message() {
+ }
+
+ virtual ~DuplicateEntryException() throw();
+ std::string message;
+
+ void __set_message(const std::string& val);
+
+ bool operator == (const DuplicateEntryException & rhs) const
+ {
+ if (!(message == rhs.message))
+ return false;
+ return true;
+ }
+ bool operator != (const DuplicateEntryException &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const DuplicateEntryException & ) 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(DuplicateEntryException &a, DuplicateEntryException &b);
+
+inline std::ostream& operator<<(std::ostream& out, const DuplicateEntryException& obj)
+{
+ obj.printTo(out);
+ return out;
+}
+
typedef struct _AiravataClientException__isset {
_AiravataClientException__isset() : parameter(false) {}
bool parameter :1;
http://git-wip-us.apache.org/repos/asf/airavata/blob/ddb95c12/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/db_event_model_constants.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/db_event_model_constants.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/db_event_model_constants.cpp
new file mode 100644
index 0000000..f752436
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/db_event_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.3)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+#include "db_event_model_constants.h"
+
+
+
+const db_event_modelConstants g_db_event_model_constants;
+
+db_event_modelConstants::db_event_modelConstants() {
+}
+
+
+
http://git-wip-us.apache.org/repos/asf/airavata/blob/ddb95c12/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/db_event_model_constants.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/db_event_model_constants.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/db_event_model_constants.h
new file mode 100644
index 0000000..15a5a75
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/db_event_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.3)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+#ifndef db_event_model_CONSTANTS_H
+#define db_event_model_CONSTANTS_H
+
+#include "db_event_model_types.h"
+
+
+
+class db_event_modelConstants {
+ public:
+ db_event_modelConstants();
+
+};
+
+extern const db_event_modelConstants g_db_event_model_constants;
+
+
+
+#endif
http://git-wip-us.apache.org/repos/asf/airavata/blob/ddb95c12/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/db_event_model_types.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/db_event_model_types.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/db_event_model_types.cpp
new file mode 100644
index 0000000..fdac10d
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/db_event_model_types.cpp
@@ -0,0 +1,627 @@
+/**
+ * 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
+ */
+#include "db_event_model_types.h"
+
+#include <algorithm>
+#include <ostream>
+
+#include <thrift/TToString.h>
+
+
+
+int _kCrudTypeValues[] = {
+ CrudType::CREATE,
+ CrudType::READ,
+ CrudType::UPDATE,
+ CrudType::DELETE
+};
+const char* _kCrudTypeNames[] = {
+ "CREATE",
+ "READ",
+ "UPDATE",
+ "DELETE"
+};
+const std::map<int, const char*> _CrudType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(4, _kCrudTypeValues, _kCrudTypeNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
+
+int _kEntityTypeValues[] = {
+ EntityType::USER_PROFILE,
+ EntityType::TENANT,
+ EntityType::GROUP,
+ EntityType::PROJECT,
+ EntityType::EXPERIMENT,
+ EntityType::APPLICATION,
+ EntityType::SHARING,
+ EntityType::REGISTRY
+};
+const char* _kEntityTypeNames[] = {
+ "USER_PROFILE",
+ "TENANT",
+ "GROUP",
+ "PROJECT",
+ "EXPERIMENT",
+ "APPLICATION",
+ "SHARING",
+ "REGISTRY"
+};
+const std::map<int, const char*> _EntityType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(8, _kEntityTypeValues, _kEntityTypeNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
+
+int _kDBEventTypeValues[] = {
+ DBEventType::PUBLISHER,
+ DBEventType::SUBSCRIBER
+};
+const char* _kDBEventTypeNames[] = {
+ "PUBLISHER",
+ "SUBSCRIBER"
+};
+const std::map<int, const char*> _DBEventType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(2, _kDBEventTypeValues, _kDBEventTypeNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
+
+
+DBEventPublisherContext::~DBEventPublisherContext() throw() {
+}
+
+
+void DBEventPublisherContext::__set_crudType(const CrudType::type val) {
+ this->crudType = val;
+}
+
+void DBEventPublisherContext::__set_entityType(const EntityType::type val) {
+ this->entityType = val;
+}
+
+void DBEventPublisherContext::__set_entityDataModel(const std::string& val) {
+ this->entityDataModel = val;
+}
+
+uint32_t DBEventPublisherContext::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ apache::thrift::protocol::TInputRecursionTracker tracker(*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_crudType = false;
+ bool isset_entityType = false;
+ bool isset_entityDataModel = 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 ecast0;
+ xfer += iprot->readI32(ecast0);
+ this->crudType = (CrudType::type)ecast0;
+ isset_crudType = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ int32_t ecast1;
+ xfer += iprot->readI32(ecast1);
+ this->entityType = (EntityType::type)ecast1;
+ isset_entityType = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readBinary(this->entityDataModel);
+ isset_entityDataModel = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_crudType)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_entityType)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_entityDataModel)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t DBEventPublisherContext::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("DBEventPublisherContext");
+
+ xfer += oprot->writeFieldBegin("crudType", ::apache::thrift::protocol::T_I32, 1);
+ xfer += oprot->writeI32((int32_t)this->crudType);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("entityType", ::apache::thrift::protocol::T_I32, 2);
+ xfer += oprot->writeI32((int32_t)this->entityType);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("entityDataModel", ::apache::thrift::protocol::T_STRING, 3);
+ xfer += oprot->writeBinary(this->entityDataModel);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(DBEventPublisherContext &a, DBEventPublisherContext &b) {
+ using ::std::swap;
+ swap(a.crudType, b.crudType);
+ swap(a.entityType, b.entityType);
+ swap(a.entityDataModel, b.entityDataModel);
+}
+
+DBEventPublisherContext::DBEventPublisherContext(const DBEventPublisherContext& other2) {
+ crudType = other2.crudType;
+ entityType = other2.entityType;
+ entityDataModel = other2.entityDataModel;
+}
+DBEventPublisherContext& DBEventPublisherContext::operator=(const DBEventPublisherContext& other3) {
+ crudType = other3.crudType;
+ entityType = other3.entityType;
+ entityDataModel = other3.entityDataModel;
+ return *this;
+}
+void DBEventPublisherContext::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "DBEventPublisherContext(";
+ out << "crudType=" << to_string(crudType);
+ out << ", " << "entityType=" << to_string(entityType);
+ out << ", " << "entityDataModel=" << to_string(entityDataModel);
+ out << ")";
+}
+
+
+DBEventPublisher::~DBEventPublisher() throw() {
+}
+
+
+void DBEventPublisher::__set_publisherContext(const DBEventPublisherContext& val) {
+ this->publisherContext = val;
+}
+
+uint32_t DBEventPublisher::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ apache::thrift::protocol::TInputRecursionTracker tracker(*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_publisherContext = 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->publisherContext.read(iprot);
+ isset_publisherContext = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_publisherContext)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t DBEventPublisher::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("DBEventPublisher");
+
+ xfer += oprot->writeFieldBegin("publisherContext", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->publisherContext.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(DBEventPublisher &a, DBEventPublisher &b) {
+ using ::std::swap;
+ swap(a.publisherContext, b.publisherContext);
+}
+
+DBEventPublisher::DBEventPublisher(const DBEventPublisher& other4) {
+ publisherContext = other4.publisherContext;
+}
+DBEventPublisher& DBEventPublisher::operator=(const DBEventPublisher& other5) {
+ publisherContext = other5.publisherContext;
+ return *this;
+}
+void DBEventPublisher::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "DBEventPublisher(";
+ out << "publisherContext=" << to_string(publisherContext);
+ out << ")";
+}
+
+
+DBEventSubscriber::~DBEventSubscriber() throw() {
+}
+
+
+void DBEventSubscriber::__set_subscriberService(const std::string& val) {
+ this->subscriberService = val;
+}
+
+uint32_t DBEventSubscriber::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ apache::thrift::protocol::TInputRecursionTracker tracker(*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_subscriberService = 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->subscriberService);
+ isset_subscriberService = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_subscriberService)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t DBEventSubscriber::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("DBEventSubscriber");
+
+ xfer += oprot->writeFieldBegin("subscriberService", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->subscriberService);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(DBEventSubscriber &a, DBEventSubscriber &b) {
+ using ::std::swap;
+ swap(a.subscriberService, b.subscriberService);
+}
+
+DBEventSubscriber::DBEventSubscriber(const DBEventSubscriber& other6) {
+ subscriberService = other6.subscriberService;
+}
+DBEventSubscriber& DBEventSubscriber::operator=(const DBEventSubscriber& other7) {
+ subscriberService = other7.subscriberService;
+ return *this;
+}
+void DBEventSubscriber::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "DBEventSubscriber(";
+ out << "subscriberService=" << to_string(subscriberService);
+ out << ")";
+}
+
+
+DBEventMessageContext::~DBEventMessageContext() throw() {
+}
+
+
+void DBEventMessageContext::__set_publisher(const DBEventPublisher& val) {
+ this->publisher = val;
+}
+
+void DBEventMessageContext::__set_subscriber(const DBEventSubscriber& val) {
+ this->subscriber = val;
+}
+
+uint32_t DBEventMessageContext::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ apache::thrift::protocol::TInputRecursionTracker tracker(*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;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->publisher.read(iprot);
+ this->__isset.publisher = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->subscriber.read(iprot);
+ this->__isset.subscriber = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t DBEventMessageContext::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("DBEventMessageContext");
+
+ xfer += oprot->writeFieldBegin("publisher", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->publisher.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("subscriber", ::apache::thrift::protocol::T_STRUCT, 2);
+ xfer += this->subscriber.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(DBEventMessageContext &a, DBEventMessageContext &b) {
+ using ::std::swap;
+ swap(a.publisher, b.publisher);
+ swap(a.subscriber, b.subscriber);
+ swap(a.__isset, b.__isset);
+}
+
+DBEventMessageContext::DBEventMessageContext(const DBEventMessageContext& other8) {
+ publisher = other8.publisher;
+ subscriber = other8.subscriber;
+ __isset = other8.__isset;
+}
+DBEventMessageContext& DBEventMessageContext::operator=(const DBEventMessageContext& other9) {
+ publisher = other9.publisher;
+ subscriber = other9.subscriber;
+ __isset = other9.__isset;
+ return *this;
+}
+void DBEventMessageContext::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "DBEventMessageContext(";
+ out << "publisher=" << to_string(publisher);
+ out << ", " << "subscriber=" << to_string(subscriber);
+ out << ")";
+}
+
+
+DBEventMessage::~DBEventMessage() throw() {
+}
+
+
+void DBEventMessage::__set_dbEventType(const DBEventType::type val) {
+ this->dbEventType = val;
+}
+
+void DBEventMessage::__set_messageContext(const DBEventMessageContext& val) {
+ this->messageContext = val;
+}
+
+void DBEventMessage::__set_publisherService(const std::string& val) {
+ this->publisherService = val;
+}
+
+uint32_t DBEventMessage::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ apache::thrift::protocol::TInputRecursionTracker tracker(*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_dbEventType = false;
+ bool isset_messageContext = false;
+ bool isset_publisherService = 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 ecast10;
+ xfer += iprot->readI32(ecast10);
+ this->dbEventType = (DBEventType::type)ecast10;
+ isset_dbEventType = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->messageContext.read(iprot);
+ isset_messageContext = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->publisherService);
+ isset_publisherService = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_dbEventType)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_messageContext)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_publisherService)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t DBEventMessage::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("DBEventMessage");
+
+ xfer += oprot->writeFieldBegin("dbEventType", ::apache::thrift::protocol::T_I32, 1);
+ xfer += oprot->writeI32((int32_t)this->dbEventType);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("messageContext", ::apache::thrift::protocol::T_STRUCT, 2);
+ xfer += this->messageContext.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("publisherService", ::apache::thrift::protocol::T_STRING, 3);
+ xfer += oprot->writeString(this->publisherService);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(DBEventMessage &a, DBEventMessage &b) {
+ using ::std::swap;
+ swap(a.dbEventType, b.dbEventType);
+ swap(a.messageContext, b.messageContext);
+ swap(a.publisherService, b.publisherService);
+}
+
+DBEventMessage::DBEventMessage(const DBEventMessage& other11) {
+ dbEventType = other11.dbEventType;
+ messageContext = other11.messageContext;
+ publisherService = other11.publisherService;
+}
+DBEventMessage& DBEventMessage::operator=(const DBEventMessage& other12) {
+ dbEventType = other12.dbEventType;
+ messageContext = other12.messageContext;
+ publisherService = other12.publisherService;
+ return *this;
+}
+void DBEventMessage::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "DBEventMessage(";
+ out << "dbEventType=" << to_string(dbEventType);
+ out << ", " << "messageContext=" << to_string(messageContext);
+ out << ", " << "publisherService=" << to_string(publisherService);
+ out << ")";
+}
+
+
http://git-wip-us.apache.org/repos/asf/airavata/blob/ddb95c12/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/db_event_model_types.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/db_event_model_types.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/db_event_model_types.h
new file mode 100644
index 0000000..43d9508
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/db_event_model_types.h
@@ -0,0 +1,318 @@
+/**
+ * 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 db_event_model_TYPES_H
+#define db_event_model_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>
+
+
+
+
+struct CrudType {
+ enum type {
+ CREATE = 0,
+ READ = 1,
+ UPDATE = 2,
+ DELETE = 3
+ };
+};
+
+extern const std::map<int, const char*> _CrudType_VALUES_TO_NAMES;
+
+struct EntityType {
+ enum type {
+ USER_PROFILE = 0,
+ TENANT = 1,
+ GROUP = 2,
+ PROJECT = 3,
+ EXPERIMENT = 4,
+ APPLICATION = 5,
+ SHARING = 6,
+ REGISTRY = 7
+ };
+};
+
+extern const std::map<int, const char*> _EntityType_VALUES_TO_NAMES;
+
+struct DBEventType {
+ enum type {
+ PUBLISHER = 0,
+ SUBSCRIBER = 1
+ };
+};
+
+extern const std::map<int, const char*> _DBEventType_VALUES_TO_NAMES;
+
+class DBEventPublisherContext;
+
+class DBEventPublisher;
+
+class DBEventSubscriber;
+
+class DBEventMessageContext;
+
+class DBEventMessage;
+
+
+class DBEventPublisherContext {
+ public:
+
+ DBEventPublisherContext(const DBEventPublisherContext&);
+ DBEventPublisherContext& operator=(const DBEventPublisherContext&);
+ DBEventPublisherContext() : crudType((CrudType::type)0), entityType((EntityType::type)0), entityDataModel() {
+ }
+
+ virtual ~DBEventPublisherContext() throw();
+ CrudType::type crudType;
+ EntityType::type entityType;
+ std::string entityDataModel;
+
+ void __set_crudType(const CrudType::type val);
+
+ void __set_entityType(const EntityType::type val);
+
+ void __set_entityDataModel(const std::string& val);
+
+ bool operator == (const DBEventPublisherContext & rhs) const
+ {
+ if (!(crudType == rhs.crudType))
+ return false;
+ if (!(entityType == rhs.entityType))
+ return false;
+ if (!(entityDataModel == rhs.entityDataModel))
+ return false;
+ return true;
+ }
+ bool operator != (const DBEventPublisherContext &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const DBEventPublisherContext & ) 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(DBEventPublisherContext &a, DBEventPublisherContext &b);
+
+inline std::ostream& operator<<(std::ostream& out, const DBEventPublisherContext& obj)
+{
+ obj.printTo(out);
+ return out;
+}
+
+
+class DBEventPublisher {
+ public:
+
+ DBEventPublisher(const DBEventPublisher&);
+ DBEventPublisher& operator=(const DBEventPublisher&);
+ DBEventPublisher() {
+ }
+
+ virtual ~DBEventPublisher() throw();
+ DBEventPublisherContext publisherContext;
+
+ void __set_publisherContext(const DBEventPublisherContext& val);
+
+ bool operator == (const DBEventPublisher & rhs) const
+ {
+ if (!(publisherContext == rhs.publisherContext))
+ return false;
+ return true;
+ }
+ bool operator != (const DBEventPublisher &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const DBEventPublisher & ) 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(DBEventPublisher &a, DBEventPublisher &b);
+
+inline std::ostream& operator<<(std::ostream& out, const DBEventPublisher& obj)
+{
+ obj.printTo(out);
+ return out;
+}
+
+
+class DBEventSubscriber {
+ public:
+
+ DBEventSubscriber(const DBEventSubscriber&);
+ DBEventSubscriber& operator=(const DBEventSubscriber&);
+ DBEventSubscriber() : subscriberService() {
+ }
+
+ virtual ~DBEventSubscriber() throw();
+ std::string subscriberService;
+
+ void __set_subscriberService(const std::string& val);
+
+ bool operator == (const DBEventSubscriber & rhs) const
+ {
+ if (!(subscriberService == rhs.subscriberService))
+ return false;
+ return true;
+ }
+ bool operator != (const DBEventSubscriber &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const DBEventSubscriber & ) 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(DBEventSubscriber &a, DBEventSubscriber &b);
+
+inline std::ostream& operator<<(std::ostream& out, const DBEventSubscriber& obj)
+{
+ obj.printTo(out);
+ return out;
+}
+
+typedef struct _DBEventMessageContext__isset {
+ _DBEventMessageContext__isset() : publisher(false), subscriber(false) {}
+ bool publisher :1;
+ bool subscriber :1;
+} _DBEventMessageContext__isset;
+
+class DBEventMessageContext {
+ public:
+
+ DBEventMessageContext(const DBEventMessageContext&);
+ DBEventMessageContext& operator=(const DBEventMessageContext&);
+ DBEventMessageContext() {
+ }
+
+ virtual ~DBEventMessageContext() throw();
+ DBEventPublisher publisher;
+ DBEventSubscriber subscriber;
+
+ _DBEventMessageContext__isset __isset;
+
+ void __set_publisher(const DBEventPublisher& val);
+
+ void __set_subscriber(const DBEventSubscriber& val);
+
+ bool operator == (const DBEventMessageContext & rhs) const
+ {
+ if (!(publisher == rhs.publisher))
+ return false;
+ if (!(subscriber == rhs.subscriber))
+ return false;
+ return true;
+ }
+ bool operator != (const DBEventMessageContext &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const DBEventMessageContext & ) 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(DBEventMessageContext &a, DBEventMessageContext &b);
+
+inline std::ostream& operator<<(std::ostream& out, const DBEventMessageContext& obj)
+{
+ obj.printTo(out);
+ return out;
+}
+
+
+class DBEventMessage {
+ public:
+
+ DBEventMessage(const DBEventMessage&);
+ DBEventMessage& operator=(const DBEventMessage&);
+ DBEventMessage() : dbEventType((DBEventType::type)0), publisherService() {
+ }
+
+ virtual ~DBEventMessage() throw();
+ DBEventType::type dbEventType;
+ DBEventMessageContext messageContext;
+ std::string publisherService;
+
+ void __set_dbEventType(const DBEventType::type val);
+
+ void __set_messageContext(const DBEventMessageContext& val);
+
+ void __set_publisherService(const std::string& val);
+
+ bool operator == (const DBEventMessage & rhs) const
+ {
+ if (!(dbEventType == rhs.dbEventType))
+ return false;
+ if (!(messageContext == rhs.messageContext))
+ return false;
+ if (!(publisherService == rhs.publisherService))
+ return false;
+ return true;
+ }
+ bool operator != (const DBEventMessage &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const DBEventMessage & ) 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(DBEventMessage &a, DBEventMessage &b);
+
+inline std::ostream& operator<<(std::ostream& out, const DBEventMessage& obj)
+{
+ obj.printTo(out);
+ return out;
+}
+
+
+
+#endif
http://git-wip-us.apache.org/repos/asf/airavata/blob/ddb95c12/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/messaging_events_types.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/messaging_events_types.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/messaging_events_types.cpp
index f7d5d87..9360c83 100644
--- a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/messaging_events_types.cpp
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/messaging_events_types.cpp
@@ -52,7 +52,8 @@ int _kMessageTypeValues[] = {
MessageType::JOB,
MessageType::LAUNCHPROCESS,
MessageType::TERMINATEPROCESS,
- MessageType::PROCESSOUTPUT
+ MessageType::PROCESSOUTPUT,
+ MessageType::DB_EVENT
};
const char* _kMessageTypeNames[] = {
"EXPERIMENT",
@@ -62,9 +63,10 @@ const char* _kMessageTypeNames[] = {
"JOB",
"LAUNCHPROCESS",
"TERMINATEPROCESS",
- "PROCESSOUTPUT"
+ "PROCESSOUTPUT",
+ "DB_EVENT"
};
-const std::map<int, const char*> _MessageType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(8, _kMessageTypeValues, _kMessageTypeNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
+const std::map<int, const char*> _MessageType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(9, _kMessageTypeValues, _kMessageTypeNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
ExperimentStatusChangeEvent::~ExperimentStatusChangeEvent() throw() {
http://git-wip-us.apache.org/repos/asf/airavata/blob/ddb95c12/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/messaging_events_types.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/messaging_events_types.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/messaging_events_types.h
index 15caed1..5b2b27f 100644
--- a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/messaging_events_types.h
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/messaging_events_types.h
@@ -59,7 +59,8 @@ struct MessageType {
JOB = 4,
LAUNCHPROCESS = 5,
TERMINATEPROCESS = 6,
- PROCESSOUTPUT = 7
+ PROCESSOUTPUT = 7,
+ DB_EVENT = 8
};
};