airavata-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From samin...@apache.org
Subject [08/12] https://issues.apache.org/jira/browse/AIRAVATA-1203
Date Thu, 15 May 2014 15:09:23 GMT
http://git-wip-us.apache.org/repos/asf/airavata/blob/c1a1bad5/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/ApplicationCatalogAPI_server.skeleton.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/ApplicationCatalogAPI_server.skeleton.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/ApplicationCatalogAPI_server.skeleton.cpp
new file mode 100644
index 0000000..2d11705
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/ApplicationCatalogAPI_server.skeleton.cpp
@@ -0,0 +1,139 @@
+// This autogenerated skeleton file illustrates how to build a server.
+// You should copy it to another filename to avoid overwriting it.
+
+#include "ApplicationCatalogAPI.h"
+#include <thrift/protocol/TBinaryProtocol.h>
+#include <thrift/server/TSimpleServer.h>
+#include <thrift/transport/TServerSocket.h>
+#include <thrift/transport/TBufferTransports.h>
+
+using namespace ::apache::thrift;
+using namespace ::apache::thrift::protocol;
+using namespace ::apache::thrift::transport;
+using namespace ::apache::thrift::server;
+
+using boost::shared_ptr;
+
+using namespace  ::airavata::api::appcatalog;
+
+class ApplicationCatalogAPIHandler : virtual public ApplicationCatalogAPIIf {
+ public:
+  ApplicationCatalogAPIHandler() {
+    // Your initialization goes here
+  }
+
+  void GetAPIVersion(std::string& _return) {
+    // Your implementation goes here
+    printf("GetAPIVersion\n");
+  }
+
+  void addComputeResourceDescription(const  ::ComputeResourceDescription& computeResourceDescription) {
+    // Your implementation goes here
+    printf("addComputeResourceDescription\n");
+  }
+
+  void addSSHJobSubmissionProtocol(const std::string& computeResourceId, const  ::SSHJobSubmission& jobSubmission) {
+    // Your implementation goes here
+    printf("addSSHJobSubmissionProtocol\n");
+  }
+
+  void addGSISSHJobSubmissionProtocol(const std::string& computeResourceId, const  ::GSISSHJobSubmission& jobSubmission) {
+    // Your implementation goes here
+    printf("addGSISSHJobSubmissionProtocol\n");
+  }
+
+  void addGlobusJobSubmissionProtocol(const std::string& computeResourceId, const  ::GlobusJobSubmission& jobSubmission) {
+    // Your implementation goes here
+    printf("addGlobusJobSubmissionProtocol\n");
+  }
+
+  void addSCPDataMovementProtocol(const std::string& computeResourceId, const  ::SCPDataMovement& dataMovement) {
+    // Your implementation goes here
+    printf("addSCPDataMovementProtocol\n");
+  }
+
+  void listComputeResourceDescriptions(std::vector<std::string> & _return) {
+    // Your implementation goes here
+    printf("listComputeResourceDescriptions\n");
+  }
+
+  void getComputeResourceDescription( ::ComputeResourceDescription& _return, const std::string& computeResourceId) {
+    // Your implementation goes here
+    printf("getComputeResourceDescription\n");
+  }
+
+  void getSSHJobSubmissionProtocol( ::SSHJobSubmission& _return, const std::string& sshJobSubmissionProtocolResourceId) {
+    // Your implementation goes here
+    printf("getSSHJobSubmissionProtocol\n");
+  }
+
+  void getGSISSHJobSubmissionProtocol( ::GSISSHJobSubmission& _return, const std::string& gsisshJobSubmissionProtocolResourceId) {
+    // Your implementation goes here
+    printf("getGSISSHJobSubmissionProtocol\n");
+  }
+
+  void getGlobusJobSubmissionProtocol( ::GlobusJobSubmission& _return, const std::string& globusJobSubmissionProtocolResourceId) {
+    // Your implementation goes here
+    printf("getGlobusJobSubmissionProtocol\n");
+  }
+
+  void getSCPDataMovementProtocol( ::SCPDataMovement& _return, const std::string& scpDataMovementResourceId) {
+    // Your implementation goes here
+    printf("getSCPDataMovementProtocol\n");
+  }
+
+  bool isComputeResourceDescriptionRegistered(const std::string& hostName) {
+    // Your implementation goes here
+    printf("isComputeResourceDescriptionRegistered\n");
+  }
+
+  void getComputeResourceDescriptionFromHostName( ::ComputeResourceDescription& _return, const std::string& hostName) {
+    // Your implementation goes here
+    printf("getComputeResourceDescriptionFromHostName\n");
+  }
+
+  void addApplicationInterface(const  ::ApplicationInterface& applicationInterface) {
+    // Your implementation goes here
+    printf("addApplicationInterface\n");
+  }
+
+  void listApplicationInterfaceIds(std::vector<std::string> & _return) {
+    // Your implementation goes here
+    printf("listApplicationInterfaceIds\n");
+  }
+
+  void getApplicationInterface( ::ApplicationInterface& _return, const std::string& applicationInterfaceId) {
+    // Your implementation goes here
+    printf("getApplicationInterface\n");
+  }
+
+  void addApplicationDeployment(const std::string& applicationInterfaceId, const  ::ApplicationDeployment& applicationDeployment) {
+    // Your implementation goes here
+    printf("addApplicationDeployment\n");
+  }
+
+  void listApplicationDeploymentIds(std::vector<std::string> & _return) {
+    // Your implementation goes here
+    printf("listApplicationDeploymentIds\n");
+  }
+
+  void getApplicationDeployment( ::ApplicationDeployment& _return, const std::string& applicationDeploymentId) {
+    // Your implementation goes here
+    printf("getApplicationDeployment\n");
+  }
+
+};
+
+int main(int argc, char **argv) {
+  int port = 9090;
+  shared_ptr<ApplicationCatalogAPIHandler> handler(new ApplicationCatalogAPIHandler());
+  shared_ptr<TProcessor> processor(new ApplicationCatalogAPIProcessor(handler));
+  shared_ptr<TServerTransport> serverTransport(new TServerSocket(port));
+  shared_ptr<TTransportFactory> transportFactory(new TBufferedTransportFactory());
+  shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory());
+
+  TSimpleServer server(processor, serverTransport, transportFactory, protocolFactory);
+  server.serve();
+  return 0;
+}
+

http://git-wip-us.apache.org/repos/asf/airavata/blob/c1a1bad5/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 3fab592..5252a10 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,6 +17,7 @@
 #include "airavataDataModel_types.h"
 #include "experimentModel_types.h"
 #include "workspaceModel_types.h"
