You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@airavata.apache.org by sm...@apache.org on 2014/07/01 12:25:37 UTC
[4/6] Pointing libs to airavata SDK - AIRAVATA-1274
http://git-wip-us.apache.org/repos/asf/airavata/blob/01f648a5/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/Airavata.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/Airavata.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/Airavata.cpp
index 9ac1541..e6e36fa 100644
--- a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/Airavata.cpp
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/Airavata.cpp
@@ -5749,6 +5749,925 @@ uint32_t Airavata_terminateExperiment_presult::read(::apache::thrift::protocol::
return xfer;
}
+uint32_t Airavata_registerAppicationModule_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_applicationModule = 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->applicationModule.read(iprot);
+ isset_applicationModule = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_applicationModule)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t Airavata_registerAppicationModule_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Airavata_registerAppicationModule_args");
+
+ xfer += oprot->writeFieldBegin("applicationModule", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->applicationModule.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_registerAppicationModule_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Airavata_registerAppicationModule_pargs");
+
+ xfer += oprot->writeFieldBegin("applicationModule", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += (*(this->applicationModule)).write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_registerAppicationModule_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 0:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->success);
+ this->__isset.success = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ire.read(iprot);
+ this->__isset.ire = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ace.read(iprot);
+ this->__isset.ace = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ase.read(iprot);
+ this->__isset.ase = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Airavata_registerAppicationModule_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+ uint32_t xfer = 0;
+
+ xfer += oprot->writeStructBegin("Airavata_registerAppicationModule_result");
+
+ if (this->__isset.success) {
+ xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRING, 0);
+ xfer += oprot->writeString(this->success);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.ire) {
+ xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->ire.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.ace) {
+ xfer += oprot->writeFieldBegin("ace", ::apache::thrift::protocol::T_STRUCT, 2);
+ xfer += this->ace.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.ase) {
+ xfer += oprot->writeFieldBegin("ase", ::apache::thrift::protocol::T_STRUCT, 3);
+ xfer += this->ase.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_registerAppicationModule_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 0:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString((*(this->success)));
+ this->__isset.success = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ire.read(iprot);
+ this->__isset.ire = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ace.read(iprot);
+ this->__isset.ace = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ase.read(iprot);
+ this->__isset.ase = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Airavata_getAppicationModule_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_appModuleId = 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->appModuleId);
+ isset_appModuleId = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_appModuleId)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t Airavata_getAppicationModule_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Airavata_getAppicationModule_args");
+
+ xfer += oprot->writeFieldBegin("appModuleId", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->appModuleId);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_getAppicationModule_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Airavata_getAppicationModule_pargs");
+
+ xfer += oprot->writeFieldBegin("appModuleId", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString((*(this->appModuleId)));
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_getAppicationModule_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 0:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->success.read(iprot);
+ this->__isset.success = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ire.read(iprot);
+ this->__isset.ire = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ace.read(iprot);
+ this->__isset.ace = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ase.read(iprot);
+ this->__isset.ase = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Airavata_getAppicationModule_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+ uint32_t xfer = 0;
+
+ xfer += oprot->writeStructBegin("Airavata_getAppicationModule_result");
+
+ if (this->__isset.success) {
+ xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0);
+ xfer += this->success.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.ire) {
+ xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->ire.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.ace) {
+ xfer += oprot->writeFieldBegin("ace", ::apache::thrift::protocol::T_STRUCT, 2);
+ xfer += this->ace.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.ase) {
+ xfer += oprot->writeFieldBegin("ase", ::apache::thrift::protocol::T_STRUCT, 3);
+ xfer += this->ase.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_getAppicationModule_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 0:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += (*(this->success)).read(iprot);
+ this->__isset.success = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ire.read(iprot);
+ this->__isset.ire = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ace.read(iprot);
+ this->__isset.ace = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ase.read(iprot);
+ this->__isset.ase = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Airavata_updateAppicationModule_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_appModuleId = false;
+ bool isset_applicationModule = 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->appModuleId);
+ isset_appModuleId = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->applicationModule.read(iprot);
+ isset_applicationModule = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_appModuleId)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_applicationModule)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t Airavata_updateAppicationModule_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Airavata_updateAppicationModule_args");
+
+ xfer += oprot->writeFieldBegin("appModuleId", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->appModuleId);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("applicationModule", ::apache::thrift::protocol::T_STRUCT, 2);
+ xfer += this->applicationModule.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_updateAppicationModule_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Airavata_updateAppicationModule_pargs");
+
+ xfer += oprot->writeFieldBegin("appModuleId", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString((*(this->appModuleId)));
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("applicationModule", ::apache::thrift::protocol::T_STRUCT, 2);
+ xfer += (*(this->applicationModule)).write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_updateAppicationModule_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 0:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->success);
+ this->__isset.success = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ire.read(iprot);
+ this->__isset.ire = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ace.read(iprot);
+ this->__isset.ace = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ase.read(iprot);
+ this->__isset.ase = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Airavata_updateAppicationModule_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+ uint32_t xfer = 0;
+
+ xfer += oprot->writeStructBegin("Airavata_updateAppicationModule_result");
+
+ if (this->__isset.success) {
+ xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0);
+ xfer += oprot->writeBool(this->success);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.ire) {
+ xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->ire.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.ace) {
+ xfer += oprot->writeFieldBegin("ace", ::apache::thrift::protocol::T_STRUCT, 2);
+ xfer += this->ace.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.ase) {
+ xfer += oprot->writeFieldBegin("ase", ::apache::thrift::protocol::T_STRUCT, 3);
+ xfer += this->ase.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_updateAppicationModule_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 0:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool((*(this->success)));
+ this->__isset.success = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ire.read(iprot);
+ this->__isset.ire = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ace.read(iprot);
+ this->__isset.ace = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ase.read(iprot);
+ this->__isset.ase = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Airavata_deleteAppicationModule_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_appModuleId = 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->appModuleId);
+ isset_appModuleId = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_appModuleId)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t Airavata_deleteAppicationModule_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Airavata_deleteAppicationModule_args");
+
+ xfer += oprot->writeFieldBegin("appModuleId", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->appModuleId);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_deleteAppicationModule_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Airavata_deleteAppicationModule_pargs");
+
+ xfer += oprot->writeFieldBegin("appModuleId", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString((*(this->appModuleId)));
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_deleteAppicationModule_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 0:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->success);
+ this->__isset.success = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ire.read(iprot);
+ this->__isset.ire = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ace.read(iprot);
+ this->__isset.ace = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ase.read(iprot);
+ this->__isset.ase = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Airavata_deleteAppicationModule_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+ uint32_t xfer = 0;
+
+ xfer += oprot->writeStructBegin("Airavata_deleteAppicationModule_result");
+
+ if (this->__isset.success) {
+ xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0);
+ xfer += oprot->writeBool(this->success);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.ire) {
+ xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->ire.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.ace) {
+ xfer += oprot->writeFieldBegin("ace", ::apache::thrift::protocol::T_STRUCT, 2);
+ xfer += this->ace.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.ase) {
+ xfer += oprot->writeFieldBegin("ase", ::apache::thrift::protocol::T_STRUCT, 3);
+ xfer += this->ase.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_deleteAppicationModule_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 0:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool((*(this->success)));
+ this->__isset.success = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ire.read(iprot);
+ this->__isset.ire = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ace.read(iprot);
+ this->__isset.ace = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ase.read(iprot);
+ this->__isset.ase = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
void AiravataClient::getAPIVersion(std::string& _return)
{
send_getAPIVersion();
@@ -7146,13 +8065,274 @@ void AiravataClient::getJobStatuses(std::map<std::string, ::JobStatus> & _retur
recv_getJobStatuses(_return);
}
-void AiravataClient::send_getJobStatuses(const std::string& airavataExperimentId)
+void AiravataClient::send_getJobStatuses(const std::string& airavataExperimentId)
+{
+ int32_t cseqid = 0;
+ oprot_->writeMessageBegin("getJobStatuses", ::apache::thrift::protocol::T_CALL, cseqid);
+
+ Airavata_getJobStatuses_pargs args;
+ args.airavataExperimentId = &airavataExperimentId;
+ args.write(oprot_);
+
+ oprot_->writeMessageEnd();
+ oprot_->getTransport()->writeEnd();
+ oprot_->getTransport()->flush();
+}
+
+void AiravataClient::recv_getJobStatuses(std::map<std::string, ::JobStatus> & _return)
+{
+
+ int32_t rseqid = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TMessageType mtype;
+
+ iprot_->readMessageBegin(fname, mtype, rseqid);
+ if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+ ::apache::thrift::TApplicationException x;
+ x.read(iprot_);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ throw x;
+ }
+ if (mtype != ::apache::thrift::protocol::T_REPLY) {
+ iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ }
+ if (fname.compare("getJobStatuses") != 0) {
+ iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ }
+ Airavata_getJobStatuses_presult result;
+ result.success = &_return;
+ result.read(iprot_);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+
+ if (result.__isset.success) {
+ // _return pointer has now been filled
+ return;
+ }
+ throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getJobStatuses failed: unknown result");
+}
+
+void AiravataClient::cloneExperiment(std::string& _return, const std::string& existingExperimentID, const std::string& newExperimentName)
+{
+ send_cloneExperiment(existingExperimentID, newExperimentName);
+ recv_cloneExperiment(_return);
+}
+
+void AiravataClient::send_cloneExperiment(const std::string& existingExperimentID, const std::string& newExperimentName)
+{
+ int32_t cseqid = 0;
+ oprot_->writeMessageBegin("cloneExperiment", ::apache::thrift::protocol::T_CALL, cseqid);
+
+ Airavata_cloneExperiment_pargs args;
+ args.existingExperimentID = &existingExperimentID;
+ args.newExperimentName = &newExperimentName;
+ args.write(oprot_);
+
+ oprot_->writeMessageEnd();
+ oprot_->getTransport()->writeEnd();
+ oprot_->getTransport()->flush();
+}
+
+void AiravataClient::recv_cloneExperiment(std::string& _return)
+{
+
+ int32_t rseqid = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TMessageType mtype;
+
+ iprot_->readMessageBegin(fname, mtype, rseqid);
+ if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+ ::apache::thrift::TApplicationException x;
+ x.read(iprot_);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ throw x;
+ }
+ if (mtype != ::apache::thrift::protocol::T_REPLY) {
+ iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ }
+ if (fname.compare("cloneExperiment") != 0) {
+ iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ }
+ Airavata_cloneExperiment_presult result;
+ result.success = &_return;
+ result.read(iprot_);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+
+ if (result.__isset.success) {
+ // _return pointer has now been filled
+ return;
+ }
+ if (result.__isset.ire) {
+ throw result.ire;
+ }
+ if (result.__isset.enf) {
+ throw result.enf;
+ }
+ if (result.__isset.ace) {
+ throw result.ace;
+ }
+ if (result.__isset.ase) {
+ throw result.ase;
+ }
+ throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "cloneExperiment failed: unknown result");
+}
+
+void AiravataClient::terminateExperiment(const std::string& airavataExperimentId)
+{
+ send_terminateExperiment(airavataExperimentId);
+ recv_terminateExperiment();
+}
+
+void AiravataClient::send_terminateExperiment(const std::string& airavataExperimentId)
+{
+ int32_t cseqid = 0;
+ oprot_->writeMessageBegin("terminateExperiment", ::apache::thrift::protocol::T_CALL, cseqid);
+
+ Airavata_terminateExperiment_pargs args;
+ args.airavataExperimentId = &airavataExperimentId;
+ args.write(oprot_);
+
+ oprot_->writeMessageEnd();
+ oprot_->getTransport()->writeEnd();
+ oprot_->getTransport()->flush();
+}
+
+void AiravataClient::recv_terminateExperiment()
+{
+
+ int32_t rseqid = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TMessageType mtype;
+
+ iprot_->readMessageBegin(fname, mtype, rseqid);
+ if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+ ::apache::thrift::TApplicationException x;
+ x.read(iprot_);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ throw x;
+ }
+ if (mtype != ::apache::thrift::protocol::T_REPLY) {
+ iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ }
+ if (fname.compare("terminateExperiment") != 0) {
+ iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ }
+ Airavata_terminateExperiment_presult result;
+ result.read(iprot_);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+
+ if (result.__isset.ire) {
+ throw result.ire;
+ }
+ if (result.__isset.enf) {
+ throw result.enf;
+ }
+ if (result.__isset.ace) {
+ throw result.ace;
+ }
+ if (result.__isset.ase) {
+ throw result.ase;
+ }
+ return;
+}
+
+void AiravataClient::registerAppicationModule(std::string& _return, const ::ApplicationModule& applicationModule)
+{
+ send_registerAppicationModule(applicationModule);
+ recv_registerAppicationModule(_return);
+}
+
+void AiravataClient::send_registerAppicationModule(const ::ApplicationModule& applicationModule)
+{
+ int32_t cseqid = 0;
+ oprot_->writeMessageBegin("registerAppicationModule", ::apache::thrift::protocol::T_CALL, cseqid);
+
+ Airavata_registerAppicationModule_pargs args;
+ args.applicationModule = &applicationModule;
+ args.write(oprot_);
+
+ oprot_->writeMessageEnd();
+ oprot_->getTransport()->writeEnd();
+ oprot_->getTransport()->flush();
+}
+
+void AiravataClient::recv_registerAppicationModule(std::string& _return)
+{
+
+ int32_t rseqid = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TMessageType mtype;
+
+ iprot_->readMessageBegin(fname, mtype, rseqid);
+ if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+ ::apache::thrift::TApplicationException x;
+ x.read(iprot_);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ throw x;
+ }
+ if (mtype != ::apache::thrift::protocol::T_REPLY) {
+ iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ }
+ if (fname.compare("registerAppicationModule") != 0) {
+ iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ }
+ Airavata_registerAppicationModule_presult result;
+ result.success = &_return;
+ result.read(iprot_);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+
+ if (result.__isset.success) {
+ // _return pointer has now been filled
+ return;
+ }
+ if (result.__isset.ire) {
+ throw result.ire;
+ }
+ if (result.__isset.ace) {
+ throw result.ace;
+ }
+ if (result.__isset.ase) {
+ throw result.ase;
+ }
+ throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "registerAppicationModule failed: unknown result");
+}
+
+void AiravataClient::getAppicationModule( ::ApplicationModule& _return, const std::string& appModuleId)
+{
+ send_getAppicationModule(appModuleId);
+ recv_getAppicationModule(_return);
+}
+
+void AiravataClient::send_getAppicationModule(const std::string& appModuleId)
{
int32_t cseqid = 0;
- oprot_->writeMessageBegin("getJobStatuses", ::apache::thrift::protocol::T_CALL, cseqid);
+ oprot_->writeMessageBegin("getAppicationModule", ::apache::thrift::protocol::T_CALL, cseqid);
- Airavata_getJobStatuses_pargs args;
- args.airavataExperimentId = &airavataExperimentId;
+ Airavata_getAppicationModule_pargs args;
+ args.appModuleId = &appModuleId;
args.write(oprot_);
oprot_->writeMessageEnd();
@@ -7160,7 +8340,7 @@ void AiravataClient::send_getJobStatuses(const std::string& airavataExperimentId
oprot_->getTransport()->flush();
}
-void AiravataClient::recv_getJobStatuses(std::map<std::string, ::JobStatus> & _return)
+void AiravataClient::recv_getAppicationModule( ::ApplicationModule& _return)
{
int32_t rseqid = 0;
@@ -7180,12 +8360,12 @@ void AiravataClient::recv_getJobStatuses(std::map<std::string, ::JobStatus> & _
iprot_->readMessageEnd();
iprot_->getTransport()->readEnd();
}
- if (fname.compare("getJobStatuses") != 0) {
+ if (fname.compare("getAppicationModule") != 0) {
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
iprot_->readMessageEnd();
iprot_->getTransport()->readEnd();
}
- Airavata_getJobStatuses_presult result;
+ Airavata_getAppicationModule_presult result;
result.success = &_return;
result.read(iprot_);
iprot_->readMessageEnd();
@@ -7195,23 +8375,32 @@ void AiravataClient::recv_getJobStatuses(std::map<std::string, ::JobStatus> & _
// _return pointer has now been filled
return;
}
- throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getJobStatuses failed: unknown result");
+ if (result.__isset.ire) {
+ throw result.ire;
+ }
+ if (result.__isset.ace) {
+ throw result.ace;
+ }
+ if (result.__isset.ase) {
+ throw result.ase;
+ }
+ throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getAppicationModule failed: unknown result");
}
-void AiravataClient::cloneExperiment(std::string& _return, const std::string& existingExperimentID, const std::string& newExperimentName)
+bool AiravataClient::updateAppicationModule(const std::string& appModuleId, const ::ApplicationModule& applicationModule)
{
- send_cloneExperiment(existingExperimentID, newExperimentName);
- recv_cloneExperiment(_return);
+ send_updateAppicationModule(appModuleId, applicationModule);
+ return recv_updateAppicationModule();
}
-void AiravataClient::send_cloneExperiment(const std::string& existingExperimentID, const std::string& newExperimentName)
+void AiravataClient::send_updateAppicationModule(const std::string& appModuleId, const ::ApplicationModule& applicationModule)
{
int32_t cseqid = 0;
- oprot_->writeMessageBegin("cloneExperiment", ::apache::thrift::protocol::T_CALL, cseqid);
+ oprot_->writeMessageBegin("updateAppicationModule", ::apache::thrift::protocol::T_CALL, cseqid);
- Airavata_cloneExperiment_pargs args;
- args.existingExperimentID = &existingExperimentID;
- args.newExperimentName = &newExperimentName;
+ Airavata_updateAppicationModule_pargs args;
+ args.appModuleId = &appModuleId;
+ args.applicationModule = &applicationModule;
args.write(oprot_);
oprot_->writeMessageEnd();
@@ -7219,7 +8408,7 @@ void AiravataClient::send_cloneExperiment(const std::string& existingExperimentI
oprot_->getTransport()->flush();
}
-void AiravataClient::recv_cloneExperiment(std::string& _return)
+bool AiravataClient::recv_updateAppicationModule()
{
int32_t rseqid = 0;
@@ -7239,49 +8428,46 @@ void AiravataClient::recv_cloneExperiment(std::string& _return)
iprot_->readMessageEnd();
iprot_->getTransport()->readEnd();
}
- if (fname.compare("cloneExperiment") != 0) {
+ if (fname.compare("updateAppicationModule") != 0) {
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
iprot_->readMessageEnd();
iprot_->getTransport()->readEnd();
}
- Airavata_cloneExperiment_presult result;
+ bool _return;
+ Airavata_updateAppicationModule_presult result;
result.success = &_return;
result.read(iprot_);
iprot_->readMessageEnd();
iprot_->getTransport()->readEnd();
if (result.__isset.success) {
- // _return pointer has now been filled
- return;
+ return _return;
}
if (result.__isset.ire) {
throw result.ire;
}
- if (result.__isset.enf) {
- throw result.enf;
- }
if (result.__isset.ace) {
throw result.ace;
}
if (result.__isset.ase) {
throw result.ase;
}
- throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "cloneExperiment failed: unknown result");
+ throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "updateAppicationModule failed: unknown result");
}
-void AiravataClient::terminateExperiment(const std::string& airavataExperimentId)
+bool AiravataClient::deleteAppicationModule(const std::string& appModuleId)
{
- send_terminateExperiment(airavataExperimentId);
- recv_terminateExperiment();
+ send_deleteAppicationModule(appModuleId);
+ return recv_deleteAppicationModule();
}
-void AiravataClient::send_terminateExperiment(const std::string& airavataExperimentId)
+void AiravataClient::send_deleteAppicationModule(const std::string& appModuleId)
{
int32_t cseqid = 0;
- oprot_->writeMessageBegin("terminateExperiment", ::apache::thrift::protocol::T_CALL, cseqid);
+ oprot_->writeMessageBegin("deleteAppicationModule", ::apache::thrift::protocol::T_CALL, cseqid);
- Airavata_terminateExperiment_pargs args;
- args.airavataExperimentId = &airavataExperimentId;
+ Airavata_deleteAppicationModule_pargs args;
+ args.appModuleId = &appModuleId;
args.write(oprot_);
oprot_->writeMessageEnd();
@@ -7289,7 +8475,7 @@ void AiravataClient::send_terminateExperiment(const std::string& airavataExperim
oprot_->getTransport()->flush();
}
-void AiravataClient::recv_terminateExperiment()
+bool AiravataClient::recv_deleteAppicationModule()
{
int32_t rseqid = 0;
@@ -7309,29 +8495,31 @@ void AiravataClient::recv_terminateExperiment()
iprot_->readMessageEnd();
iprot_->getTransport()->readEnd();
}
- if (fname.compare("terminateExperiment") != 0) {
+ if (fname.compare("deleteAppicationModule") != 0) {
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
iprot_->readMessageEnd();
iprot_->getTransport()->readEnd();
}
- Airavata_terminateExperiment_presult result;
+ bool _return;
+ Airavata_deleteAppicationModule_presult result;
+ result.success = &_return;
result.read(iprot_);
iprot_->readMessageEnd();
iprot_->getTransport()->readEnd();
+ if (result.__isset.success) {
+ return _return;
+ }
if (result.__isset.ire) {
throw result.ire;
}
- if (result.__isset.enf) {
- throw result.enf;
- }
if (result.__isset.ace) {
throw result.ace;
}
if (result.__isset.ase) {
throw result.ase;
}
- return;
+ throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "deleteAppicationModule failed: unknown result");
}
bool AiravataProcessor::dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext) {
@@ -8856,6 +10044,258 @@ void AiravataProcessor::process_terminateExperiment(int32_t seqid, ::apache::thr
}
}
+void AiravataProcessor::process_registerAppicationModule(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+ void* ctx = NULL;
+ if (this->eventHandler_.get() != NULL) {
+ ctx = this->eventHandler_->getContext("Airavata.registerAppicationModule", callContext);
+ }
+ ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Airavata.registerAppicationModule");
+
+ if (this->eventHandler_.get() != NULL) {
+ this->eventHandler_->preRead(ctx, "Airavata.registerAppicationModule");
+ }
+
+ Airavata_registerAppicationModule_args args;
+ args.read(iprot);
+ iprot->readMessageEnd();
+ uint32_t bytes = iprot->getTransport()->readEnd();
+
+ if (this->eventHandler_.get() != NULL) {
+ this->eventHandler_->postRead(ctx, "Airavata.registerAppicationModule", bytes);
+ }
+
+ Airavata_registerAppicationModule_result result;
+ try {
+ iface_->registerAppicationModule(result.success, args.applicationModule);
+ result.__isset.success = true;
+ } catch ( ::airavata::api::error::InvalidRequestException &ire) {
+ result.ire = ire;
+ result.__isset.ire = true;
+ } catch ( ::airavata::api::error::AiravataClientException &ace) {
+ result.ace = ace;
+ result.__isset.ace = true;
+ } catch ( ::airavata::api::error::AiravataSystemException &ase) {
+ result.ase = ase;
+ result.__isset.ase = true;
+ } catch (const std::exception& e) {
+ if (this->eventHandler_.get() != NULL) {
+ this->eventHandler_->handlerError(ctx, "Airavata.registerAppicationModule");
+ }
+
+ ::apache::thrift::TApplicationException x(e.what());
+ oprot->writeMessageBegin("registerAppicationModule", ::apache::thrift::protocol::T_EXCEPTION, seqid);
+ x.write(oprot);
+ oprot->writeMessageEnd();
+ oprot->getTransport()->writeEnd();
+ oprot->getTransport()->flush();
+ return;
+ }
+
+ if (this->eventHandler_.get() != NULL) {
+ this->eventHandler_->preWrite(ctx, "Airavata.registerAppicationModule");
+ }
+
+ oprot->writeMessageBegin("registerAppicationModule", ::apache::thrift::protocol::T_REPLY, seqid);
+ result.write(oprot);
+ oprot->writeMessageEnd();
+ bytes = oprot->getTransport()->writeEnd();
+ oprot->getTransport()->flush();
+
+ if (this->eventHandler_.get() != NULL) {
+ this->eventHandler_->postWrite(ctx, "Airavata.registerAppicationModule", bytes);
+ }
+}
+
+void AiravataProcessor::process_getAppicationModule(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+ void* ctx = NULL;
+ if (this->eventHandler_.get() != NULL) {
+ ctx = this->eventHandler_->getContext("Airavata.getAppicationModule", callContext);
+ }
+ ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Airavata.getAppicationModule");
+
+ if (this->eventHandler_.get() != NULL) {
+ this->eventHandler_->preRead(ctx, "Airavata.getAppicationModule");
+ }
+
+ Airavata_getAppicationModule_args args;
+ args.read(iprot);
+ iprot->readMessageEnd();
+ uint32_t bytes = iprot->getTransport()->readEnd();
+
+ if (this->eventHandler_.get() != NULL) {
+ this->eventHandler_->postRead(ctx, "Airavata.getAppicationModule", bytes);
+ }
+
+ Airavata_getAppicationModule_result result;
+ try {
+ iface_->getAppicationModule(result.success, args.appModuleId);
+ result.__isset.success = true;
+ } catch ( ::airavata::api::error::InvalidRequestException &ire) {
+ result.ire = ire;
+ result.__isset.ire = true;
+ } catch ( ::airavata::api::error::AiravataClientException &ace) {
+ result.ace = ace;
+ result.__isset.ace = true;
+ } catch ( ::airavata::api::error::AiravataSystemException &ase) {
+ result.ase = ase;
+ result.__isset.ase = true;
+ } catch (const std::exception& e) {
+ if (this->eventHandler_.get() != NULL) {
+ this->eventHandler_->handlerError(ctx, "Airavata.getAppicationModule");
+ }
+
+ ::apache::thrift::TApplicationException x(e.what());
+ oprot->writeMessageBegin("getAppicationModule", ::apache::thrift::protocol::T_EXCEPTION, seqid);
+ x.write(oprot);
+ oprot->writeMessageEnd();
+ oprot->getTransport()->writeEnd();
+ oprot->getTransport()->flush();
+ return;
+ }
+
+ if (this->eventHandler_.get() != NULL) {
+ this->eventHandler_->preWrite(ctx, "Airavata.getAppicationModule");
+ }
+
+ oprot->writeMessageBegin("getAppicationModule", ::apache::thrift::protocol::T_REPLY, seqid);
+ result.write(oprot);
+ oprot->writeMessageEnd();
+ bytes = oprot->getTransport()->writeEnd();
+ oprot->getTransport()->flush();
+
+ if (this->eventHandler_.get() != NULL) {
+ this->eventHandler_->postWrite(ctx, "Airavata.getAppicationModule", bytes);
+ }
+}
+
+void AiravataProcessor::process_updateAppicationModule(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+ void* ctx = NULL;
+ if (this->eventHandler_.get() != NULL) {
+ ctx = this->eventHandler_->getContext("Airavata.updateAppicationModule", callContext);
+ }
+ ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Airavata.updateAppicationModule");
+
+ if (this->eventHandler_.get() != NULL) {
+ this->eventHandler_->preRead(ctx, "Airavata.updateAppicationModule");
+ }
+
+ Airavata_updateAppicationModule_args args;
+ args.read(iprot);
+ iprot->readMessageEnd();
+ uint32_t bytes = iprot->getTransport()->readEnd();
+
+ if (this->eventHandler_.get() != NULL) {
+ this->eventHandler_->postRead(ctx, "Airavata.updateAppicationModule", bytes);
+ }
+
+ Airavata_updateAppicationModule_result result;
+ try {
+ result.success = iface_->updateAppicationModule(args.appModuleId, args.applicationModule);
+ result.__isset.success = true;
+ } catch ( ::airavata::api::error::InvalidRequestException &ire) {
+ result.ire = ire;
+ result.__isset.ire = true;
+ } catch ( ::airavata::api::error::AiravataClientException &ace) {
+ result.ace = ace;
+ result.__isset.ace = true;
+ } catch ( ::airavata::api::error::AiravataSystemException &ase) {
+ result.ase = ase;
+ result.__isset.ase = true;
+ } catch (const std::exception& e) {
+ if (this->eventHandler_.get() != NULL) {
+ this->eventHandler_->handlerError(ctx, "Airavata.updateAppicationModule");
+ }
+
+ ::apache::thrift::TApplicationException x(e.what());
+ oprot->writeMessageBegin("updateAppicationModule", ::apache::thrift::protocol::T_EXCEPTION, seqid);
+ x.write(oprot);
+ oprot->writeMessageEnd();
+ oprot->getTransport()->writeEnd();
+ oprot->getTransport()->flush();
+ return;
+ }
+
+ if (this->eventHandler_.get() != NULL) {
+ this->eventHandler_->preWrite(ctx, "Airavata.updateAppicationModule");
+ }
+
+ oprot->writeMessageBegin("updateAppicationModule", ::apache::thrift::protocol::T_REPLY, seqid);
+ result.write(oprot);
+ oprot->writeMessageEnd();
+ bytes = oprot->getTransport()->writeEnd();
+ oprot->getTransport()->flush();
+
+ if (this->eventHandler_.get() != NULL) {
+ this->eventHandler_->postWrite(ctx, "Airavata.updateAppicationModule", bytes);
+ }
+}
+
+void AiravataProcessor::process_deleteAppicationModule(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+ void* ctx = NULL;
+ if (this->eventHandler_.get() != NULL) {
+ ctx = this->eventHandler_->getContext("Airavata.deleteAppicationModule", callContext);
+ }
+ ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Airavata.deleteAppicationModule");
+
+ if (this->eventHandler_.get() != NULL) {
+ this->eventHandler_->preRead(ctx, "Airavata.deleteAppicationModule");
+ }
+
+ Airavata_deleteAppicationModule_args args;
+ args.read(iprot);
+ iprot->readMessageEnd();
+ uint32_t bytes = iprot->getTransport()->readEnd();
+
+ if (this->eventHandler_.get() != NULL) {
+ this->eventHandler_->postRead(ctx, "Airavata.deleteAppicationModule", bytes);
+ }
+
+ Airavata_deleteAppicationModule_result result;
+ try {
+ result.success = iface_->deleteAppicationModule(args.appModuleId);
+ result.__isset.success = true;
+ } catch ( ::airavata::api::error::InvalidRequestException &ire) {
+ result.ire = ire;
+ result.__isset.ire = true;
+ } catch ( ::airavata::api::error::AiravataClientException &ace) {
+ result.ace = ace;
+ result.__isset.ace = true;
+ } catch ( ::airavata::api::error::AiravataSystemException &ase) {
+ result.ase = ase;
+ result.__isset.ase = true;
+ } catch (const std::exception& e) {
+ if (this->eventHandler_.get() != NULL) {
+ this->eventHandler_->handlerError(ctx, "Airavata.deleteAppicationModule");
+ }
+
+ ::apache::thrift::TApplicationException x(e.what());
+ oprot->writeMessageBegin("deleteAppicationModule", ::apache::thrift::protocol::T_EXCEPTION, seqid);
+ x.write(oprot);
+ oprot->writeMessageEnd();
+ oprot->getTransport()->writeEnd();
+ oprot->getTransport()->flush();
+ return;
+ }
+
+ if (this->eventHandler_.get() != NULL) {
+ this->eventHandler_->preWrite(ctx, "Airavata.deleteAppicationModule");
+ }
+
+ oprot->writeMessageBegin("deleteAppicationModule", ::apache::thrift::protocol::T_REPLY, seqid);
+ result.write(oprot);
+ oprot->writeMessageEnd();
+ bytes = oprot->getTransport()->writeEnd();
+ oprot->getTransport()->flush();
+
+ if (this->eventHandler_.get() != NULL) {
+ this->eventHandler_->postWrite(ctx, "Airavata.deleteAppicationModule", bytes);
+ }
+}
+
::boost::shared_ptr< ::apache::thrift::TProcessor > AiravataProcessorFactory::getProcessor(const ::apache::thrift::TConnectionInfo& connInfo) {
::apache::thrift::ReleaseHandler< AiravataIfFactory > cleanup(handlerFactory_);
::boost::shared_ptr< AiravataIf > handler(handlerFactory_->getHandler(connInfo), cleanup);
http://git-wip-us.apache.org/repos/asf/airavata/blob/01f648a5/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/Airavata.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/Airavata.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/Airavata.h
index 48bb219..7abf697 100644
--- a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/Airavata.h
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/Airavata.h
@@ -39,6 +39,10 @@ class AiravataIf {
virtual void getJobStatuses(std::map<std::string, ::JobStatus> & _return, const std::string& airavataExperimentId) = 0;
virtual void cloneExperiment(std::string& _return, const std::string& existingExperimentID, const std::string& newExperimentName) = 0;
virtual void terminateExperiment(const std::string& airavataExperimentId) = 0;
+ virtual void registerAppicationModule(std::string& _return, const ::ApplicationModule& applicationModule) = 0;
+ virtual void getAppicationModule( ::ApplicationModule& _return, const std::string& appModuleId) = 0;
+ virtual bool updateAppicationModule(const std::string& appModuleId, const ::ApplicationModule& applicationModule) = 0;
+ virtual bool deleteAppicationModule(const std::string& appModuleId) = 0;
};
class AiravataIfFactory {
@@ -141,6 +145,20 @@ class AiravataNull : virtual public AiravataIf {
void terminateExperiment(const std::string& /* airavataExperimentId */) {
return;
}
+ void registerAppicationModule(std::string& /* _return */, const ::ApplicationModule& /* applicationModule */) {
+ return;
+ }
+ void getAppicationModule( ::ApplicationModule& /* _return */, const std::string& /* appModuleId */) {
+ return;
+ }
+ bool updateAppicationModule(const std::string& /* appModuleId */, const ::ApplicationModule& /* applicationModule */) {
+ bool _return = false;
+ return _return;
+ }
+ bool deleteAppicationModule(const std::string& /* appModuleId */) {
+ bool _return = false;
+ return _return;
+ }
};
@@ -3314,6 +3332,542 @@ class Airavata_terminateExperiment_presult {
};
+
+class Airavata_registerAppicationModule_args {
+ public:
+
+ Airavata_registerAppicationModule_args() {
+ }
+
+ virtual ~Airavata_registerAppicationModule_args() throw() {}
+
+ ::ApplicationModule applicationModule;
+
+ void __set_applicationModule(const ::ApplicationModule& val) {
+ applicationModule = val;
+ }
+
+ bool operator == (const Airavata_registerAppicationModule_args & rhs) const
+ {
+ if (!(applicationModule == rhs.applicationModule))
+ return false;
+ return true;
+ }
+ bool operator != (const Airavata_registerAppicationModule_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Airavata_registerAppicationModule_args & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Airavata_registerAppicationModule_pargs {
+ public:
+
+
+ virtual ~Airavata_registerAppicationModule_pargs() throw() {}
+
+ const ::ApplicationModule* applicationModule;
+
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_registerAppicationModule_result__isset {
+ _Airavata_registerAppicationModule_result__isset() : success(false), ire(false), ace(false), ase(false) {}
+ bool success;
+ bool ire;
+ bool ace;
+ bool ase;
+} _Airavata_registerAppicationModule_result__isset;
+
+class Airavata_registerAppicationModule_result {
+ public:
+
+ Airavata_registerAppicationModule_result() : success() {
+ }
+
+ virtual ~Airavata_registerAppicationModule_result() throw() {}
+
+ std::string success;
+ ::airavata::api::error::InvalidRequestException ire;
+ ::airavata::api::error::AiravataClientException ace;
+ ::airavata::api::error::AiravataSystemException ase;
+
+ _Airavata_registerAppicationModule_result__isset __isset;
+
+ void __set_success(const std::string& val) {
+ success = val;
+ }
+
+ void __set_ire(const ::airavata::api::error::InvalidRequestException& val) {
+ ire = val;
+ }
+
+ void __set_ace(const ::airavata::api::error::AiravataClientException& val) {
+ ace = val;
+ }
+
+ void __set_ase(const ::airavata::api::error::AiravataSystemException& val) {
+ ase = val;
+ }
+
+ bool operator == (const Airavata_registerAppicationModule_result & rhs) const
+ {
+ if (!(success == rhs.success))
+ return false;
+ if (!(ire == rhs.ire))
+ return false;
+ if (!(ace == rhs.ace))
+ return false;
+ if (!(ase == rhs.ase))
+ return false;
+ return true;
+ }
+ bool operator != (const Airavata_registerAppicationModule_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Airavata_registerAppicationModule_result & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_registerAppicationModule_presult__isset {
+ _Airavata_registerAppicationModule_presult__isset() : success(false), ire(false), ace(false), ase(false) {}
+ bool success;
+ bool ire;
+ bool ace;
+ bool ase;
+} _Airavata_registerAppicationModule_presult__isset;
+
+class Airavata_registerAppicationModule_presult {
+ public:
+
+
+ virtual ~Airavata_registerAppicationModule_presult() throw() {}
+
+ std::string* success;
+ ::airavata::api::error::InvalidRequestException ire;
+ ::airavata::api::error::AiravataClientException ace;
+ ::airavata::api::error::AiravataSystemException ase;
+
+ _Airavata_registerAppicationModule_presult__isset __isset;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Airavata_getAppicationModule_args {
+ public:
+
+ Airavata_getAppicationModule_args() : appModuleId() {
+ }
+
+ virtual ~Airavata_getAppicationModule_args() throw() {}
+
+ std::string appModuleId;
+
+ void __set_appModuleId(const std::string& val) {
+ appModuleId = val;
+ }
+
+ bool operator == (const Airavata_getAppicationModule_args & rhs) const
+ {
+ if (!(appModuleId == rhs.appModuleId))
+ return false;
+ return true;
+ }
+ bool operator != (const Airavata_getAppicationModule_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Airavata_getAppicationModule_args & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Airavata_getAppicationModule_pargs {
+ public:
+
+
+ virtual ~Airavata_getAppicationModule_pargs() throw() {}
+
+ const std::string* appModuleId;
+
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_getAppicationModule_result__isset {
+ _Airavata_getAppicationModule_result__isset() : success(false), ire(false), ace(false), ase(false) {}
+ bool success;
+ bool ire;
+ bool ace;
+ bool ase;
+} _Airavata_getAppicationModule_result__isset;
+
+class Airavata_getAppicationModule_result {
+ public:
+
+ Airavata_getAppicationModule_result() {
+ }
+
+ virtual ~Airavata_getAppicationModule_result() throw() {}
+
+ ::ApplicationModule success;
+ ::airavata::api::error::InvalidRequestException ire;
+ ::airavata::api::error::AiravataClientException ace;
+ ::airavata::api::error::AiravataSystemException ase;
+
+ _Airavata_getAppicationModule_result__isset __isset;
+
+ void __set_success(const ::ApplicationModule& val) {
+ success = val;
+ }
+
+ void __set_ire(const ::airavata::api::error::InvalidRequestException& val) {
+ ire = val;
+ }
+
+ void __set_ace(const ::airavata::api::error::AiravataClientException& val) {
+ ace = val;
+ }
+
+ void __set_ase(const ::airavata::api::error::AiravataSystemException& val) {
+ ase = val;
+ }
+
+ bool operator == (const Airavata_getAppicationModule_result & rhs) const
+ {
+ if (!(success == rhs.success))
+ return false;
+ if (!(ire == rhs.ire))
+ return false;
+ if (!(ace == rhs.ace))
+ return false;
+ if (!(ase == rhs.ase))
+ return false;
+ return true;
+ }
+ bool operator != (const Airavata_getAppicationModule_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Airavata_getAppicationModule_result & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_getAppicationModule_presult__isset {
+ _Airavata_getAppicationModule_presult__isset() : success(false), ire(false), ace(false), ase(false) {}
+ bool success;
+ bool ire;
+ bool ace;
+ bool ase;
+} _Airavata_getAppicationModule_presult__isset;
+
+class Airavata_getAppicationModule_presult {
+ public:
+
+
+ virtual ~Airavata_getAppicationModule_presult() throw() {}
+
+ ::ApplicationModule* success;
+ ::airavata::api::error::InvalidRequestException ire;
+ ::airavata::api::error::AiravataClientException ace;
+ ::airavata::api::error::AiravataSystemException ase;
+
+ _Airavata_getAppicationModule_presult__isset __isset;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Airavata_updateAppicationModule_args {
+ public:
+
+ Airavata_updateAppicationModule_args() : appModuleId() {
+ }
+
+ virtual ~Airavata_updateAppicationModule_args() throw() {}
+
+ std::string appModuleId;
+ ::ApplicationModule applicationModule;
+
+ void __set_appModuleId(const std::string& val) {
+ appModuleId = val;
+ }
+
+ void __set_applicationModule(const ::ApplicationModule& val) {
+ applicationModule = val;
+ }
+
+ bool operator == (const Airavata_updateAppicationModule_args & rhs) const
+ {
+ if (!(appModuleId == rhs.appModuleId))
+ return false;
+ if (!(applicationModule == rhs.applicationModule))
+ return false;
+ return true;
+ }
+ bool operator != (const Airavata_updateAppicationModule_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Airavata_updateAppicationModule_args & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Airavata_updateAppicationModule_pargs {
+ public:
+
+
+ virtual ~Airavata_updateAppicationModule_pargs() throw() {}
+
+ const std::string* appModuleId;
+ const ::ApplicationModule* applicationModule;
+
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_updateAppicationModule_result__isset {
+ _Airavata_updateAppicationModule_result__isset() : success(false), ire(false), ace(false), ase(false) {}
+ bool success;
+ bool ire;
+ bool ace;
+ bool ase;
+} _Airavata_updateAppicationModule_result__isset;
+
+class Airavata_updateAppicationModule_result {
+ public:
+
+ Airavata_updateAppicationModule_result() : success(0) {
+ }
+
+ virtual ~Airavata_updateAppicationModule_result() throw() {}
+
+ bool success;
+ ::airavata::api::error::InvalidRequestException ire;
+ ::airavata::api::error::AiravataClientException ace;
+ ::airavata::api::error::AiravataSystemException ase;
+
+ _Airavata_updateAppicationModule_result__isset __isset;
+
+ void __set_success(const bool val) {
+ success = val;
+ }
+
+ void __set_ire(const ::airavata::api::error::InvalidRequestException& val) {
+ ire = val;
+ }
+
+ void __set_ace(const ::airavata::api::error::AiravataClientException& val) {
+ ace = val;
+ }
+
+ void __set_ase(const ::airavata::api::error::AiravataSystemException& val) {
+ ase = val;
+ }
+
+ bool operator == (const Airavata_updateAppicationModule_result & rhs) const
+ {
+ if (!(success == rhs.success))
+ return false;
+ if (!(ire == rhs.ire))
+ return false;
+ if (!(ace == rhs.ace))
+ return false;
+ if (!(ase == rhs.ase))
+ return false;
+ return true;
+ }
+ bool operator != (const Airavata_updateAppicationModule_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Airavata_updateAppicationModule_result & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_updateAppicationModule_presult__isset {
+ _Airavata_updateAppicationModule_presult__isset() : success(false), ire(false), ace(false), ase(false) {}
+ bool success;
+ bool ire;
+ bool ace;
+ bool ase;
+} _Airavata_updateAppicationModule_presult__isset;
+
+class Airavata_updateAppicationModule_presult {
+ public:
+
+
+ virtual ~Airavata_updateAppicationModule_presult() throw() {}
+
+ bool* success;
+ ::airavata::api::error::InvalidRequestException ire;
+ ::airavata::api::error::AiravataClientException ace;
+ ::airavata::api::error::AiravataSystemException ase;
+
+ _Airavata_updateAppicationModule_presult__isset __isset;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Airavata_deleteAppicationModule_args {
+ public:
+
+ Airavata_deleteAppicationModule_args() : appModuleId() {
+ }
+
+ virtual ~Airavata_deleteAppicationModule_args() throw() {}
+
+ std::string appModuleId;
+
+ void __set_appModuleId(const std::string& val) {
+ appModuleId = val;
+ }
+
+ bool operator == (const Airavata_deleteAppicationModule_args & rhs) const
+ {
+ if (!(appModuleId == rhs.appModuleId))
+ return false;
+ return true;
+ }
+ bool operator != (const Airavata_deleteAppicationModule_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Airavata_deleteAppicationModule_args & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Airavata_deleteAppicationModule_pargs {
+ public:
+
+
+ virtual ~Airavata_deleteAppicationModule_pargs() throw() {}
+
+ const std::string* appModuleId;
+
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_deleteAppicationModule_result__isset {
+ _Airavata_deleteAppicationModule_result__isset() : success(false), ire(false), ace(false), ase(false) {}
+ bool success;
+ bool ire;
+ bool ace;
+ bool ase;
+} _Airavata_deleteAppicationModule_result__isset;
+
+class Airavata_deleteAppicationModule_result {
+ public:
+
+ Airavata_deleteAppicationModule_result() : success(0) {
+ }
+
+ virtual ~Airavata_deleteAppicationModule_result() throw() {}
+
+ bool success;
+ ::airavata::api::error::InvalidRequestException ire;
+ ::airavata::api::error::AiravataClientException ace;
+ ::airavata::api::error::AiravataSystemException ase;
+
+ _Airavata_deleteAppicationModule_result__isset __isset;
+
+ void __set_success(const bool val) {
+ success = val;
+ }
+
+ void __set_ire(const ::airavata::api::error::InvalidRequestException& val) {
+ ire = val;
+ }
+
+ void __set_ace(const ::airavata::api::error::AiravataClientException& val) {
+ ace = val;
+ }
+
+ void __set_ase(const ::airavata::api::error::AiravataSystemException& val) {
+ ase = val;
+ }
+
+ bool operator == (const Airavata_deleteAppicationModule_result & rhs) const
+ {
+ if (!(success == rhs.success))
+ return false;
+ if (!(ire == rhs.ire))
+ return false;
+ if (!(ace == rhs.ace))
+ return false;
+ if (!(ase == rhs.ase))
+ return false;
+ return true;
+ }
+ bool operator != (const Airavata_deleteAppicationModule_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Airavata_deleteAppicationModule_result & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_deleteAppicationModule_presult__isset {
+ _Airavata_deleteAppicationModule_presult__isset() : success(false), ire(false), ace(false), ase(false) {}
+ bool success;
+ bool ire;
+ bool ace;
+ bool ase;
+} _Airavata_deleteAppicationModule_presult__isset;
+
+class Airavata_deleteAppicationModule_presult {
+ public:
+
+
+ virtual ~Airavata_deleteAppicationModule_presult() throw() {}
+
+ bool* success;
+ ::airavata::api::error::InvalidRequestException ire;
+ ::airavata::api::error::AiravataClientException ace;
+ ::airavata::api::error::AiravataSystemException ase;
+
+ _Airavata_deleteAppicationModule_presult__isset __isset;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
class AiravataClient : virtual public AiravataIf {
public:
AiravataClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) :
@@ -3406,6 +3960,18 @@ class AiravataClient : virtual public AiravataIf {
void terminateExperiment(const std::string& airavataExperimentId);
void send_terminateExperiment(const std::string& airavataExperimentId);
void recv_terminateExperiment();
+ void registerAppicationModule(std::string& _return, const ::ApplicationModule& applicationModule);
+ void send_registerAppicationModule(const ::ApplicationModule& applicationModule);
+ void recv_registerAppicationModule(std::string& _return);
+ void getAppicationModule( ::ApplicationModule& _return, const std::string& appModuleId);
+ void send_getAppicationModule(const std::string& appModuleId);
+ void recv_getAppicationModule( ::ApplicationModule& _return);
+ bool updateAppicationModule(const std::string& appModuleId, const ::ApplicationModule& applicationModule);
+ void send_updateAppicationModule(const std::string& appModuleId, const ::ApplicationModule& applicationModule);
+ bool recv_updateAppicationModule();
+ bool deleteAppicationModule(const std::string& appModuleId);
+ void send_deleteAppicationModule(const std::string& appModuleId);
+ bool recv_deleteAppicationModule();
protected:
boost::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_;
boost::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_;
@@ -3445,6 +4011,10 @@ class AiravataProcessor : public ::apache::thrift::TDispatchProcessor {
void process_getJobStatuses(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
void process_cloneExperiment(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
void process_terminateExperiment(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+ void process_registerAppicationModule(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+ void process_getAppicationModule(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+ void process_updateAppicationModule(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+ void process_deleteAppicationModule(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
public:
AiravataProcessor(boost::shared_ptr<AiravataIf> iface) :
iface_(iface) {
@@ -3472,6 +4042,10 @@ class AiravataProcessor : public ::apache::thrift::TDispatchProcessor {
processMap_["getJobStatuses"] = &AiravataProcessor::process_getJobStatuses;
processMap_["cloneExperiment"] = &AiravataProcessor::process_cloneExperiment;
processMap_["terminateExperiment"] = &AiravataProcessor::process_terminateExperiment;
+ processMap_["registerAppicationModule"] = &AiravataProcessor::process_registerAppicationModule;
+ processMap_["getAppicationModule"] = &AiravataProcessor::process_getAppicationModule;
+ processMap_["updateAppicationModule"] = &AiravataProcessor::process_updateAppicationModule;
+ processMap_["deleteAppicationModule"] = &AiravataProcessor::process_deleteAppicationModule;
}
virtual ~AiravataProcessor() {}
@@ -3733,6 +4307,44 @@ class AiravataMultiface : virtual public AiravataIf {
ifaces_[i]->terminateExperiment(airavataExperimentId);
}
+ void registerAppicationModule(std::string& _return, const ::ApplicationModule& applicationModule) {
+ size_t sz = ifaces_.size();
+ size_t i = 0;
+ for (; i < (sz - 1); ++i) {
+ ifaces_[i]->registerAppicationModule(_return, applicationModule);
+ }
+ ifaces_[i]->registerAppicationModule(_return, applicationModule);
+ return;
+ }
+
+ void getAppicationModule( ::ApplicationModule& _return, const std::string& appModuleId) {
+ size_t sz = ifaces_.size();
+ size_t i = 0;
+ for (; i < (sz - 1); ++i) {
+ ifaces_[i]->getAppicationModule(_return, appModuleId);
+ }
+ ifaces_[i]->getAppicationModule(_return, appModuleId);
+ return;
+ }
+
+ bool updateAppicationModule(const std::string& appModuleId, const ::ApplicationModule& applicationModule) {
+ size_t sz = ifaces_.size();
+ size_t i = 0;
+ for (; i < (sz - 1); ++i) {
+ ifaces_[i]->updateAppicationModule(appModuleId, applicationModule);
+ }
+ return ifaces_[i]->updateAppicationModule(appModuleId, applicationModule);
+ }
+
+ bool deleteAppicationModule(const std::string& appModuleId) {
+ size_t sz = ifaces_.size();
+ size_t i = 0;
+ for (; i < (sz - 1); ++i) {
+ ifaces_[i]->deleteAppicationModule(appModuleId);
+ }
+ return ifaces_[i]->deleteAppicationModule(appModuleId);
+ }
+
};
}} // namespace
http://git-wip-us.apache.org/repos/asf/airavata/blob/01f648a5/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/Airavata_server.skeleton.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/Airavata_server.skeleton.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/Airavata_server.skeleton.cpp
index 0a64052..14bd43b 100644
--- a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/Airavata_server.skeleton.cpp
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/Airavata_server.skeleton.cpp
@@ -142,6 +142,26 @@ class AiravataHandler : virtual public AiravataIf {
printf("terminateExperiment\n");
}
+ void registerAppicationModule(std::string& _return, const ::ApplicationModule& applicationModule) {
+ // Your implementation goes here
+ printf("registerAppicationModule\n");
+ }
+
+ void getAppicationModule( ::ApplicationModule& _return, const std::string& appModuleId) {
+ // Your implementation goes here
+ printf("getAppicationModule\n");
+ }
+
+ bool updateAppicationModule(const std::string& appModuleId, const ::ApplicationModule& applicationModule) {
+ // Your implementation goes here
+ printf("updateAppicationModule\n");
+ }
+
+ bool deleteAppicationModule(const std::string& appModuleId) {
+ // Your implementation goes here
+ printf("deleteAppicationModule\n");
+ }
+
};
int main(int argc, char **argv) {
http://git-wip-us.apache.org/repos/asf/airavata/blob/01f648a5/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavataAPI_types.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavataAPI_types.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavataAPI_types.h
index 5252a10..ea6b02d 100644
--- a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavataAPI_types.h
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavataAPI_types.h
@@ -17,7 +17,10 @@
#include "airavataDataModel_types.h"
#include "experimentModel_types.h"
#include "workspaceModel_types.h"
-#include "applicationCatalogAPI_types.h"
+#include "computeHostModel_types.h"
+#include "applicationDeploymentModel_types.h"
+#include "applicationInterfaceModel_types.h"
+#include "gatewayProfileModel_types.h"
namespace airavata { namespace api {