airavata-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sma...@apache.org
Subject [14/50] [abbrv] airavata git commit: Add Tenant Profile Thrift Model
Date Tue, 16 May 2017 15:50:03 GMT
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
   };
 };
 


Mime
View raw message