+#include "applicationCatalogAPI_types.h"
 
 
 namespace airavata { namespace api {

http://git-wip-us.apache.org/repos/asf/airavata/blob/c1a1bad5/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationCatalogAPI_constants.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationCatalogAPI_constants.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationCatalogAPI_constants.cpp
new file mode 100644
index 0000000..d2f6b63
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationCatalogAPI_constants.cpp
@@ -0,0 +1,19 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+#include "applicationCatalogAPI_constants.h"
+
+namespace airavata { namespace api { namespace appcatalog {
+
+const applicationCatalogAPIConstants g_applicationCatalogAPI_constants;
+
+applicationCatalogAPIConstants::applicationCatalogAPIConstants() {
+  AIRAVATA_API_VERSION = "0.12.0";
+
+}
+
+}}} // namespace
+

http://git-wip-us.apache.org/repos/asf/airavata/blob/c1a1bad5/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationCatalogAPI_constants.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationCatalogAPI_constants.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationCatalogAPI_constants.h
new file mode 100644
index 0000000..325136d
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationCatalogAPI_constants.h
@@ -0,0 +1,25 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+#ifndef applicationCatalogAPI_CONSTANTS_H
+#define applicationCatalogAPI_CONSTANTS_H
+
+#include "applicationCatalogAPI_types.h"
+
+namespace airavata { namespace api { namespace appcatalog {
+
+class applicationCatalogAPIConstants {
+ public:
+  applicationCatalogAPIConstants();
+
+  std::string AIRAVATA_API_VERSION;
+};
+
+extern const applicationCatalogAPIConstants g_applicationCatalogAPI_constants;
+
+}}} // namespace
+
+#endif

http://git-wip-us.apache.org/repos/asf/airavata/blob/c1a1bad5/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationCatalogAPI_types.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationCatalogAPI_types.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationCatalogAPI_types.cpp
new file mode 100644
index 0000000..d0f5533
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationCatalogAPI_types.cpp
@@ -0,0 +1,13 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+#include "applicationCatalogAPI_types.h"
+
+#include <algorithm>
+
+namespace airavata { namespace api { namespace appcatalog {
+
+}}} // namespace

http://git-wip-us.apache.org/repos/asf/airavata/blob/c1a1bad5/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationCatalogAPI_types.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationCatalogAPI_types.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationCatalogAPI_types.h
new file mode 100644
index 0000000..2f7ec54
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationCatalogAPI_types.h
@@ -0,0 +1,25 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+#ifndef applicationCatalogAPI_TYPES_H
+#define applicationCatalogAPI_TYPES_H
+
+#include <thrift/Thrift.h>
+#include <thrift/TApplicationException.h>
+#include <thrift/protocol/TProtocol.h>
+#include <thrift/transport/TTransport.h>
+
+#include <thrift/cxxfunctional.h>
+#include "airavataErrors_types.h"
+#include "airavataDataModel_types.h"
+#include "applicationCatalogDataModel_types.h"
+
+
+namespace airavata { namespace api { namespace appcatalog {
+
+}}} // namespace
+
+#endif

http://git-wip-us.apache.org/repos/asf/airavata/blob/c1a1bad5/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationCatalogDataModel_constants.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationCatalogDataModel_constants.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationCatalogDataModel_constants.cpp
new file mode 100644
index 0000000..e3b3394
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationCatalogDataModel_constants.cpp
@@ -0,0 +1,19 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+#include "applicationCatalogDataModel_constants.h"
+
+
+
+const applicationCatalogDataModelConstants g_applicationCatalogDataModel_constants;
+
+applicationCatalogDataModelConstants::applicationCatalogDataModelConstants() {
+  DEFAULT_ID = "DO_NOT_SET_AT_CLIENTS";
+
+}
+
+
+

http://git-wip-us.apache.org/repos/asf/airavata/blob/c1a1bad5/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationCatalogDataModel_constants.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationCatalogDataModel_constants.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationCatalogDataModel_constants.h
new file mode 100644
index 0000000..d8bf387
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationCatalogDataModel_constants.h
@@ -0,0 +1,25 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+#ifndef applicationCatalogDataModel_CONSTANTS_H
+#define applicationCatalogDataModel_CONSTANTS_H
+
+#include "applicationCatalogDataModel_types.h"
+
+
+
+class applicationCatalogDataModelConstants {
+ public:
+  applicationCatalogDataModelConstants();
+
+  std::string DEFAULT_ID;
+};
+
+extern const applicationCatalogDataModelConstants g_applicationCatalogDataModel_constants;
+
+
+
+#endif

http://git-wip-us.apache.org/repos/asf/airavata/blob/c1a1bad5/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationCatalogDataModel_types.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationCatalogDataModel_types.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationCatalogDataModel_types.cpp
new file mode 100644
index 0000000..c60cf41
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationCatalogDataModel_types.cpp
@@ -0,0 +1,1260 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+#include "applicationCatalogDataModel_types.h"
+
+#include <algorithm>
+
+
+
+int _kResourceJobManagerValues[] = {
+  ResourceJobManager::FORK,
+  ResourceJobManager::PBS,
+  ResourceJobManager::UGE,
+  ResourceJobManager::SLURM
+};
+const char* _kResourceJobManagerNames[] = {
+  "FORK",
+  "PBS",
+  "UGE",
+  "SLURM"
+};
+const std::map<int, const char*> _ResourceJobManager_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(4, _kResourceJobManagerValues, _kResourceJobManagerNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
+
+int _kJobSubmissionProtocolValues[] = {
+  JobSubmissionProtocol::SSH,
+  JobSubmissionProtocol::GRAM,
+  JobSubmissionProtocol::UNICORE
+};
+const char* _kJobSubmissionProtocolNames[] = {
+  "SSH",
+  "GRAM",
+  "UNICORE"
+};
+const std::map<int, const char*> _JobSubmissionProtocol_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(3, _kJobSubmissionProtocolValues, _kJobSubmissionProtocolNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
+
+int _kDataMovementProtocolValues[] = {
+  DataMovementProtocol::SCP,
+  DataMovementProtocol::SFTP,
+  DataMovementProtocol::GridFTP,
+  DataMovementProtocol::UNICORE_STORAGE_SERVICE
+};
+const char* _kDataMovementProtocolNames[] = {
+  "SCP",
+  "SFTP",
+  "GridFTP",
+  "UNICORE_STORAGE_SERVICE"
+};
+const std::map<int, const char*> _DataMovementProtocol_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(4, _kDataMovementProtocolValues, _kDataMovementProtocolNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
+
+int _kSecurityProtocolValues[] = {
+  SecurityProtocol::USERNAME_PASSWORD,
+  SecurityProtocol::SSH_KEYS,
+  SecurityProtocol::GSI,
+  SecurityProtocol::KERBEROS,
+  SecurityProtocol::OAUTH
+};
+const char* _kSecurityProtocolNames[] = {
+  "USERNAME_PASSWORD",
+  "SSH_KEYS",
+  "GSI",
+  "KERBEROS",
+  "OAUTH"
+};
+const std::map<int, const char*> _SecurityProtocol_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(5, _kSecurityProtocolValues, _kSecurityProtocolNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
+
+const char* SCPDataMovement::ascii_fingerprint = "15D34740303C4E50CFFA807ABA20C3EF";
+const uint8_t SCPDataMovement::binary_fingerprint[16] = {0x15,0xD3,0x47,0x40,0x30,0x3C,0x4E,0x50,0xCF,0xFA,0x80,0x7A,0xBA,0x20,0xC3,0xEF};
+
+uint32_t SCPDataMovement::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_securityProtocol = 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->securityProtocol = (SecurityProtocol::type)ecast0;
+          isset_securityProtocol = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->sshPort);
+          this->__isset.sshPort = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_securityProtocol)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t SCPDataMovement::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("SCPDataMovement");
+
+  xfer += oprot->writeFieldBegin("securityProtocol", ::apache::thrift::protocol::T_I32, 1);
+  xfer += oprot->writeI32((int32_t)this->securityProtocol);
+  xfer += oprot->writeFieldEnd();
+
+  if (this->__isset.sshPort) {
+    xfer += oprot->writeFieldBegin("sshPort", ::apache::thrift::protocol::T_I32, 2);
+    xfer += oprot->writeI32(this->sshPort);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(SCPDataMovement &a, SCPDataMovement &b) {
+  using ::std::swap;
+  swap(a.securityProtocol, b.securityProtocol);
+  swap(a.sshPort, b.sshPort);
+  swap(a.__isset, b.__isset);
+}
+
+const char* SSHJobSubmission::ascii_fingerprint = "E65F4B00849C697EF0A023BF341A5599";
+const uint8_t SSHJobSubmission::binary_fingerprint[16] = {0xE6,0x5F,0x4B,0x00,0x84,0x9C,0x69,0x7E,0xF0,0xA0,0x23,0xBF,0x34,0x1A,0x55,0x99};
+
+uint32_t SSHJobSubmission::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_resourceJobManager = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          int32_t ecast1;
+          xfer += iprot->readI32(ecast1);
+          this->resourceJobManager = (ResourceJobManager::type)ecast1;
+          isset_resourceJobManager = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->sshPort);
+          this->__isset.sshPort = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_resourceJobManager)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t SSHJobSubmission::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("SSHJobSubmission");
+
+  xfer += oprot->writeFieldBegin("resourceJobManager", ::apache::thrift::protocol::T_I32, 2);
+  xfer += oprot->writeI32((int32_t)this->resourceJobManager);
+  xfer += oprot->writeFieldEnd();
+
+  if (this->__isset.sshPort) {
+    xfer += oprot->writeFieldBegin("sshPort", ::apache::thrift::protocol::T_I32, 3);
+    xfer += oprot->writeI32(this->sshPort);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(SSHJobSubmission &a, SSHJobSubmission &b) {
+  using ::std::swap;
+  swap(a.resourceJobManager, b.resourceJobManager);
+  swap(a.sshPort, b.sshPort);
+  swap(a.__isset, b.__isset);
+}
+
+const char* GlobusJobSubmission::ascii_fingerprint = "19AAB18E981C4EB11AEBB34F40FF0939";
+const uint8_t GlobusJobSubmission::binary_fingerprint[16] = {0x19,0xAA,0xB1,0x8E,0x98,0x1C,0x4E,0xB1,0x1A,0xEB,0xB3,0x4F,0x40,0xFF,0x09,0x39};
+
+uint32_t GlobusJobSubmission::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_securityProtocol = false;
+  bool isset_resourceJobManager = 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 ecast2;
+          xfer += iprot->readI32(ecast2);
+          this->securityProtocol = (SecurityProtocol::type)ecast2;
+          isset_securityProtocol = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          int32_t ecast3;
+          xfer += iprot->readI32(ecast3);
+          this->resourceJobManager = (ResourceJobManager::type)ecast3;
+          isset_resourceJobManager = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->globusGateKeeperEndPoint);
+          this->__isset.globusGateKeeperEndPoint = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_securityProtocol)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_resourceJobManager)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t GlobusJobSubmission::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("GlobusJobSubmission");
+
+  xfer += oprot->writeFieldBegin("securityProtocol", ::apache::thrift::protocol::T_I32, 1);
+  xfer += oprot->writeI32((int32_t)this->securityProtocol);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("resourceJobManager", ::apache::thrift::protocol::T_I32, 2);
+  xfer += oprot->writeI32((int32_t)this->resourceJobManager);
+  xfer += oprot->writeFieldEnd();
+
+  if (this->__isset.globusGateKeeperEndPoint) {
+    xfer += oprot->writeFieldBegin("globusGateKeeperEndPoint", ::apache::thrift::protocol::T_STRING, 3);
+    xfer += oprot->writeString(this->globusGateKeeperEndPoint);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(GlobusJobSubmission &a, GlobusJobSubmission &b) {
+  using ::std::swap;
+  swap(a.securityProtocol, b.securityProtocol);
+  swap(a.resourceJobManager, b.resourceJobManager);
+  swap(a.globusGateKeeperEndPoint, b.globusGateKeeperEndPoint);
+  swap(a.__isset, b.__isset);
+}
+
+const char* GSISSHJobSubmission::ascii_fingerprint = "91E841F79C1FDEC6DD757B48AC5FD97E";
+const uint8_t GSISSHJobSubmission::binary_fingerprint[16] = {0x91,0xE8,0x41,0xF7,0x9C,0x1F,0xDE,0xC6,0xDD,0x75,0x7B,0x48,0xAC,0x5F,0xD9,0x7E};
+
+uint32_t GSISSHJobSubmission::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_resourceJobManager = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          int32_t ecast4;
+          xfer += iprot->readI32(ecast4);
+          this->resourceJobManager = (ResourceJobManager::type)ecast4;
+          isset_resourceJobManager = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->sshPort);
+          this->__isset.sshPort = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_SET) {
+          {
+            this->exports.clear();
+            uint32_t _size5;
+            ::apache::thrift::protocol::TType _etype8;
+            xfer += iprot->readSetBegin(_etype8, _size5);
+            uint32_t _i9;
+            for (_i9 = 0; _i9 < _size5; ++_i9)
+            {
+              std::string _elem10;
+              xfer += iprot->readString(_elem10);
+              this->exports.insert(_elem10);
+            }
+            xfer += iprot->readSetEnd();
+          }
+          this->__isset.exports = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 5:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->preJobCommands.clear();
+            uint32_t _size11;
+            ::apache::thrift::protocol::TType _etype14;
+            xfer += iprot->readListBegin(_etype14, _size11);
+            this->preJobCommands.resize(_size11);
+            uint32_t _i15;
+            for (_i15 = 0; _i15 < _size11; ++_i15)
+            {
+              xfer += iprot->readString(this->preJobCommands[_i15]);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.preJobCommands = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 6:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->postJobCommands.clear();
+            uint32_t _size16;
+            ::apache::thrift::protocol::TType _etype19;
+            xfer += iprot->readListBegin(_etype19, _size16);
+            this->postJobCommands.resize(_size16);
+            uint32_t _i20;
+            for (_i20 = 0; _i20 < _size16; ++_i20)
+            {
+              xfer += iprot->readString(this->postJobCommands[_i20]);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.postJobCommands = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 7:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->installedPath);
+          this->__isset.installedPath = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 8:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->monitorMode);
+          this->__isset.monitorMode = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_resourceJobManager)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t GSISSHJobSubmission::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("GSISSHJobSubmission");
+
+  xfer += oprot->writeFieldBegin("resourceJobManager", ::apache::thrift::protocol::T_I32, 2);
+  xfer += oprot->writeI32((int32_t)this->resourceJobManager);
+  xfer += oprot->writeFieldEnd();
+
+  if (this->__isset.sshPort) {
+    xfer += oprot->writeFieldBegin("sshPort", ::apache::thrift::protocol::T_I32, 3);
+    xfer += oprot->writeI32(this->sshPort);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.exports) {
+    xfer += oprot->writeFieldBegin("exports", ::apache::thrift::protocol::T_SET, 4);
+    {
+      xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->exports.size()));
+      std::set<std::string> ::const_iterator _iter21;
+      for (_iter21 = this->exports.begin(); _iter21 != this->exports.end(); ++_iter21)
+      {
+        xfer += oprot->writeString((*_iter21));
+      }
+      xfer += oprot->writeSetEnd();
+    }
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.preJobCommands) {
+    xfer += oprot->writeFieldBegin("preJobCommands", ::apache::thrift::protocol::T_LIST, 5);
+    {
+      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->preJobCommands.size()));
+      std::vector<std::string> ::const_iterator _iter22;
+      for (_iter22 = this->preJobCommands.begin(); _iter22 != this->preJobCommands.end(); ++_iter22)
+      {
+        xfer += oprot->writeString((*_iter22));
+      }
+      xfer += oprot->writeListEnd();
+    }
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.postJobCommands) {
+    xfer += oprot->writeFieldBegin("postJobCommands", ::apache::thrift::protocol::T_LIST, 6);
+    {
+      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->postJobCommands.size()));
+      std::vector<std::string> ::const_iterator _iter23;
+      for (_iter23 = this->postJobCommands.begin(); _iter23 != this->postJobCommands.end(); ++_iter23)
+      {
+        xfer += oprot->writeString((*_iter23));
+      }
+      xfer += oprot->writeListEnd();
+    }
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.installedPath) {
+    xfer += oprot->writeFieldBegin("installedPath", ::apache::thrift::protocol::T_STRING, 7);
+    xfer += oprot->writeString(this->installedPath);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.monitorMode) {
+    xfer += oprot->writeFieldBegin("monitorMode", ::apache::thrift::protocol::T_STRING, 8);
+    xfer += oprot->writeString(this->monitorMode);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(GSISSHJobSubmission &a, GSISSHJobSubmission &b) {
+  using ::std::swap;
+  swap(a.resourceJobManager, b.resourceJobManager);
+  swap(a.sshPort, b.sshPort);
+  swap(a.exports, b.exports);
+  swap(a.preJobCommands, b.preJobCommands);
+  swap(a.postJobCommands, b.postJobCommands);
+  swap(a.installedPath, b.installedPath);
+  swap(a.monitorMode, b.monitorMode);
+  swap(a.__isset, b.__isset);
+}
+
+const char* JobSubmissionProtocols::ascii_fingerprint = "18B1F54358A01390B5830C26FFD334D4";
+const uint8_t JobSubmissionProtocols::binary_fingerprint[16] = {0x18,0xB1,0xF5,0x43,0x58,0xA0,0x13,0x90,0xB5,0x83,0x0C,0x26,0xFF,0xD3,0x34,0xD4};
+
+uint32_t JobSubmissionProtocols::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_isEmpty = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_BOOL) {
+          xfer += iprot->readBool(this->isEmpty);
+          isset_isEmpty = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          int32_t ecast24;
+          xfer += iprot->readI32(ecast24);
+          this->preferedJobSubmissionProtocol = (JobSubmissionProtocol::type)ecast24;
+          this->__isset.preferedJobSubmissionProtocol = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->sshJobSubmissionInfo.read(iprot);
+          this->__isset.sshJobSubmissionInfo = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->globusGRAMHost);
+          this->__isset.globusGRAMHost = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 5:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->globusGRAMPort);
+          this->__isset.globusGRAMPort = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 6:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->unicoreBESEndPoint);
+          this->__isset.unicoreBESEndPoint = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_isEmpty)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t JobSubmissionProtocols::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("JobSubmissionProtocols");
+
+  xfer += oprot->writeFieldBegin("isEmpty", ::apache::thrift::protocol::T_BOOL, 1);
+  xfer += oprot->writeBool(this->isEmpty);
+  xfer += oprot->writeFieldEnd();
+
+  if (this->__isset.preferedJobSubmissionProtocol) {
+    xfer += oprot->writeFieldBegin("preferedJobSubmissionProtocol", ::apache::thrift::protocol::T_I32, 2);
+    xfer += oprot->writeI32((int32_t)this->preferedJobSubmissionProtocol);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.sshJobSubmissionInfo) {
+    xfer += oprot->writeFieldBegin("sshJobSubmissionInfo", ::apache::thrift::protocol::T_STRUCT, 3);
+    xfer += this->sshJobSubmissionInfo.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.globusGRAMHost) {
+    xfer += oprot->writeFieldBegin("globusGRAMHost", ::apache::thrift::protocol::T_STRING, 4);
+    xfer += oprot->writeString(this->globusGRAMHost);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.globusGRAMPort) {
+    xfer += oprot->writeFieldBegin("globusGRAMPort", ::apache::thrift::protocol::T_I32, 5);
+    xfer += oprot->writeI32(this->globusGRAMPort);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.unicoreBESEndPoint) {
+    xfer += oprot->writeFieldBegin("unicoreBESEndPoint", ::apache::thrift::protocol::T_STRING, 6);
+    xfer += oprot->writeString(this->unicoreBESEndPoint);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(JobSubmissionProtocols &a, JobSubmissionProtocols &b) {
+  using ::std::swap;
+  swap(a.isEmpty, b.isEmpty);
+  swap(a.preferedJobSubmissionProtocol, b.preferedJobSubmissionProtocol);
+  swap(a.sshJobSubmissionInfo, b.sshJobSubmissionInfo);
+  swap(a.globusGRAMHost, b.globusGRAMHost);
+  swap(a.globusGRAMPort, b.globusGRAMPort);
+  swap(a.unicoreBESEndPoint, b.unicoreBESEndPoint);
+  swap(a.__isset, b.__isset);
+}
+
+const char* ComputeResourceDescription::ascii_fingerprint = "BA89EA8A5D740F97C53BA51CA49FEC18";
+const uint8_t ComputeResourceDescription::binary_fingerprint[16] = {0xBA,0x89,0xEA,0x8A,0x5D,0x74,0x0F,0x97,0xC5,0x3B,0xA5,0x1C,0xA4,0x9F,0xEC,0x18};
+
+uint32_t ComputeResourceDescription::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_isEmpty = false;
+  bool isset_resourceId = false;
+  bool isset_hostName = false;
+  bool isset_jobSubmissionProtocols = false;
+  bool isset_dataMovementProtocols = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_BOOL) {
+          xfer += iprot->readBool(this->isEmpty);
+          isset_isEmpty = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->resourceId);
+          isset_resourceId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->hostName);
+          isset_hostName = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_SET) {
+          {
+            this->hostAliases.clear();
+            uint32_t _size25;
+            ::apache::thrift::protocol::TType _etype28;
+            xfer += iprot->readSetBegin(_etype28, _size25);
+            uint32_t _i29;
+            for (_i29 = 0; _i29 < _size25; ++_i29)
+            {
+              std::string _elem30;
+              xfer += iprot->readString(_elem30);
+              this->hostAliases.insert(_elem30);
+            }
+            xfer += iprot->readSetEnd();
+          }
+          this->__isset.hostAliases = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 5:
+        if (ftype == ::apache::thrift::protocol::T_SET) {
+          {
+            this->ipAddresses.clear();
+            uint32_t _size31;
+            ::apache::thrift::protocol::TType _etype34;
+            xfer += iprot->readSetBegin(_etype34, _size31);
+            uint32_t _i35;
+            for (_i35 = 0; _i35 < _size31; ++_i35)
+            {
+              std::string _elem36;
+              xfer += iprot->readString(_elem36);
+              this->ipAddresses.insert(_elem36);
+            }
+            xfer += iprot->readSetEnd();
+          }
+          this->__isset.ipAddresses = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 6:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->resourceDescription);
+          this->__isset.resourceDescription = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 7:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->scratchLocation);
+          this->__isset.scratchLocation = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 8:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->preferredJobSubmissionProtocol);
+          this->__isset.preferredJobSubmissionProtocol = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 9:
+        if (ftype == ::apache::thrift::protocol::T_MAP) {
+          {
+            this->jobSubmissionProtocols.clear();
+            uint32_t _size37;
+            ::apache::thrift::protocol::TType _ktype38;
+            ::apache::thrift::protocol::TType _vtype39;
+            xfer += iprot->readMapBegin(_ktype38, _vtype39, _size37);
+            uint32_t _i41;
+            for (_i41 = 0; _i41 < _size37; ++_i41)
+            {
+              std::string _key42;
+              xfer += iprot->readString(_key42);
+              JobSubmissionProtocol::type& _val43 = this->jobSubmissionProtocols[_key42];
+              int32_t ecast44;
+              xfer += iprot->readI32(ecast44);
+              _val43 = (JobSubmissionProtocol::type)ecast44;
+            }
+            xfer += iprot->readMapEnd();
+          }
+          isset_jobSubmissionProtocols = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 10:
+        if (ftype == ::apache::thrift::protocol::T_MAP) {
+          {
+            this->dataMovementProtocols.clear();
+            uint32_t _size45;
+            ::apache::thrift::protocol::TType _ktype46;
+            ::apache::thrift::protocol::TType _vtype47;
+            xfer += iprot->readMapBegin(_ktype46, _vtype47, _size45);
+            uint32_t _i49;
+            for (_i49 = 0; _i49 < _size45; ++_i49)
+            {
+              std::string _key50;
+              xfer += iprot->readString(_key50);
+              DataMovementProtocol::type& _val51 = this->dataMovementProtocols[_key50];
+              int32_t ecast52;
+              xfer += iprot->readI32(ecast52);
+              _val51 = (DataMovementProtocol::type)ecast52;
+            }
+            xfer += iprot->readMapEnd();
+          }
+          isset_dataMovementProtocols = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_isEmpty)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_resourceId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_hostName)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_jobSubmissionProtocols)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_dataMovementProtocols)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t ComputeResourceDescription::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("ComputeResourceDescription");
+
+  xfer += oprot->writeFieldBegin("isEmpty", ::apache::thrift::protocol::T_BOOL, 1);
+  xfer += oprot->writeBool(this->isEmpty);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("resourceId", ::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeString(this->resourceId);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("hostName", ::apache::thrift::protocol::T_STRING, 3);
+  xfer += oprot->writeString(this->hostName);
+  xfer += oprot->writeFieldEnd();
+
+  if (this->__isset.hostAliases) {
+    xfer += oprot->writeFieldBegin("hostAliases", ::apache::thrift::protocol::T_SET, 4);
+    {
+      xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->hostAliases.size()));
+      std::set<std::string> ::const_iterator _iter53;
+      for (_iter53 = this->hostAliases.begin(); _iter53 != this->hostAliases.end(); ++_iter53)
+      {
+        xfer += oprot->writeString((*_iter53));
+      }
+      xfer += oprot->writeSetEnd();
+    }
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.ipAddresses) {
+    xfer += oprot->writeFieldBegin("ipAddresses", ::apache::thrift::protocol::T_SET, 5);
+    {
+      xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->ipAddresses.size()));
+      std::set<std::string> ::const_iterator _iter54;
+      for (_iter54 = this->ipAddresses.begin(); _iter54 != this->ipAddresses.end(); ++_iter54)
+      {
+        xfer += oprot->writeString((*_iter54));
+      }
+      xfer += oprot->writeSetEnd();
+    }
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.resourceDescription) {
+    xfer += oprot->writeFieldBegin("resourceDescription", ::apache::thrift::protocol::T_STRING, 6);
+    xfer += oprot->writeString(this->resourceDescription);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.scratchLocation) {
+    xfer += oprot->writeFieldBegin("scratchLocation", ::apache::thrift::protocol::T_STRING, 7);
+    xfer += oprot->writeString(this->scratchLocation);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.preferredJobSubmissionProtocol) {
+    xfer += oprot->writeFieldBegin("preferredJobSubmissionProtocol", ::apache::thrift::protocol::T_STRING, 8);
+    xfer += oprot->writeString(this->preferredJobSubmissionProtocol);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldBegin("jobSubmissionProtocols", ::apache::thrift::protocol::T_MAP, 9);
+  {
+    xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_I32, static_cast<uint32_t>(this->jobSubmissionProtocols.size()));
+    std::map<std::string, JobSubmissionProtocol::type> ::const_iterator _iter55;
+    for (_iter55 = this->jobSubmissionProtocols.begin(); _iter55 != this->jobSubmissionProtocols.end(); ++_iter55)
+    {
+      xfer += oprot->writeString(_iter55->first);
+      xfer += oprot->writeI32((int32_t)_iter55->second);
+    }
+    xfer += oprot->writeMapEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("dataMovementProtocols", ::apache::thrift::protocol::T_MAP, 10);
+  {
+    xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_I32, static_cast<uint32_t>(this->dataMovementProtocols.size()));
+    std::map<std::string, DataMovementProtocol::type> ::const_iterator _iter56;
+    for (_iter56 = this->dataMovementProtocols.begin(); _iter56 != this->dataMovementProtocols.end(); ++_iter56)
+    {
+      xfer += oprot->writeString(_iter56->first);
+      xfer += oprot->writeI32((int32_t)_iter56->second);
+    }
+    xfer += oprot->writeMapEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(ComputeResourceDescription &a, ComputeResourceDescription &b) {
+  using ::std::swap;
+  swap(a.isEmpty, b.isEmpty);
+  swap(a.resourceId, b.resourceId);
+  swap(a.hostName, b.hostName);
+  swap(a.hostAliases, b.hostAliases);
+  swap(a.ipAddresses, b.ipAddresses);
+  swap(a.resourceDescription, b.resourceDescription);
+  swap(a.scratchLocation, b.scratchLocation);
+  swap(a.preferredJobSubmissionProtocol, b.preferredJobSubmissionProtocol);
+  swap(a.jobSubmissionProtocols, b.jobSubmissionProtocols);
+  swap(a.dataMovementProtocols, b.dataMovementProtocols);
+  swap(a.__isset, b.__isset);
+}
+
+const char* ApplicationDescriptor::ascii_fingerprint = "5B708A954C550ECA9C1A49D3C5CAFAB9";
+const uint8_t ApplicationDescriptor::binary_fingerprint[16] = {0x5B,0x70,0x8A,0x95,0x4C,0x55,0x0E,0xCA,0x9C,0x1A,0x49,0xD3,0xC5,0xCA,0xFA,0xB9};
+
+uint32_t ApplicationDescriptor::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_applicationDescriptorId = 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->applicationDescriptorId);
+          isset_applicationDescriptorId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->applicationDescriptorData);
+          this->__isset.applicationDescriptorData = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_applicationDescriptorId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t ApplicationDescriptor::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("ApplicationDescriptor");
+
+  xfer += oprot->writeFieldBegin("applicationDescriptorId", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->applicationDescriptorId);
+  xfer += oprot->writeFieldEnd();
+
+  if (this->__isset.applicationDescriptorData) {
+    xfer += oprot->writeFieldBegin("applicationDescriptorData", ::apache::thrift::protocol::T_STRING, 2);
+    xfer += oprot->writeString(this->applicationDescriptorData);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(ApplicationDescriptor &a, ApplicationDescriptor &b) {
+  using ::std::swap;
+  swap(a.applicationDescriptorId, b.applicationDescriptorId);
+  swap(a.applicationDescriptorData, b.applicationDescriptorData);
+  swap(a.__isset, b.__isset);
+}
+
+const char* ApplicationDeployment::ascii_fingerprint = "960C379A1227D22F43E92F77C32827B9";
+const uint8_t ApplicationDeployment::binary_fingerprint[16] = {0x96,0x0C,0x37,0x9A,0x12,0x27,0xD2,0x2F,0x43,0xE9,0x2F,0x77,0xC3,0x28,0x27,0xB9};
+
+uint32_t ApplicationDeployment::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_deploymentId = false;
+  bool isset_computeResourceDescription = false;
+  bool isset_applicationDescriptor = 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->deploymentId);
+          isset_deploymentId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->computeResourceDescription.read(iprot);
+          isset_computeResourceDescription = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->applicationDescriptor.read(iprot);
+          isset_applicationDescriptor = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_deploymentId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_computeResourceDescription)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_applicationDescriptor)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t ApplicationDeployment::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("ApplicationDeployment");
+
+  xfer += oprot->writeFieldBegin("deploymentId", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->deploymentId);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("computeResourceDescription", ::apache::thrift::protocol::T_STRUCT, 2);
+  xfer += this->computeResourceDescription.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("applicationDescriptor", ::apache::thrift::protocol::T_STRUCT, 3);
+  xfer += this->applicationDescriptor.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(ApplicationDeployment &a, ApplicationDeployment &b) {
+  using ::std::swap;
+  swap(a.deploymentId, b.deploymentId);
+  swap(a.computeResourceDescription, b.computeResourceDescription);
+  swap(a.applicationDescriptor, b.applicationDescriptor);
+}
+
+const char* ApplicationInterface::ascii_fingerprint = "EEF3E81C0A64CA93FD2422A6CF9ABA97";
+const uint8_t ApplicationInterface::binary_fingerprint[16] = {0xEE,0xF3,0xE8,0x1C,0x0A,0x64,0xCA,0x93,0xFD,0x24,0x22,0xA6,0xCF,0x9A,0xBA,0x97};
+
+uint32_t ApplicationInterface::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_applicationInterfaceId = 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->applicationInterfaceId);
+          isset_applicationInterfaceId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->applicationInterfaceData);
+          this->__isset.applicationInterfaceData = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->applicationDeployments.clear();
+            uint32_t _size57;
+            ::apache::thrift::protocol::TType _etype60;
+            xfer += iprot->readListBegin(_etype60, _size57);
+            this->applicationDeployments.resize(_size57);
+            uint32_t _i61;
+            for (_i61 = 0; _i61 < _size57; ++_i61)
+            {
+              xfer += this->applicationDeployments[_i61].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.applicationDeployments = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_applicationInterfaceId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t ApplicationInterface::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("ApplicationInterface");
+
+  xfer += oprot->writeFieldBegin("applicationInterfaceId", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->applicationInterfaceId);
+  xfer += oprot->writeFieldEnd();
+
+  if (this->__isset.applicationInterfaceData) {
+    xfer += oprot->writeFieldBegin("applicationInterfaceData", ::apache::thrift::protocol::T_STRING, 2);
+    xfer += oprot->writeString(this->applicationInterfaceData);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.applicationDeployments) {
+    xfer += oprot->writeFieldBegin("applicationDeployments", ::apache::thrift::protocol::T_LIST, 3);
+    {
+      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->applicationDeployments.size()));
+      std::vector<ApplicationDeployment> ::const_iterator _iter62;
+      for (_iter62 = this->applicationDeployments.begin(); _iter62 != this->applicationDeployments.end(); ++_iter62)
+      {
+        xfer += (*_iter62).write(oprot);
+      }
+      xfer += oprot->writeListEnd();
+    }
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(ApplicationInterface &a, ApplicationInterface &b) {
+  using ::std::swap;
+  swap(a.applicationInterfaceId, b.applicationInterfaceId);
+  swap(a.applicationInterfaceData, b.applicationInterfaceData);
+  swap(a.applicationDeployments, b.applicationDeployments);
+  swap(a.__isset, b.__isset);
+}
+
+

