Return-Path: X-Original-To: archive-asf-public-internal@cust-asf2.ponee.io Delivered-To: archive-asf-public-internal@cust-asf2.ponee.io Received: from cust-asf.ponee.io (cust-asf.ponee.io [163.172.22.183]) by cust-asf2.ponee.io (Postfix) with ESMTP id F31712009DC for ; Tue, 2 May 2017 21:59:02 +0200 (CEST) Received: by cust-asf.ponee.io (Postfix) id F1CC8160B9D; Tue, 2 May 2017 19:59:02 +0000 (UTC) Delivered-To: archive-asf-public@cust-asf.ponee.io Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by cust-asf.ponee.io (Postfix) with SMTP id 1610E160BCD for ; Tue, 2 May 2017 21:59:00 +0200 (CEST) Received: (qmail 87153 invoked by uid 500); 2 May 2017 19:59:00 -0000 Mailing-List: contact commits-help@airavata.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: dev@airavata.apache.org Delivered-To: mailing list commits@airavata.apache.org Received: (qmail 86450 invoked by uid 99); 2 May 2017 19:58:59 -0000 Received: from git1-us-west.apache.org (HELO git1-us-west.apache.org) (140.211.11.23) by apache.org (qpsmtpd/0.29) with ESMTP; Tue, 02 May 2017 19:58:59 +0000 Received: by git1-us-west.apache.org (ASF Mail Server at git1-us-west.apache.org, from userid 33) id ADC7CE1794; Tue, 2 May 2017 19:58:59 +0000 (UTC) Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: goshenoy@apache.org To: commits@airavata.apache.org Date: Tue, 02 May 2017 19:59:11 -0000 Message-Id: <42824f8515d74fcfa9ef8f3db295e59b@git.apache.org> In-Reply-To: <1e7163b967a34d1db080a755d7de3bc8@git.apache.org> References: <1e7163b967a34d1db080a755d7de3bc8@git.apache.org> X-Mailer: ASF-Git Admin Mailer Subject: [13/17] airavata git commit: Add Tenant Profile Thrift Model archived-at: Tue, 02 May 2017 19:59:03 -0000 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(this->validationResultList.size())); - std::vector ::const_iterator _iter22; - for (_iter22 = this->validationResultList.begin(); _iter22 != this->validationResultList.end(); ++_iter22) + std::vector ::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 +#include + +#include + + + +int _kCrudTypeValues[] = { + CrudType::CREATE, + CrudType::READ, + CrudType::UPDATE, + CrudType::DELETE +}; +const char* _kCrudTypeNames[] = { + "CREATE", + "READ", + "UPDATE", + "DELETE" +}; +const std::map _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 _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 _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 + +#include +#include +#include +#include + +#include + + + + +struct CrudType { + enum type { + CREATE = 0, + READ = 1, + UPDATE = 2, + DELETE = 3 + }; +}; + +extern const std::map _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 _EntityType_VALUES_TO_NAMES; + +struct DBEventType { + enum type { + PUBLISHER = 0, + SUBSCRIBER = 1 + }; +}; + +extern const std::map _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 _MessageType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(8, _kMessageTypeValues, _kMessageTypeNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL)); +const std::map _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 }; };