http://git-wip-us.apache.org/repos/asf/airavata/blob/c1a1bad5/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationCatalogDataModel_types.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationCatalogDataModel_types.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationCatalogDataModel_types.h
new file mode 100644
index 0000000..3fc88e1
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationCatalogDataModel_types.h
@@ -0,0 +1,730 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+#ifndef applicationCatalogDataModel_TYPES_H
+#define applicationCatalogDataModel_TYPES_H
+
+#include <thrift/Thrift.h>
+#include <thrift/TApplicationException.h>
+#include <thrift/protocol/TProtocol.h>
+#include <thrift/transport/TTransport.h>
+
+#include <thrift/cxxfunctional.h>
+
+
+
+
+struct ResourceJobManager {
+  enum type {
+    FORK = 0,
+    PBS = 1,
+    UGE = 2,
+    SLURM = 3
+  };
+};
+
+extern const std::map<int, const char*> _ResourceJobManager_VALUES_TO_NAMES;
+
+struct JobSubmissionProtocol {
+  enum type {
+    SSH = 0,
+    GRAM = 1,
+    UNICORE = 2
+  };
+};
+
+extern const std::map<int, const char*> _JobSubmissionProtocol_VALUES_TO_NAMES;
+
+struct DataMovementProtocol {
+  enum type {
+    SCP = 0,
+    SFTP = 1,
+    GridFTP = 2,
+    UNICORE_STORAGE_SERVICE = 3
+  };
+};
+
+extern const std::map<int, const char*> _DataMovementProtocol_VALUES_TO_NAMES;
+
+struct SecurityProtocol {
+  enum type {
+    USERNAME_PASSWORD = 0,
+    SSH_KEYS = 1,
+    GSI = 2,
+    KERBEROS = 3,
+    OAUTH = 4
+  };
+};
+
+extern const std::map<int, const char*> _SecurityProtocol_VALUES_TO_NAMES;
+
+typedef struct _SCPDataMovement__isset {
+  _SCPDataMovement__isset() : sshPort(true) {}
+  bool sshPort;
+} _SCPDataMovement__isset;
+
+class SCPDataMovement {
+ public:
+
+  static const char* ascii_fingerprint; // = "15D34740303C4E50CFFA807ABA20C3EF";
+  static const uint8_t binary_fingerprint[16]; // = {0x15,0xD3,0x47,0x40,0x30,0x3C,0x4E,0x50,0xCF,0xFA,0x80,0x7A,0xBA,0x20,0xC3,0xEF};
+
+  SCPDataMovement() : securityProtocol((SecurityProtocol::type)0), sshPort(22) {
+  }
+
+  virtual ~SCPDataMovement() throw() {}
+
+  SecurityProtocol::type securityProtocol;
+  int32_t sshPort;
+
+  _SCPDataMovement__isset __isset;
+
+  void __set_securityProtocol(const SecurityProtocol::type val) {
+    securityProtocol = val;
+  }
+
+  void __set_sshPort(const int32_t val) {
+    sshPort = val;
+    __isset.sshPort = true;
+  }
+
+  bool operator == (const SCPDataMovement & rhs) const
+  {
+    if (!(securityProtocol == rhs.securityProtocol))
+      return false;
+    if (__isset.sshPort != rhs.__isset.sshPort)
+      return false;
+    else if (__isset.sshPort && !(sshPort == rhs.sshPort))
+      return false;
+    return true;
+  }
+  bool operator != (const SCPDataMovement &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const SCPDataMovement & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(SCPDataMovement &a, SCPDataMovement &b);
+
+typedef struct _SSHJobSubmission__isset {
+  _SSHJobSubmission__isset() : sshPort(true) {}
+  bool sshPort;
+} _SSHJobSubmission__isset;
+
+class SSHJobSubmission {
+ public:
+
+  static const char* ascii_fingerprint; // = "E65F4B00849C697EF0A023BF341A5599";
+  static const uint8_t binary_fingerprint[16]; // = {0xE6,0x5F,0x4B,0x00,0x84,0x9C,0x69,0x7E,0xF0,0xA0,0x23,0xBF,0x34,0x1A,0x55,0x99};
+
+  SSHJobSubmission() : resourceJobManager((ResourceJobManager::type)0), sshPort(22) {
+  }
+
+  virtual ~SSHJobSubmission() throw() {}
+
+  ResourceJobManager::type resourceJobManager;
+  int32_t sshPort;
+
+  _SSHJobSubmission__isset __isset;
+
+  void __set_resourceJobManager(const ResourceJobManager::type val) {
+    resourceJobManager = val;
+  }
+
+  void __set_sshPort(const int32_t val) {
+    sshPort = val;
+    __isset.sshPort = true;
+  }
+
+  bool operator == (const SSHJobSubmission & rhs) const
+  {
+    if (!(resourceJobManager == rhs.resourceJobManager))
+      return false;
+    if (__isset.sshPort != rhs.__isset.sshPort)
+      return false;
+    else if (__isset.sshPort && !(sshPort == rhs.sshPort))
+      return false;
+    return true;
+  }
+  bool operator != (const SSHJobSubmission &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const SSHJobSubmission & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(SSHJobSubmission &a, SSHJobSubmission &b);
+
+typedef struct _GlobusJobSubmission__isset {
+  _GlobusJobSubmission__isset() : globusGateKeeperEndPoint(false) {}
+  bool globusGateKeeperEndPoint;
+} _GlobusJobSubmission__isset;
+
+class GlobusJobSubmission {
+ public:
+
+  static const char* ascii_fingerprint; // = "19AAB18E981C4EB11AEBB34F40FF0939";
+  static const uint8_t binary_fingerprint[16]; // = {0x19,0xAA,0xB1,0x8E,0x98,0x1C,0x4E,0xB1,0x1A,0xEB,0xB3,0x4F,0x40,0xFF,0x09,0x39};
+
+  GlobusJobSubmission() : securityProtocol((SecurityProtocol::type)0), resourceJobManager((ResourceJobManager::type)0), globusGateKeeperEndPoint() {
+  }
+
+  virtual ~GlobusJobSubmission() throw() {}
+
+  SecurityProtocol::type securityProtocol;
+  ResourceJobManager::type resourceJobManager;
+  std::string globusGateKeeperEndPoint;
+
+  _GlobusJobSubmission__isset __isset;
+
+  void __set_securityProtocol(const SecurityProtocol::type val) {
+    securityProtocol = val;
+  }
+
+  void __set_resourceJobManager(const ResourceJobManager::type val) {
+    resourceJobManager = val;
+  }
+
+  void __set_globusGateKeeperEndPoint(const std::string& val) {
+    globusGateKeeperEndPoint = val;
+    __isset.globusGateKeeperEndPoint = true;
+  }
+
+  bool operator == (const GlobusJobSubmission & rhs) const
+  {
+    if (!(securityProtocol == rhs.securityProtocol))
+      return false;
+    if (!(resourceJobManager == rhs.resourceJobManager))
+      return false;
+    if (__isset.globusGateKeeperEndPoint != rhs.__isset.globusGateKeeperEndPoint)
+      return false;
+    else if (__isset.globusGateKeeperEndPoint && !(globusGateKeeperEndPoint == rhs.globusGateKeeperEndPoint))
+      return false;
+    return true;
+  }
+  bool operator != (const GlobusJobSubmission &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const GlobusJobSubmission & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(GlobusJobSubmission &a, GlobusJobSubmission &b);
+
+typedef struct _GSISSHJobSubmission__isset {
+  _GSISSHJobSubmission__isset() : sshPort(true), exports(false), preJobCommands(false), postJobCommands(false), installedPath(false), monitorMode(false) {}
+  bool sshPort;
+  bool exports;
+  bool preJobCommands;
+  bool postJobCommands;
+  bool installedPath;
+  bool monitorMode;
+} _GSISSHJobSubmission__isset;
+
+class GSISSHJobSubmission {
+ public:
+
+  static const char* ascii_fingerprint; // = "91E841F79C1FDEC6DD757B48AC5FD97E";
+  static const uint8_t binary_fingerprint[16]; // = {0x91,0xE8,0x41,0xF7,0x9C,0x1F,0xDE,0xC6,0xDD,0x75,0x7B,0x48,0xAC,0x5F,0xD9,0x7E};
+
+  GSISSHJobSubmission() : resourceJobManager((ResourceJobManager::type)0), sshPort(22), installedPath(), monitorMode() {
+  }
+
+  virtual ~GSISSHJobSubmission() throw() {}
+
+  ResourceJobManager::type resourceJobManager;
+  int32_t sshPort;
+  std::set<std::string>  exports;
+  std::vector<std::string>  preJobCommands;
+  std::vector<std::string>  postJobCommands;
+  std::string installedPath;
+  std::string monitorMode;
+
+  _GSISSHJobSubmission__isset __isset;
+
+  void __set_resourceJobManager(const ResourceJobManager::type val) {
+    resourceJobManager = val;
+  }
+
+  void __set_sshPort(const int32_t val) {
+    sshPort = val;
+    __isset.sshPort = true;
+  }
+
+  void __set_exports(const std::set<std::string> & val) {
+    exports = val;
+    __isset.exports = true;
+  }
+
+  void __set_preJobCommands(const std::vector<std::string> & val) {
+    preJobCommands = val;
+    __isset.preJobCommands = true;
+  }
+
+  void __set_postJobCommands(const std::vector<std::string> & val) {
+    postJobCommands = val;
+    __isset.postJobCommands = true;
+  }
+
+  void __set_installedPath(const std::string& val) {
+    installedPath = val;
+    __isset.installedPath = true;
+  }
+
+  void __set_monitorMode(const std::string& val) {
+    monitorMode = val;
+    __isset.monitorMode = true;
+  }
+
+  bool operator == (const GSISSHJobSubmission & rhs) const
+  {
+    if (!(resourceJobManager == rhs.resourceJobManager))
+      return false;
+    if (__isset.sshPort != rhs.__isset.sshPort)
+      return false;
+    else if (__isset.sshPort && !(sshPort == rhs.sshPort))
+      return false;
+    if (__isset.exports != rhs.__isset.exports)
+      return false;
+    else if (__isset.exports && !(exports == rhs.exports))
+      return false;
+    if (__isset.preJobCommands != rhs.__isset.preJobCommands)
+      return false;
+    else if (__isset.preJobCommands && !(preJobCommands == rhs.preJobCommands))
+      return false;
+    if (__isset.postJobCommands != rhs.__isset.postJobCommands)
+      return false;
+    else if (__isset.postJobCommands && !(postJobCommands == rhs.postJobCommands))
+      return false;
+    if (__isset.installedPath != rhs.__isset.installedPath)
+      return false;
+    else if (__isset.installedPath && !(installedPath == rhs.installedPath))
+      return false;
+    if (__isset.monitorMode != rhs.__isset.monitorMode)
+      return false;
+    else if (__isset.monitorMode && !(monitorMode == rhs.monitorMode))
+      return false;
+    return true;
+  }
+  bool operator != (const GSISSHJobSubmission &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const GSISSHJobSubmission & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(GSISSHJobSubmission &a, GSISSHJobSubmission &b);
+
+typedef struct _JobSubmissionProtocols__isset {
+  _JobSubmissionProtocols__isset() : preferedJobSubmissionProtocol(false), sshJobSubmissionInfo(false), globusGRAMHost(false), globusGRAMPort(true), unicoreBESEndPoint(false) {}
+  bool preferedJobSubmissionProtocol;
+  bool sshJobSubmissionInfo;
+  bool globusGRAMHost;
+  bool globusGRAMPort;
+  bool unicoreBESEndPoint;
+} _JobSubmissionProtocols__isset;
+
+class JobSubmissionProtocols {
+ public:
+
+  static const char* ascii_fingerprint; // = "18B1F54358A01390B5830C26FFD334D4";
+  static const uint8_t binary_fingerprint[16]; // = {0x18,0xB1,0xF5,0x43,0x58,0xA0,0x13,0x90,0xB5,0x83,0x0C,0x26,0xFF,0xD3,0x34,0xD4};
+
+  JobSubmissionProtocols() : isEmpty(false), preferedJobSubmissionProtocol((JobSubmissionProtocol::type)0), globusGRAMHost(), globusGRAMPort(2119), unicoreBESEndPoint() {
+  }
+
+  virtual ~JobSubmissionProtocols() throw() {}
+
+  bool isEmpty;
+  JobSubmissionProtocol::type preferedJobSubmissionProtocol;
+  SSHJobSubmission sshJobSubmissionInfo;
+  std::string globusGRAMHost;
+  int32_t globusGRAMPort;
+  std::string unicoreBESEndPoint;
+
+  _JobSubmissionProtocols__isset __isset;
+
+  void __set_isEmpty(const bool val) {
+    isEmpty = val;
+  }
+
+  void __set_preferedJobSubmissionProtocol(const JobSubmissionProtocol::type val) {
+    preferedJobSubmissionProtocol = val;
+    __isset.preferedJobSubmissionProtocol = true;
+  }
+
+  void __set_sshJobSubmissionInfo(const SSHJobSubmission& val) {
+    sshJobSubmissionInfo = val;
+    __isset.sshJobSubmissionInfo = true;
+  }
+
+  void __set_globusGRAMHost(const std::string& val) {
+    globusGRAMHost = val;
+    __isset.globusGRAMHost = true;
+  }
+
+  void __set_globusGRAMPort(const int32_t val) {
+    globusGRAMPort = val;
+    __isset.globusGRAMPort = true;
+  }
+
+  void __set_unicoreBESEndPoint(const std::string& val) {
+    unicoreBESEndPoint = val;
+    __isset.unicoreBESEndPoint = true;
+  }
+
+  bool operator == (const JobSubmissionProtocols & rhs) const
+  {
+    if (!(isEmpty == rhs.isEmpty))
+      return false;
+    if (__isset.preferedJobSubmissionProtocol != rhs.__isset.preferedJobSubmissionProtocol)
+      return false;
+    else if (__isset.preferedJobSubmissionProtocol && !(preferedJobSubmissionProtocol == rhs.preferedJobSubmissionProtocol))
+      return false;
+    if (__isset.sshJobSubmissionInfo != rhs.__isset.sshJobSubmissionInfo)
+      return false;
+    else if (__isset.sshJobSubmissionInfo && !(sshJobSubmissionInfo == rhs.sshJobSubmissionInfo))
+      return false;
+    if (__isset.globusGRAMHost != rhs.__isset.globusGRAMHost)
+      return false;
+    else if (__isset.globusGRAMHost && !(globusGRAMHost == rhs.globusGRAMHost))
+      return false;
+    if (__isset.globusGRAMPort != rhs.__isset.globusGRAMPort)
+      return false;
+    else if (__isset.globusGRAMPort && !(globusGRAMPort == rhs.globusGRAMPort))
+      return false;
+    if (__isset.unicoreBESEndPoint != rhs.__isset.unicoreBESEndPoint)
+      return false;
+    else if (__isset.unicoreBESEndPoint && !(unicoreBESEndPoint == rhs.unicoreBESEndPoint))
+      return false;
+    return true;
+  }
+  bool operator != (const JobSubmissionProtocols &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const JobSubmissionProtocols & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(JobSubmissionProtocols &a, JobSubmissionProtocols &b);
+
+typedef struct _ComputeResourceDescription__isset {
+  _ComputeResourceDescription__isset() : hostAliases(false), ipAddresses(false), resourceDescription(false), scratchLocation(false), preferredJobSubmissionProtocol(false) {}
+  bool hostAliases;
+  bool ipAddresses;
+  bool resourceDescription;
+  bool scratchLocation;
+  bool preferredJobSubmissionProtocol;
+} _ComputeResourceDescription__isset;
+
+class ComputeResourceDescription {
+ public:
+
+  static const char* ascii_fingerprint; // = "BA89EA8A5D740F97C53BA51CA49FEC18";
+  static const uint8_t binary_fingerprint[16]; // = {0xBA,0x89,0xEA,0x8A,0x5D,0x74,0x0F,0x97,0xC5,0x3B,0xA5,0x1C,0xA4,0x9F,0xEC,0x18};
+
+  ComputeResourceDescription() : isEmpty(false), resourceId("DO_NOT_SET_AT_CLIENTS"), hostName(), resourceDescription(), scratchLocation(), preferredJobSubmissionProtocol() {
+  }
+
+  virtual ~ComputeResourceDescription() throw() {}
+
+  bool isEmpty;
+  std::string resourceId;
+  std::string hostName;
+  std::set<std::string>  hostAliases;
+  std::set<std::string>  ipAddresses;
+  std::string resourceDescription;
+  std::string scratchLocation;
+  std::string preferredJobSubmissionProtocol;
+  std::map<std::string, JobSubmissionProtocol::type>  jobSubmissionProtocols;
+  std::map<std::string, DataMovementProtocol::type>  dataMovementProtocols;
+
+  _ComputeResourceDescription__isset __isset;
+
+  void __set_isEmpty(const bool val) {
+    isEmpty = val;
+  }
+
+  void __set_resourceId(const std::string& val) {
+    resourceId = val;
+  }
+
+  void __set_hostName(const std::string& val) {
+    hostName = val;
+  }
+
+  void __set_hostAliases(const std::set<std::string> & val) {
+    hostAliases = val;
+    __isset.hostAliases = true;
+  }
+
+  void __set_ipAddresses(const std::set<std::string> & val) {
+    ipAddresses = val;
+    __isset.ipAddresses = true;
+  }
+
+  void __set_resourceDescription(const std::string& val) {
+    resourceDescription = val;
+    __isset.resourceDescription = true;
+  }
+
+  void __set_scratchLocation(const std::string& val) {
+    scratchLocation = val;
+    __isset.scratchLocation = true;
+  }
+
+  void __set_preferredJobSubmissionProtocol(const std::string& val) {
+    preferredJobSubmissionProtocol = val;
+    __isset.preferredJobSubmissionProtocol = true;
+  }
+
+  void __set_jobSubmissionProtocols(const std::map<std::string, JobSubmissionProtocol::type> & val) {
+    jobSubmissionProtocols = val;
+  }
+
+  void __set_dataMovementProtocols(const std::map<std::string, DataMovementProtocol::type> & val) {
+    dataMovementProtocols = val;
+  }
+
+  bool operator == (const ComputeResourceDescription & rhs) const
+  {
+    if (!(isEmpty == rhs.isEmpty))
+      return false;
+    if (!(resourceId == rhs.resourceId))
+      return false;
+    if (!(hostName == rhs.hostName))
+      return false;
+    if (__isset.hostAliases != rhs.__isset.hostAliases)
+      return false;
+    else if (__isset.hostAliases && !(hostAliases == rhs.hostAliases))
+      return false;
+    if (__isset.ipAddresses != rhs.__isset.ipAddresses)
+      return false;
+    else if (__isset.ipAddresses && !(ipAddresses == rhs.ipAddresses))
+      return false;
+    if (__isset.resourceDescription != rhs.__isset.resourceDescription)
+      return false;
+    else if (__isset.resourceDescription && !(resourceDescription == rhs.resourceDescription))
+      return false;
+    if (__isset.scratchLocation != rhs.__isset.scratchLocation)
+      return false;
+    else if (__isset.scratchLocation && !(scratchLocation == rhs.scratchLocation))
+      return false;
+    if (__isset.preferredJobSubmissionProtocol != rhs.__isset.preferredJobSubmissionProtocol)
+      return false;
+    else if (__isset.preferredJobSubmissionProtocol && !(preferredJobSubmissionProtocol == rhs.preferredJobSubmissionProtocol))
+      return false;
+    if (!(jobSubmissionProtocols == rhs.jobSubmissionProtocols))
+      return false;
+    if (!(dataMovementProtocols == rhs.dataMovementProtocols))
+      return false;
+    return true;
+  }
+  bool operator != (const ComputeResourceDescription &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ComputeResourceDescription & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(ComputeResourceDescription &a, ComputeResourceDescription &b);
+
+typedef struct _ApplicationDescriptor__isset {
+  _ApplicationDescriptor__isset() : applicationDescriptorData(false) {}
+  bool applicationDescriptorData;
+} _ApplicationDescriptor__isset;
+
+class ApplicationDescriptor {
+ public:
+
+  static const char* ascii_fingerprint; // = "5B708A954C550ECA9C1A49D3C5CAFAB9";
+  static const uint8_t binary_fingerprint[16]; // = {0x5B,0x70,0x8A,0x95,0x4C,0x55,0x0E,0xCA,0x9C,0x1A,0x49,0xD3,0xC5,0xCA,0xFA,0xB9};
+
+  ApplicationDescriptor() : applicationDescriptorId("DO_NOT_SET_AT_CLIENTS"), applicationDescriptorData() {
+  }
+
+  virtual ~ApplicationDescriptor() throw() {}
+
+  std::string applicationDescriptorId;
+  std::string applicationDescriptorData;
+
+  _ApplicationDescriptor__isset __isset;
+
+  void __set_applicationDescriptorId(const std::string& val) {
+    applicationDescriptorId = val;
+  }
+
+  void __set_applicationDescriptorData(const std::string& val) {
+    applicationDescriptorData = val;
+    __isset.applicationDescriptorData = true;
+  }
+
+  bool operator == (const ApplicationDescriptor & rhs) const
+  {
+    if (!(applicationDescriptorId == rhs.applicationDescriptorId))
+      return false;
+    if (__isset.applicationDescriptorData != rhs.__isset.applicationDescriptorData)
+      return false;
+    else if (__isset.applicationDescriptorData && !(applicationDescriptorData == rhs.applicationDescriptorData))
+      return false;
+    return true;
+  }
+  bool operator != (const ApplicationDescriptor &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ApplicationDescriptor & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(ApplicationDescriptor &a, ApplicationDescriptor &b);
+
+
+class ApplicationDeployment {
+ public:
+
+  static const char* ascii_fingerprint; // = "960C379A1227D22F43E92F77C32827B9";
+  static const uint8_t binary_fingerprint[16]; // = {0x96,0x0C,0x37,0x9A,0x12,0x27,0xD2,0x2F,0x43,0xE9,0x2F,0x77,0xC3,0x28,0x27,0xB9};
+
+  ApplicationDeployment() : deploymentId("DO_NOT_SET_AT_CLIENTS") {
+  }
+
+  virtual ~ApplicationDeployment() throw() {}
+
+  std::string deploymentId;
+  ComputeResourceDescription computeResourceDescription;
+  ApplicationDescriptor applicationDescriptor;
+
+  void __set_deploymentId(const std::string& val) {
+    deploymentId = val;
+  }
+
+  void __set_computeResourceDescription(const ComputeResourceDescription& val) {
+    computeResourceDescription = val;
+  }
+
+  void __set_applicationDescriptor(const ApplicationDescriptor& val) {
+    applicationDescriptor = val;
+  }
+
+  bool operator == (const ApplicationDeployment & rhs) const
+  {
+    if (!(deploymentId == rhs.deploymentId))
+      return false;
+    if (!(computeResourceDescription == rhs.computeResourceDescription))
+      return false;
+    if (!(applicationDescriptor == rhs.applicationDescriptor))
+      return false;
+    return true;
+  }
+  bool operator != (const ApplicationDeployment &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ApplicationDeployment & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(ApplicationDeployment &a, ApplicationDeployment &b);
+
+typedef struct _ApplicationInterface__isset {
+  _ApplicationInterface__isset() : applicationInterfaceData(false), applicationDeployments(false) {}
+  bool applicationInterfaceData;
+  bool applicationDeployments;
+} _ApplicationInterface__isset;
+
+class ApplicationInterface {
+ public:
+
+  static const char* ascii_fingerprint; // = "EEF3E81C0A64CA93FD2422A6CF9ABA97";
+  static const uint8_t binary_fingerprint[16]; // = {0xEE,0xF3,0xE8,0x1C,0x0A,0x64,0xCA,0x93,0xFD,0x24,0x22,0xA6,0xCF,0x9A,0xBA,0x97};
+
+  ApplicationInterface() : applicationInterfaceId("DO_NOT_SET_AT_CLIENTS"), applicationInterfaceData() {
+  }
+
+  virtual ~ApplicationInterface() throw() {}
+
+  std::string applicationInterfaceId;
+  std::string applicationInterfaceData;
+  std::vector<ApplicationDeployment>  applicationDeployments;
+
+  _ApplicationInterface__isset __isset;
+
+  void __set_applicationInterfaceId(const std::string& val) {
+    applicationInterfaceId = val;
+  }
+
+  void __set_applicationInterfaceData(const std::string& val) {
+    applicationInterfaceData = val;
+    __isset.applicationInterfaceData = true;
+  }
+
+  void __set_applicationDeployments(const std::vector<ApplicationDeployment> & val) {
+    applicationDeployments = val;
+    __isset.applicationDeployments = true;
+  }
+
+  bool operator == (const ApplicationInterface & rhs) const
+  {
+    if (!(applicationInterfaceId == rhs.applicationInterfaceId))
+      return false;
+    if (__isset.applicationInterfaceData != rhs.__isset.applicationInterfaceData)
+      return false;
+    else if (__isset.applicationInterfaceData && !(applicationInterfaceData == rhs.applicationInterfaceData))
+      return false;
+    if (__isset.applicationDeployments != rhs.__isset.applicationDeployments)
+      return false;
+    else if (__isset.applicationDeployments && !(applicationDeployments == rhs.applicationDeployments))
+      return false;
+    return true;
+  }
+  bool operator != (const ApplicationInterface &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ApplicationInterface & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(ApplicationInterface &a, ApplicationInterface &b);
+
+
+
+#endif

http://git-wip-us.apache.org/repos/asf/airavata/blob/c1a1bad5/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/experimentModel_types.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/experimentModel_types.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/experimentModel_types.h
index ad58c38..451e579 100644
--- a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/experimentModel_types.h
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/experimentModel_types.h
@@ -13,6 +13,7 @@
 #include <thrift/transport/TTransport.h>
 
 #include <thrift/cxxfunctional.h>
+#include "applicationCatalogDataModel_types.h"
 
 
 


Mime
View raw message