airavata-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From chath...@apache.org
Subject [09/12] adding generated code for app-catalog
Date Sat, 28 Jun 2014 22:46:03 GMT
http://git-wip-us.apache.org/repos/asf/airavata/blob/8ebb254f/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/ApplicationCatalogAPI.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/ApplicationCatalogAPI.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/ApplicationCatalogAPI.h
index 6cfc0dc..b3ce2e9 100644
--- a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/ApplicationCatalogAPI.h
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/ApplicationCatalogAPI.h
@@ -31,12 +31,16 @@ class ApplicationCatalogAPIIf {
   virtual void getGridFTPDataMovementProtocol( ::GridFTPDataMovement& _return, const std::string& gridFTPDataMovementResourceId) = 0;
   virtual bool isComputeResourceDescriptionRegistered(const std::string& hostName) = 0;
   virtual void getComputeResourceDescriptionFromHostName( ::ComputeResourceDescription& _return, const std::string& hostName) = 0;
-  virtual void addApplicationInterface(std::string& _return, const  ::ApplicationInterface& applicationInterface) = 0;
+  virtual void addApplicationInterface(std::string& _return, const  ::ApplicationInterfaceDescription& applicationInterface) = 0;
   virtual void listApplicationInterfaceIds(std::vector<std::string> & _return) = 0;
-  virtual void getApplicationInterface( ::ApplicationInterface& _return, const std::string& applicationInterfaceId) = 0;
-  virtual void addApplicationDeployment(std::string& _return, const std::string& applicationInterfaceId, const  ::ApplicationDeployment& applicationDeployment) = 0;
+  virtual void getApplicationInterface( ::ApplicationInterfaceDescription& _return, const std::string& applicationInterfaceId) = 0;
+  virtual void registerAppicationModule(std::string& _return, const  ::ApplicationModule& applicationModule, const bool publish) = 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;
+  virtual void addApplicationDeployment(std::string& _return, const std::string& applicationInterfaceId, const  ::ApplicationDeploymentDescription& applicationDeployment) = 0;
   virtual void listApplicationDeploymentIds(std::vector<std::string> & _return, const std::string& applicationInterfaceId) = 0;
-  virtual void getApplicationDeployment( ::ApplicationDeployment& _return, const std::string& applicationInterfaceId, const std::string& applicationDeploymentId) = 0;
+  virtual void getApplicationDeployment( ::ApplicationDeploymentDescription& _return, const std::string& applicationInterfaceId, const std::string& applicationDeploymentId) = 0;
 };
 
 class ApplicationCatalogAPIIfFactory {
@@ -115,22 +119,36 @@ class ApplicationCatalogAPINull : virtual public ApplicationCatalogAPIIf {
   void getComputeResourceDescriptionFromHostName( ::ComputeResourceDescription& /* _return */, const std::string& /* hostName */) {
     return;
   }
-  void addApplicationInterface(std::string& /* _return */, const  ::ApplicationInterface& /* applicationInterface */) {
+  void addApplicationInterface(std::string& /* _return */, const  ::ApplicationInterfaceDescription& /* applicationInterface */) {
     return;
   }
   void listApplicationInterfaceIds(std::vector<std::string> & /* _return */) {
     return;
   }
-  void getApplicationInterface( ::ApplicationInterface& /* _return */, const std::string& /* applicationInterfaceId */) {
+  void getApplicationInterface( ::ApplicationInterfaceDescription& /* _return */, const std::string& /* applicationInterfaceId */) {
     return;
   }
-  void addApplicationDeployment(std::string& /* _return */, const std::string& /* applicationInterfaceId */, const  ::ApplicationDeployment& /* applicationDeployment */) {
+  void registerAppicationModule(std::string& /* _return */, const  ::ApplicationModule& /* applicationModule */, const bool /* publish */) {
+    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;
+  }
+  void addApplicationDeployment(std::string& /* _return */, const std::string& /* applicationInterfaceId */, const  ::ApplicationDeploymentDescription& /* applicationDeployment */) {
     return;
   }
   void listApplicationDeploymentIds(std::vector<std::string> & /* _return */, const std::string& /* applicationInterfaceId */) {
     return;
   }
-  void getApplicationDeployment( ::ApplicationDeployment& /* _return */, const std::string& /* applicationInterfaceId */, const std::string& /* applicationDeploymentId */) {
+  void getApplicationDeployment( ::ApplicationDeploymentDescription& /* _return */, const std::string& /* applicationInterfaceId */, const std::string& /* applicationDeploymentId */) {
     return;
   }
 };
@@ -2250,9 +2268,9 @@ class ApplicationCatalogAPI_addApplicationInterface_args {
 
   virtual ~ApplicationCatalogAPI_addApplicationInterface_args() throw() {}
 
-   ::ApplicationInterface applicationInterface;
+   ::ApplicationInterfaceDescription applicationInterface;
 
-  void __set_applicationInterface(const  ::ApplicationInterface& val) {
+  void __set_applicationInterface(const  ::ApplicationInterfaceDescription& val) {
     applicationInterface = val;
   }
 
@@ -2280,7 +2298,7 @@ class ApplicationCatalogAPI_addApplicationInterface_pargs {
 
   virtual ~ApplicationCatalogAPI_addApplicationInterface_pargs() throw() {}
 
-  const  ::ApplicationInterface* applicationInterface;
+  const  ::ApplicationInterfaceDescription* applicationInterface;
 
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
@@ -2558,14 +2576,14 @@ class ApplicationCatalogAPI_getApplicationInterface_result {
 
   virtual ~ApplicationCatalogAPI_getApplicationInterface_result() throw() {}
 
-   ::ApplicationInterface success;
+   ::ApplicationInterfaceDescription success;
    ::airavata::api::error::InvalidRequestException ire;
    ::airavata::api::error::AiravataClientException ace;
    ::airavata::api::error::AiravataSystemException ase;
 
   _ApplicationCatalogAPI_getApplicationInterface_result__isset __isset;
 
-  void __set_success(const  ::ApplicationInterface& val) {
+  void __set_success(const  ::ApplicationInterfaceDescription& val) {
     success = val;
   }
 
@@ -2618,7 +2636,7 @@ class ApplicationCatalogAPI_getApplicationInterface_presult {
 
   virtual ~ApplicationCatalogAPI_getApplicationInterface_presult() throw() {}
 
-   ::ApplicationInterface* success;
+   ::ApplicationInterfaceDescription* success;
    ::airavata::api::error::InvalidRequestException ire;
    ::airavata::api::error::AiravataClientException ace;
    ::airavata::api::error::AiravataSystemException ase;
@@ -2629,6 +2647,556 @@ class ApplicationCatalogAPI_getApplicationInterface_presult {
 
 };
 
+typedef struct _ApplicationCatalogAPI_registerAppicationModule_args__isset {
+  _ApplicationCatalogAPI_registerAppicationModule_args__isset() : publish(false) {}
+  bool publish;
+} _ApplicationCatalogAPI_registerAppicationModule_args__isset;
+
+class ApplicationCatalogAPI_registerAppicationModule_args {
+ public:
+
+  ApplicationCatalogAPI_registerAppicationModule_args() : publish(0) {
+  }
+
+  virtual ~ApplicationCatalogAPI_registerAppicationModule_args() throw() {}
+
+   ::ApplicationModule applicationModule;
+  bool publish;
+
+  _ApplicationCatalogAPI_registerAppicationModule_args__isset __isset;
+
+  void __set_applicationModule(const  ::ApplicationModule& val) {
+    applicationModule = val;
+  }
+
+  void __set_publish(const bool val) {
+    publish = val;
+  }
+
+  bool operator == (const ApplicationCatalogAPI_registerAppicationModule_args & rhs) const
+  {
+    if (!(applicationModule == rhs.applicationModule))
+      return false;
+    if (!(publish == rhs.publish))
+      return false;
+    return true;
+  }
+  bool operator != (const ApplicationCatalogAPI_registerAppicationModule_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ApplicationCatalogAPI_registerAppicationModule_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ApplicationCatalogAPI_registerAppicationModule_pargs {
+ public:
+
+
+  virtual ~ApplicationCatalogAPI_registerAppicationModule_pargs() throw() {}
+
+  const  ::ApplicationModule* applicationModule;
+  const bool* publish;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ApplicationCatalogAPI_registerAppicationModule_result__isset {
+  _ApplicationCatalogAPI_registerAppicationModule_result__isset() : success(false), ire(false), ace(false), ase(false) {}
+  bool success;
+  bool ire;
+  bool ace;
+  bool ase;
+} _ApplicationCatalogAPI_registerAppicationModule_result__isset;
+
+class ApplicationCatalogAPI_registerAppicationModule_result {
+ public:
+
+  ApplicationCatalogAPI_registerAppicationModule_result() : success() {
+  }
+
+  virtual ~ApplicationCatalogAPI_registerAppicationModule_result() throw() {}
+
+  std::string success;
+   ::airavata::api::error::InvalidRequestException ire;
+   ::airavata::api::error::AiravataClientException ace;
+   ::airavata::api::error::AiravataSystemException ase;
+
+  _ApplicationCatalogAPI_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 ApplicationCatalogAPI_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 ApplicationCatalogAPI_registerAppicationModule_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ApplicationCatalogAPI_registerAppicationModule_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ApplicationCatalogAPI_registerAppicationModule_presult__isset {
+  _ApplicationCatalogAPI_registerAppicationModule_presult__isset() : success(false), ire(false), ace(false), ase(false) {}
+  bool success;
+  bool ire;
+  bool ace;
+  bool ase;
+} _ApplicationCatalogAPI_registerAppicationModule_presult__isset;
+
+class ApplicationCatalogAPI_registerAppicationModule_presult {
+ public:
+
+
+  virtual ~ApplicationCatalogAPI_registerAppicationModule_presult() throw() {}
+
+  std::string* success;
+   ::airavata::api::error::InvalidRequestException ire;
+   ::airavata::api::error::AiravataClientException ace;
+   ::airavata::api::error::AiravataSystemException ase;
+
+  _ApplicationCatalogAPI_registerAppicationModule_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class ApplicationCatalogAPI_getAppicationModule_args {
+ public:
+
+  ApplicationCatalogAPI_getAppicationModule_args() : appModuleId() {
+  }
+
+  virtual ~ApplicationCatalogAPI_getAppicationModule_args() throw() {}
+
+  std::string appModuleId;
+
+  void __set_appModuleId(const std::string& val) {
+    appModuleId = val;
+  }
+
+  bool operator == (const ApplicationCatalogAPI_getAppicationModule_args & rhs) const
+  {
+    if (!(appModuleId == rhs.appModuleId))
+      return false;
+    return true;
+  }
+  bool operator != (const ApplicationCatalogAPI_getAppicationModule_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ApplicationCatalogAPI_getAppicationModule_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ApplicationCatalogAPI_getAppicationModule_pargs {
+ public:
+
+
+  virtual ~ApplicationCatalogAPI_getAppicationModule_pargs() throw() {}
+
+  const std::string* appModuleId;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ApplicationCatalogAPI_getAppicationModule_result__isset {
+  _ApplicationCatalogAPI_getAppicationModule_result__isset() : success(false), ire(false), ace(false), ase(false) {}
+  bool success;
+  bool ire;
+  bool ace;
+  bool ase;
+} _ApplicationCatalogAPI_getAppicationModule_result__isset;
+
+class ApplicationCatalogAPI_getAppicationModule_result {
+ public:
+
+  ApplicationCatalogAPI_getAppicationModule_result() {
+  }
+
+  virtual ~ApplicationCatalogAPI_getAppicationModule_result() throw() {}
+
+   ::ApplicationModule success;
+   ::airavata::api::error::InvalidRequestException ire;
+   ::airavata::api::error::AiravataClientException ace;
+   ::airavata::api::error::AiravataSystemException ase;
+
+  _ApplicationCatalogAPI_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 ApplicationCatalogAPI_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 ApplicationCatalogAPI_getAppicationModule_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ApplicationCatalogAPI_getAppicationModule_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ApplicationCatalogAPI_getAppicationModule_presult__isset {
+  _ApplicationCatalogAPI_getAppicationModule_presult__isset() : success(false), ire(false), ace(false), ase(false) {}
+  bool success;
+  bool ire;
+  bool ace;
+  bool ase;
+} _ApplicationCatalogAPI_getAppicationModule_presult__isset;
+
+class ApplicationCatalogAPI_getAppicationModule_presult {
+ public:
+
+
+  virtual ~ApplicationCatalogAPI_getAppicationModule_presult() throw() {}
+
+   ::ApplicationModule* success;
+   ::airavata::api::error::InvalidRequestException ire;
+   ::airavata::api::error::AiravataClientException ace;
+   ::airavata::api::error::AiravataSystemException ase;
+
+  _ApplicationCatalogAPI_getAppicationModule_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class ApplicationCatalogAPI_updateAppicationModule_args {
+ public:
+
+  ApplicationCatalogAPI_updateAppicationModule_args() : appModuleId() {
+  }
+
+  virtual ~ApplicationCatalogAPI_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 ApplicationCatalogAPI_updateAppicationModule_args & rhs) const
+  {
+    if (!(appModuleId == rhs.appModuleId))
+      return false;
+    if (!(applicationModule == rhs.applicationModule))
+      return false;
+    return true;
+  }
+  bool operator != (const ApplicationCatalogAPI_updateAppicationModule_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ApplicationCatalogAPI_updateAppicationModule_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ApplicationCatalogAPI_updateAppicationModule_pargs {
+ public:
+
+
+  virtual ~ApplicationCatalogAPI_updateAppicationModule_pargs() throw() {}
+
+  const std::string* appModuleId;
+  const  ::ApplicationModule* applicationModule;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ApplicationCatalogAPI_updateAppicationModule_result__isset {
+  _ApplicationCatalogAPI_updateAppicationModule_result__isset() : success(false), ire(false), ace(false), ase(false) {}
+  bool success;
+  bool ire;
+  bool ace;
+  bool ase;
+} _ApplicationCatalogAPI_updateAppicationModule_result__isset;
+
+class ApplicationCatalogAPI_updateAppicationModule_result {
+ public:
+
+  ApplicationCatalogAPI_updateAppicationModule_result() : success(0) {
+  }
+
+  virtual ~ApplicationCatalogAPI_updateAppicationModule_result() throw() {}
+
+  bool success;
+   ::airavata::api::error::InvalidRequestException ire;
+   ::airavata::api::error::AiravataClientException ace;
+   ::airavata::api::error::AiravataSystemException ase;
+
+  _ApplicationCatalogAPI_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 ApplicationCatalogAPI_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 ApplicationCatalogAPI_updateAppicationModule_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ApplicationCatalogAPI_updateAppicationModule_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ApplicationCatalogAPI_updateAppicationModule_presult__isset {
+  _ApplicationCatalogAPI_updateAppicationModule_presult__isset() : success(false), ire(false), ace(false), ase(false) {}
+  bool success;
+  bool ire;
+  bool ace;
+  bool ase;
+} _ApplicationCatalogAPI_updateAppicationModule_presult__isset;
+
+class ApplicationCatalogAPI_updateAppicationModule_presult {
+ public:
+
+
+  virtual ~ApplicationCatalogAPI_updateAppicationModule_presult() throw() {}
+
+  bool* success;
+   ::airavata::api::error::InvalidRequestException ire;
+   ::airavata::api::error::AiravataClientException ace;
+   ::airavata::api::error::AiravataSystemException ase;
+
+  _ApplicationCatalogAPI_updateAppicationModule_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class ApplicationCatalogAPI_deleteAppicationModule_args {
+ public:
+
+  ApplicationCatalogAPI_deleteAppicationModule_args() : appModuleId() {
+  }
+
+  virtual ~ApplicationCatalogAPI_deleteAppicationModule_args() throw() {}
+
+  std::string appModuleId;
+
+  void __set_appModuleId(const std::string& val) {
+    appModuleId = val;
+  }
+
+  bool operator == (const ApplicationCatalogAPI_deleteAppicationModule_args & rhs) const
+  {
+    if (!(appModuleId == rhs.appModuleId))
+      return false;
+    return true;
+  }
+  bool operator != (const ApplicationCatalogAPI_deleteAppicationModule_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ApplicationCatalogAPI_deleteAppicationModule_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ApplicationCatalogAPI_deleteAppicationModule_pargs {
+ public:
+
+
+  virtual ~ApplicationCatalogAPI_deleteAppicationModule_pargs() throw() {}
+
+  const std::string* appModuleId;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ApplicationCatalogAPI_deleteAppicationModule_result__isset {
+  _ApplicationCatalogAPI_deleteAppicationModule_result__isset() : success(false), ire(false), ace(false), ase(false) {}
+  bool success;
+  bool ire;
+  bool ace;
+  bool ase;
+} _ApplicationCatalogAPI_deleteAppicationModule_result__isset;
+
+class ApplicationCatalogAPI_deleteAppicationModule_result {
+ public:
+
+  ApplicationCatalogAPI_deleteAppicationModule_result() : success(0) {
+  }
+
+  virtual ~ApplicationCatalogAPI_deleteAppicationModule_result() throw() {}
+
+  bool success;
+   ::airavata::api::error::InvalidRequestException ire;
+   ::airavata::api::error::AiravataClientException ace;
+   ::airavata::api::error::AiravataSystemException ase;
+
+  _ApplicationCatalogAPI_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 ApplicationCatalogAPI_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 ApplicationCatalogAPI_deleteAppicationModule_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ApplicationCatalogAPI_deleteAppicationModule_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ApplicationCatalogAPI_deleteAppicationModule_presult__isset {
+  _ApplicationCatalogAPI_deleteAppicationModule_presult__isset() : success(false), ire(false), ace(false), ase(false) {}
+  bool success;
+  bool ire;
+  bool ace;
+  bool ase;
+} _ApplicationCatalogAPI_deleteAppicationModule_presult__isset;
+
+class ApplicationCatalogAPI_deleteAppicationModule_presult {
+ public:
+
+
+  virtual ~ApplicationCatalogAPI_deleteAppicationModule_presult() throw() {}
+
+  bool* success;
+   ::airavata::api::error::InvalidRequestException ire;
+   ::airavata::api::error::AiravataClientException ace;
+   ::airavata::api::error::AiravataSystemException ase;
+
+  _ApplicationCatalogAPI_deleteAppicationModule_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
 
 class ApplicationCatalogAPI_addApplicationDeployment_args {
  public:
@@ -2639,13 +3207,13 @@ class ApplicationCatalogAPI_addApplicationDeployment_args {
   virtual ~ApplicationCatalogAPI_addApplicationDeployment_args() throw() {}
 
   std::string applicationInterfaceId;
-   ::ApplicationDeployment applicationDeployment;
+   ::ApplicationDeploymentDescription applicationDeployment;
 
   void __set_applicationInterfaceId(const std::string& val) {
     applicationInterfaceId = val;
   }
 
-  void __set_applicationDeployment(const  ::ApplicationDeployment& val) {
+  void __set_applicationDeployment(const  ::ApplicationDeploymentDescription& val) {
     applicationDeployment = val;
   }
 
@@ -2676,7 +3244,7 @@ class ApplicationCatalogAPI_addApplicationDeployment_pargs {
   virtual ~ApplicationCatalogAPI_addApplicationDeployment_pargs() throw() {}
 
   const std::string* applicationInterfaceId;
-  const  ::ApplicationDeployment* applicationDeployment;
+  const  ::ApplicationDeploymentDescription* applicationDeployment;
 
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
@@ -2970,14 +3538,14 @@ class ApplicationCatalogAPI_getApplicationDeployment_result {
 
   virtual ~ApplicationCatalogAPI_getApplicationDeployment_result() throw() {}
 
-   ::ApplicationDeployment success;
+   ::ApplicationDeploymentDescription success;
    ::airavata::api::error::InvalidRequestException ire;
    ::airavata::api::error::AiravataClientException ace;
    ::airavata::api::error::AiravataSystemException ase;
 
   _ApplicationCatalogAPI_getApplicationDeployment_result__isset __isset;
 
-  void __set_success(const  ::ApplicationDeployment& val) {
+  void __set_success(const  ::ApplicationDeploymentDescription& val) {
     success = val;
   }
 
@@ -3030,7 +3598,7 @@ class ApplicationCatalogAPI_getApplicationDeployment_presult {
 
   virtual ~ApplicationCatalogAPI_getApplicationDeployment_presult() throw() {}
 
-   ::ApplicationDeployment* success;
+   ::ApplicationDeploymentDescription* success;
    ::airavata::api::error::InvalidRequestException ire;
    ::airavata::api::error::AiravataClientException ace;
    ::airavata::api::error::AiravataSystemException ase;
@@ -3109,24 +3677,36 @@ class ApplicationCatalogAPIClient : virtual public ApplicationCatalogAPIIf {
   void getComputeResourceDescriptionFromHostName( ::ComputeResourceDescription& _return, const std::string& hostName);
   void send_getComputeResourceDescriptionFromHostName(const std::string& hostName);
   void recv_getComputeResourceDescriptionFromHostName( ::ComputeResourceDescription& _return);
-  void addApplicationInterface(std::string& _return, const  ::ApplicationInterface& applicationInterface);
-  void send_addApplicationInterface(const  ::ApplicationInterface& applicationInterface);
+  void addApplicationInterface(std::string& _return, const  ::ApplicationInterfaceDescription& applicationInterface);
+  void send_addApplicationInterface(const  ::ApplicationInterfaceDescription& applicationInterface);
   void recv_addApplicationInterface(std::string& _return);
   void listApplicationInterfaceIds(std::vector<std::string> & _return);
   void send_listApplicationInterfaceIds();
   void recv_listApplicationInterfaceIds(std::vector<std::string> & _return);
-  void getApplicationInterface( ::ApplicationInterface& _return, const std::string& applicationInterfaceId);
+  void getApplicationInterface( ::ApplicationInterfaceDescription& _return, const std::string& applicationInterfaceId);
   void send_getApplicationInterface(const std::string& applicationInterfaceId);
-  void recv_getApplicationInterface( ::ApplicationInterface& _return);
-  void addApplicationDeployment(std::string& _return, const std::string& applicationInterfaceId, const  ::ApplicationDeployment& applicationDeployment);
-  void send_addApplicationDeployment(const std::string& applicationInterfaceId, const  ::ApplicationDeployment& applicationDeployment);
+  void recv_getApplicationInterface( ::ApplicationInterfaceDescription& _return);
+  void registerAppicationModule(std::string& _return, const  ::ApplicationModule& applicationModule, const bool publish);
+  void send_registerAppicationModule(const  ::ApplicationModule& applicationModule, const bool publish);
+  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();
+  void addApplicationDeployment(std::string& _return, const std::string& applicationInterfaceId, const  ::ApplicationDeploymentDescription& applicationDeployment);
+  void send_addApplicationDeployment(const std::string& applicationInterfaceId, const  ::ApplicationDeploymentDescription& applicationDeployment);
   void recv_addApplicationDeployment(std::string& _return);
   void listApplicationDeploymentIds(std::vector<std::string> & _return, const std::string& applicationInterfaceId);
   void send_listApplicationDeploymentIds(const std::string& applicationInterfaceId);
   void recv_listApplicationDeploymentIds(std::vector<std::string> & _return);
-  void getApplicationDeployment( ::ApplicationDeployment& _return, const std::string& applicationInterfaceId, const std::string& applicationDeploymentId);
+  void getApplicationDeployment( ::ApplicationDeploymentDescription& _return, const std::string& applicationInterfaceId, const std::string& applicationDeploymentId);
   void send_getApplicationDeployment(const std::string& applicationInterfaceId, const std::string& applicationDeploymentId);
-  void recv_getApplicationDeployment( ::ApplicationDeployment& _return);
+  void recv_getApplicationDeployment( ::ApplicationDeploymentDescription& _return);
  protected:
   boost::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_;
   boost::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_;
@@ -3161,6 +3741,10 @@ class ApplicationCatalogAPIProcessor : public ::apache::thrift::TDispatchProcess
   void process_addApplicationInterface(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
   void process_listApplicationInterfaceIds(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
   void process_getApplicationInterface(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);
   void process_addApplicationDeployment(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
   void process_listApplicationDeploymentIds(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
   void process_getApplicationDeployment(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
@@ -3186,6 +3770,10 @@ class ApplicationCatalogAPIProcessor : public ::apache::thrift::TDispatchProcess
     processMap_["addApplicationInterface"] = &ApplicationCatalogAPIProcessor::process_addApplicationInterface;
     processMap_["listApplicationInterfaceIds"] = &ApplicationCatalogAPIProcessor::process_listApplicationInterfaceIds;
     processMap_["getApplicationInterface"] = &ApplicationCatalogAPIProcessor::process_getApplicationInterface;
+    processMap_["registerAppicationModule"] = &ApplicationCatalogAPIProcessor::process_registerAppicationModule;
+    processMap_["getAppicationModule"] = &ApplicationCatalogAPIProcessor::process_getAppicationModule;
+    processMap_["updateAppicationModule"] = &ApplicationCatalogAPIProcessor::process_updateAppicationModule;
+    processMap_["deleteAppicationModule"] = &ApplicationCatalogAPIProcessor::process_deleteAppicationModule;
     processMap_["addApplicationDeployment"] = &ApplicationCatalogAPIProcessor::process_addApplicationDeployment;
     processMap_["listApplicationDeploymentIds"] = &ApplicationCatalogAPIProcessor::process_listApplicationDeploymentIds;
     processMap_["getApplicationDeployment"] = &ApplicationCatalogAPIProcessor::process_getApplicationDeployment;
@@ -3376,7 +3964,7 @@ class ApplicationCatalogAPIMultiface : virtual public ApplicationCatalogAPIIf {
     return;
   }
 
-  void addApplicationInterface(std::string& _return, const  ::ApplicationInterface& applicationInterface) {
+  void addApplicationInterface(std::string& _return, const  ::ApplicationInterfaceDescription& applicationInterface) {
     size_t sz = ifaces_.size();
     size_t i = 0;
     for (; i < (sz - 1); ++i) {
@@ -3396,7 +3984,7 @@ class ApplicationCatalogAPIMultiface : virtual public ApplicationCatalogAPIIf {
     return;
   }
 
-  void getApplicationInterface( ::ApplicationInterface& _return, const std::string& applicationInterfaceId) {
+  void getApplicationInterface( ::ApplicationInterfaceDescription& _return, const std::string& applicationInterfaceId) {
     size_t sz = ifaces_.size();
     size_t i = 0;
     for (; i < (sz - 1); ++i) {
@@ -3406,7 +3994,45 @@ class ApplicationCatalogAPIMultiface : virtual public ApplicationCatalogAPIIf {
     return;
   }
 
-  void addApplicationDeployment(std::string& _return, const std::string& applicationInterfaceId, const  ::ApplicationDeployment& applicationDeployment) {
+  void registerAppicationModule(std::string& _return, const  ::ApplicationModule& applicationModule, const bool publish) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->registerAppicationModule(_return, applicationModule, publish);
+    }
+    ifaces_[i]->registerAppicationModule(_return, applicationModule, publish);
+    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);
+  }
+
+  void addApplicationDeployment(std::string& _return, const std::string& applicationInterfaceId, const  ::ApplicationDeploymentDescription& applicationDeployment) {
     size_t sz = ifaces_.size();
     size_t i = 0;
     for (; i < (sz - 1); ++i) {
@@ -3426,7 +4052,7 @@ class ApplicationCatalogAPIMultiface : virtual public ApplicationCatalogAPIIf {
     return;
   }
 
-  void getApplicationDeployment( ::ApplicationDeployment& _return, const std::string& applicationInterfaceId, const std::string& applicationDeploymentId) {
+  void getApplicationDeployment( ::ApplicationDeploymentDescription& _return, const std::string& applicationInterfaceId, const std::string& applicationDeploymentId) {
     size_t sz = ifaces_.size();
     size_t i = 0;
     for (; i < (sz - 1); ++i) {

http://git-wip-us.apache.org/repos/asf/airavata/blob/8ebb254f/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
index ed61bd8..ae4afe6 100644
--- 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
@@ -102,7 +102,7 @@ class ApplicationCatalogAPIHandler : virtual public ApplicationCatalogAPIIf {
     printf("getComputeResourceDescriptionFromHostName\n");
   }
 
-  void addApplicationInterface(std::string& _return, const  ::ApplicationInterface& applicationInterface) {
+  void addApplicationInterface(std::string& _return, const  ::ApplicationInterfaceDescription& applicationInterface) {
     // Your implementation goes here
     printf("addApplicationInterface\n");
   }
@@ -112,12 +112,32 @@ class ApplicationCatalogAPIHandler : virtual public ApplicationCatalogAPIIf {
     printf("listApplicationInterfaceIds\n");
   }
 
-  void getApplicationInterface( ::ApplicationInterface& _return, const std::string& applicationInterfaceId) {
+  void getApplicationInterface( ::ApplicationInterfaceDescription& _return, const std::string& applicationInterfaceId) {
     // Your implementation goes here
     printf("getApplicationInterface\n");
   }
 
-  void addApplicationDeployment(std::string& _return, const std::string& applicationInterfaceId, const  ::ApplicationDeployment& applicationDeployment) {
+  void registerAppicationModule(std::string& _return, const  ::ApplicationModule& applicationModule, const bool publish) {
+    // 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");
+  }
+
+  void addApplicationDeployment(std::string& _return, const std::string& applicationInterfaceId, const  ::ApplicationDeploymentDescription& applicationDeployment) {
     // Your implementation goes here
     printf("addApplicationDeployment\n");
   }
@@ -127,7 +147,7 @@ class ApplicationCatalogAPIHandler : virtual public ApplicationCatalogAPIIf {
     printf("listApplicationDeploymentIds\n");
   }
 
-  void getApplicationDeployment( ::ApplicationDeployment& _return, const std::string& applicationInterfaceId, const std::string& applicationDeploymentId) {
+  void getApplicationDeployment( ::ApplicationDeploymentDescription& _return, const std::string& applicationInterfaceId, const std::string& applicationDeploymentId) {
     // Your implementation goes here
     printf("getApplicationDeployment\n");
   }

http://git-wip-us.apache.org/repos/asf/airavata/blob/8ebb254f/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
index 2f7ec54..4a9fc73 100644
--- 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
@@ -15,7 +15,9 @@
 #include <thrift/cxxfunctional.h>
 #include "airavataErrors_types.h"
 #include "airavataDataModel_types.h"
-#include "applicationCatalogDataModel_types.h"
+#include "computeHostModel_types.h"
+#include "applicationInterfaceModel_types.h"
+#include "applicationDeploymentModel_types.h"
 
 
 namespace airavata { namespace api { namespace appcatalog {

http://git-wip-us.apache.org/repos/asf/airavata/blob/8ebb254f/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationDeploymentModel_constants.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationDeploymentModel_constants.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationDeploymentModel_constants.cpp
new file mode 100644
index 0000000..d247067
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationDeploymentModel_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 "applicationDeploymentModel_constants.h"
+
+
+
+const applicationDeploymentModelConstants g_applicationDeploymentModel_constants;
+
+applicationDeploymentModelConstants::applicationDeploymentModelConstants() {
+  DEFAULT_ID = "DO_NOT_SET_AT_CLIENTS";
+
+}
+
+
+

http://git-wip-us.apache.org/repos/asf/airavata/blob/8ebb254f/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationDeploymentModel_constants.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationDeploymentModel_constants.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationDeploymentModel_constants.h
new file mode 100644
index 0000000..1fa8e0b
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationDeploymentModel_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 applicationDeploymentModel_CONSTANTS_H
+#define applicationDeploymentModel_CONSTANTS_H
+
+#include "applicationDeploymentModel_types.h"
+
+
+
+class applicationDeploymentModelConstants {
+ public:
+  applicationDeploymentModelConstants();
+
+  std::string DEFAULT_ID;
+};
+
+extern const applicationDeploymentModelConstants g_applicationDeploymentModel_constants;
+
+
+
+#endif

http://git-wip-us.apache.org/repos/asf/airavata/blob/8ebb254f/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationDeploymentModel_types.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationDeploymentModel_types.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationDeploymentModel_types.cpp
new file mode 100644
index 0000000..9a3f90a
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationDeploymentModel_types.cpp
@@ -0,0 +1,477 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+#include "applicationDeploymentModel_types.h"
+
+#include <algorithm>
+
+
+
+const char* SetEnvPaths::ascii_fingerprint = "07A9615F837F7D0A952B595DD3020972";
+const uint8_t SetEnvPaths::binary_fingerprint[16] = {0x07,0xA9,0x61,0x5F,0x83,0x7F,0x7D,0x0A,0x95,0x2B,0x59,0x5D,0xD3,0x02,0x09,0x72};
+
+uint32_t SetEnvPaths::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_name = false;
+  bool isset_value = 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->name);
+          isset_name = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->value);
+          isset_value = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_name)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_value)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t SetEnvPaths::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("SetEnvPaths");
+
+  xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->name);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeString(this->value);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(SetEnvPaths &a, SetEnvPaths &b) {
+  using ::std::swap;
+  swap(a.name, b.name);
+  swap(a.value, b.value);
+}
+
+const char* ApplicationModule::ascii_fingerprint = "EAD3BFBDF5BD64DF63F11230D11B43DE";
+const uint8_t ApplicationModule::binary_fingerprint[16] = {0xEA,0xD3,0xBF,0xBD,0xF5,0xBD,0x64,0xDF,0x63,0xF1,0x12,0x30,0xD1,0x1B,0x43,0xDE};
+
+uint32_t ApplicationModule::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_appModuleId = false;
+  bool isset_appModuleName = 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->appModuleId);
+          isset_appModuleId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->appModuleName);
+          isset_appModuleName = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->appModuleVersion);
+          this->__isset.appModuleVersion = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 5:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->appModuleDescription);
+          this->__isset.appModuleDescription = 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_appModuleId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_appModuleName)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t ApplicationModule::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("ApplicationModule");
+
+  xfer += oprot->writeFieldBegin("isEmpty", ::apache::thrift::protocol::T_BOOL, 1);
+  xfer += oprot->writeBool(this->isEmpty);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("appModuleId", ::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeString(this->appModuleId);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("appModuleName", ::apache::thrift::protocol::T_STRING, 3);
+  xfer += oprot->writeString(this->appModuleName);
+  xfer += oprot->writeFieldEnd();
+
+  if (this->__isset.appModuleVersion) {
+    xfer += oprot->writeFieldBegin("appModuleVersion", ::apache::thrift::protocol::T_STRING, 4);
+    xfer += oprot->writeString(this->appModuleVersion);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.appModuleDescription) {
+    xfer += oprot->writeFieldBegin("appModuleDescription", ::apache::thrift::protocol::T_STRING, 5);
+    xfer += oprot->writeString(this->appModuleDescription);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(ApplicationModule &a, ApplicationModule &b) {
+  using ::std::swap;
+  swap(a.isEmpty, b.isEmpty);
+  swap(a.appModuleId, b.appModuleId);
+  swap(a.appModuleName, b.appModuleName);
+  swap(a.appModuleVersion, b.appModuleVersion);
+  swap(a.appModuleDescription, b.appModuleDescription);
+  swap(a.__isset, b.__isset);
+}
+
+const char* ApplicationDeploymentDescription::ascii_fingerprint = "50C12617CDB84220D07D0920711332CF";
+const uint8_t ApplicationDeploymentDescription::binary_fingerprint[16] = {0x50,0xC1,0x26,0x17,0xCD,0xB8,0x42,0x20,0xD0,0x7D,0x09,0x20,0x71,0x13,0x32,0xCF};
+
+uint32_t ApplicationDeploymentDescription::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_appDeploymentId = false;
+  bool isset_appModuleId = false;
+  bool isset_computeHostId = false;
+  bool isset_executablePath = 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->appDeploymentId);
+          isset_appDeploymentId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->appModuleId);
+          isset_appModuleId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->computeHostId);
+          isset_computeHostId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 5:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->executablePath);
+          isset_executablePath = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 6:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->appDeploymentDescription);
+          this->__isset.appDeploymentDescription = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 7:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->moduleLoadCmd);
+          this->__isset.moduleLoadCmd = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 8:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->libPrependPaths.clear();
+            uint32_t _size0;
+            ::apache::thrift::protocol::TType _etype3;
+            xfer += iprot->readListBegin(_etype3, _size0);
+            this->libPrependPaths.resize(_size0);
+            uint32_t _i4;
+            for (_i4 = 0; _i4 < _size0; ++_i4)
+            {
+              xfer += this->libPrependPaths[_i4].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.libPrependPaths = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 9:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->libAppendPaths.clear();
+            uint32_t _size5;
+            ::apache::thrift::protocol::TType _etype8;
+            xfer += iprot->readListBegin(_etype8, _size5);
+            this->libAppendPaths.resize(_size5);
+            uint32_t _i9;
+            for (_i9 = 0; _i9 < _size5; ++_i9)
+            {
+              xfer += this->libAppendPaths[_i9].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.libAppendPaths = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 10:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->setEnvironment.clear();
+            uint32_t _size10;
+            ::apache::thrift::protocol::TType _etype13;
+            xfer += iprot->readListBegin(_etype13, _size10);
+            this->setEnvironment.resize(_size10);
+            uint32_t _i14;
+            for (_i14 = 0; _i14 < _size10; ++_i14)
+            {
+              xfer += this->setEnvironment[_i14].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.setEnvironment = 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_appDeploymentId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_appModuleId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_computeHostId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_executablePath)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t ApplicationDeploymentDescription::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("ApplicationDeploymentDescription");
+
+  xfer += oprot->writeFieldBegin("isEmpty", ::apache::thrift::protocol::T_BOOL, 1);
+  xfer += oprot->writeBool(this->isEmpty);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("appDeploymentId", ::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeString(this->appDeploymentId);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("appModuleId", ::apache::thrift::protocol::T_STRING, 3);
+  xfer += oprot->writeString(this->appModuleId);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("computeHostId", ::apache::thrift::protocol::T_STRING, 4);
+  xfer += oprot->writeString(this->computeHostId);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("executablePath", ::apache::thrift::protocol::T_STRING, 5);
+  xfer += oprot->writeString(this->executablePath);
+  xfer += oprot->writeFieldEnd();
+
+  if (this->__isset.appDeploymentDescription) {
+    xfer += oprot->writeFieldBegin("appDeploymentDescription", ::apache::thrift::protocol::T_STRING, 6);
+    xfer += oprot->writeString(this->appDeploymentDescription);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.moduleLoadCmd) {
+    xfer += oprot->writeFieldBegin("moduleLoadCmd", ::apache::thrift::protocol::T_STRING, 7);
+    xfer += oprot->writeString(this->moduleLoadCmd);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.libPrependPaths) {
+    xfer += oprot->writeFieldBegin("libPrependPaths", ::apache::thrift::protocol::T_LIST, 8);
+    {
+      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->libPrependPaths.size()));
+      std::vector<SetEnvPaths> ::const_iterator _iter15;
+      for (_iter15 = this->libPrependPaths.begin(); _iter15 != this->libPrependPaths.end(); ++_iter15)
+      {
+        xfer += (*_iter15).write(oprot);
+      }
+      xfer += oprot->writeListEnd();
+    }
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.libAppendPaths) {
+    xfer += oprot->writeFieldBegin("libAppendPaths", ::apache::thrift::protocol::T_LIST, 9);
+    {
+      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->libAppendPaths.size()));
+      std::vector<SetEnvPaths> ::const_iterator _iter16;
+      for (_iter16 = this->libAppendPaths.begin(); _iter16 != this->libAppendPaths.end(); ++_iter16)
+      {
+        xfer += (*_iter16).write(oprot);
+      }
+      xfer += oprot->writeListEnd();
+    }
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.setEnvironment) {
+    xfer += oprot->writeFieldBegin("setEnvironment", ::apache::thrift::protocol::T_LIST, 10);
+    {
+      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->setEnvironment.size()));
+      std::vector<SetEnvPaths> ::const_iterator _iter17;
+      for (_iter17 = this->setEnvironment.begin(); _iter17 != this->setEnvironment.end(); ++_iter17)
+      {
+        xfer += (*_iter17).write(oprot);
+      }
+      xfer += oprot->writeListEnd();
+    }
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(ApplicationDeploymentDescription &a, ApplicationDeploymentDescription &b) {
+  using ::std::swap;
+  swap(a.isEmpty, b.isEmpty);
+  swap(a.appDeploymentId, b.appDeploymentId);
+  swap(a.appModuleId, b.appModuleId);
+  swap(a.computeHostId, b.computeHostId);
+  swap(a.executablePath, b.executablePath);
+  swap(a.appDeploymentDescription, b.appDeploymentDescription);
+  swap(a.moduleLoadCmd, b.moduleLoadCmd);
+  swap(a.libPrependPaths, b.libPrependPaths);
+  swap(a.libAppendPaths, b.libAppendPaths);
+  swap(a.setEnvironment, b.setEnvironment);
+  swap(a.__isset, b.__isset);
+}
+
+

http://git-wip-us.apache.org/repos/asf/airavata/blob/8ebb254f/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationDeploymentModel_types.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationDeploymentModel_types.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationDeploymentModel_types.h
new file mode 100644
index 0000000..2bc61dd
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationDeploymentModel_types.h
@@ -0,0 +1,269 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+#ifndef applicationDeploymentModel_TYPES_H
+#define applicationDeploymentModel_TYPES_H
+
+#include <thrift/Thrift.h>
+#include <thrift/TApplicationException.h>
+#include <thrift/protocol/TProtocol.h>
+#include <thrift/transport/TTransport.h>
+
+#include <thrift/cxxfunctional.h>
+
+
+
+
+
+class SetEnvPaths {
+ public:
+
+  static const char* ascii_fingerprint; // = "07A9615F837F7D0A952B595DD3020972";
+  static const uint8_t binary_fingerprint[16]; // = {0x07,0xA9,0x61,0x5F,0x83,0x7F,0x7D,0x0A,0x95,0x2B,0x59,0x5D,0xD3,0x02,0x09,0x72};
+
+  SetEnvPaths() : name(), value() {
+  }
+
+  virtual ~SetEnvPaths() throw() {}
+
+  std::string name;
+  std::string value;
+
+  void __set_name(const std::string& val) {
+    name = val;
+  }
+
+  void __set_value(const std::string& val) {
+    value = val;
+  }
+
+  bool operator == (const SetEnvPaths & rhs) const
+  {
+    if (!(name == rhs.name))
+      return false;
+    if (!(value == rhs.value))
+      return false;
+    return true;
+  }
+  bool operator != (const SetEnvPaths &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const SetEnvPaths & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(SetEnvPaths &a, SetEnvPaths &b);
+
+typedef struct _ApplicationModule__isset {
+  _ApplicationModule__isset() : appModuleVersion(false), appModuleDescription(false) {}
+  bool appModuleVersion;
+  bool appModuleDescription;
+} _ApplicationModule__isset;
+
+class ApplicationModule {
+ public:
+
+  static const char* ascii_fingerprint; // = "EAD3BFBDF5BD64DF63F11230D11B43DE";
+  static const uint8_t binary_fingerprint[16]; // = {0xEA,0xD3,0xBF,0xBD,0xF5,0xBD,0x64,0xDF,0x63,0xF1,0x12,0x30,0xD1,0x1B,0x43,0xDE};
+
+  ApplicationModule() : isEmpty(false), appModuleId("DO_NOT_SET_AT_CLIENTS"), appModuleName(), appModuleVersion(), appModuleDescription() {
+  }
+
+  virtual ~ApplicationModule() throw() {}
+
+  bool isEmpty;
+  std::string appModuleId;
+  std::string appModuleName;
+  std::string appModuleVersion;
+  std::string appModuleDescription;
+
+  _ApplicationModule__isset __isset;
+
+  void __set_isEmpty(const bool val) {
+    isEmpty = val;
+  }
+
+  void __set_appModuleId(const std::string& val) {
+    appModuleId = val;
+  }
+
+  void __set_appModuleName(const std::string& val) {
+    appModuleName = val;
+  }
+
+  void __set_appModuleVersion(const std::string& val) {
+    appModuleVersion = val;
+    __isset.appModuleVersion = true;
+  }
+
+  void __set_appModuleDescription(const std::string& val) {
+    appModuleDescription = val;
+    __isset.appModuleDescription = true;
+  }
+
+  bool operator == (const ApplicationModule & rhs) const
+  {
+    if (!(isEmpty == rhs.isEmpty))
+      return false;
+    if (!(appModuleId == rhs.appModuleId))
+      return false;
+    if (!(appModuleName == rhs.appModuleName))
+      return false;
+    if (__isset.appModuleVersion != rhs.__isset.appModuleVersion)
+      return false;
+    else if (__isset.appModuleVersion && !(appModuleVersion == rhs.appModuleVersion))
+      return false;
+    if (__isset.appModuleDescription != rhs.__isset.appModuleDescription)
+      return false;
+    else if (__isset.appModuleDescription && !(appModuleDescription == rhs.appModuleDescription))
+      return false;
+    return true;
+  }
+  bool operator != (const ApplicationModule &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ApplicationModule & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(ApplicationModule &a, ApplicationModule &b);
+
+typedef struct _ApplicationDeploymentDescription__isset {
+  _ApplicationDeploymentDescription__isset() : appDeploymentDescription(false), moduleLoadCmd(false), libPrependPaths(false), libAppendPaths(false), setEnvironment(false) {}
+  bool appDeploymentDescription;
+  bool moduleLoadCmd;
+  bool libPrependPaths;
+  bool libAppendPaths;
+  bool setEnvironment;
+} _ApplicationDeploymentDescription__isset;
+
+class ApplicationDeploymentDescription {
+ public:
+
+  static const char* ascii_fingerprint; // = "50C12617CDB84220D07D0920711332CF";
+  static const uint8_t binary_fingerprint[16]; // = {0x50,0xC1,0x26,0x17,0xCD,0xB8,0x42,0x20,0xD0,0x7D,0x09,0x20,0x71,0x13,0x32,0xCF};
+
+  ApplicationDeploymentDescription() : isEmpty(false), appDeploymentId("DO_NOT_SET_AT_CLIENTS"), appModuleId(), computeHostId(), executablePath(), appDeploymentDescription(), moduleLoadCmd() {
+  }
+
+  virtual ~ApplicationDeploymentDescription() throw() {}
+
+  bool isEmpty;
+  std::string appDeploymentId;
+  std::string appModuleId;
+  std::string computeHostId;
+  std::string executablePath;
+  std::string appDeploymentDescription;
+  std::string moduleLoadCmd;
+  std::vector<SetEnvPaths>  libPrependPaths;
+  std::vector<SetEnvPaths>  libAppendPaths;
+  std::vector<SetEnvPaths>  setEnvironment;
+
+  _ApplicationDeploymentDescription__isset __isset;
+
+  void __set_isEmpty(const bool val) {
+    isEmpty = val;
+  }
+
+  void __set_appDeploymentId(const std::string& val) {
+    appDeploymentId = val;
+  }
+
+  void __set_appModuleId(const std::string& val) {
+    appModuleId = val;
+  }
+
+  void __set_computeHostId(const std::string& val) {
+    computeHostId = val;
+  }
+
+  void __set_executablePath(const std::string& val) {
+    executablePath = val;
+  }
+
+  void __set_appDeploymentDescription(const std::string& val) {
+    appDeploymentDescription = val;
+    __isset.appDeploymentDescription = true;
+  }
+
+  void __set_moduleLoadCmd(const std::string& val) {
+    moduleLoadCmd = val;
+    __isset.moduleLoadCmd = true;
+  }
+
+  void __set_libPrependPaths(const std::vector<SetEnvPaths> & val) {
+    libPrependPaths = val;
+    __isset.libPrependPaths = true;
+  }
+
+  void __set_libAppendPaths(const std::vector<SetEnvPaths> & val) {
+    libAppendPaths = val;
+    __isset.libAppendPaths = true;
+  }
+
+  void __set_setEnvironment(const std::vector<SetEnvPaths> & val) {
+    setEnvironment = val;
+    __isset.setEnvironment = true;
+  }
+
+  bool operator == (const ApplicationDeploymentDescription & rhs) const
+  {
+    if (!(isEmpty == rhs.isEmpty))
+      return false;
+    if (!(appDeploymentId == rhs.appDeploymentId))
+      return false;
+    if (!(appModuleId == rhs.appModuleId))
+      return false;
+    if (!(computeHostId == rhs.computeHostId))
+      return false;
+    if (!(executablePath == rhs.executablePath))
+      return false;
+    if (__isset.appDeploymentDescription != rhs.__isset.appDeploymentDescription)
+      return false;
+    else if (__isset.appDeploymentDescription && !(appDeploymentDescription == rhs.appDeploymentDescription))
+      return false;
+    if (__isset.moduleLoadCmd != rhs.__isset.moduleLoadCmd)
+      return false;
+    else if (__isset.moduleLoadCmd && !(moduleLoadCmd == rhs.moduleLoadCmd))
+      return false;
+    if (__isset.libPrependPaths != rhs.__isset.libPrependPaths)
+      return false;
+    else if (__isset.libPrependPaths && !(libPrependPaths == rhs.libPrependPaths))
+      return false;
+    if (__isset.libAppendPaths != rhs.__isset.libAppendPaths)
+      return false;
+    else if (__isset.libAppendPaths && !(libAppendPaths == rhs.libAppendPaths))
+      return false;
+    if (__isset.setEnvironment != rhs.__isset.setEnvironment)
+      return false;
+    else if (__isset.setEnvironment && !(setEnvironment == rhs.setEnvironment))
+      return false;
+    return true;
+  }
+  bool operator != (const ApplicationDeploymentDescription &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ApplicationDeploymentDescription & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(ApplicationDeploymentDescription &a, ApplicationDeploymentDescription &b);
+
+
+
+#endif

http://git-wip-us.apache.org/repos/asf/airavata/blob/8ebb254f/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationInterfaceModel_constants.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationInterfaceModel_constants.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationInterfaceModel_constants.cpp
new file mode 100644
index 0000000..6d8887f
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationInterfaceModel_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 "applicationInterfaceModel_constants.h"
+
+
+
+const applicationInterfaceModelConstants g_applicationInterfaceModel_constants;
+
+applicationInterfaceModelConstants::applicationInterfaceModelConstants() {
+  DEFAULT_ID = "DO_NOT_SET_AT_CLIENTS";
+
+}
+
+
+

http://git-wip-us.apache.org/repos/asf/airavata/blob/8ebb254f/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationInterfaceModel_constants.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationInterfaceModel_constants.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationInterfaceModel_constants.h
new file mode 100644
index 0000000..0bf5c4c
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationInterfaceModel_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 applicationInterfaceModel_CONSTANTS_H
+#define applicationInterfaceModel_CONSTANTS_H
+
+#include "applicationInterfaceModel_types.h"
+
+
+
+class applicationInterfaceModelConstants {
+ public:
+  applicationInterfaceModelConstants();
+
+  std::string DEFAULT_ID;
+};
+
+extern const applicationInterfaceModelConstants g_applicationInterfaceModel_constants;
+
+
+
+#endif

http://git-wip-us.apache.org/repos/asf/airavata/blob/8ebb254f/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationInterfaceModel_types.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationInterfaceModel_types.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationInterfaceModel_types.cpp
new file mode 100644
index 0000000..c393fab
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/applicationInterfaceModel_types.cpp
@@ -0,0 +1,504 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+#include "applicationInterfaceModel_types.h"
+
+#include <algorithm>
+
+
+
+int _kDataTypeValues[] = {
+  DataType::STRING,
+  DataType::INTEGER,
+  DataType::FLOAT,
+  DataType::URI
+};
+const char* _kDataTypeNames[] = {
+  "STRING",
+  "INTEGER",
+  "FLOAT",
+  "URI"
+};
+const std::map<int, const char*> _DataType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(4, _kDataTypeValues, _kDataTypeNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
+
+const char* InputDataObjectType::ascii_fingerprint = "0C147F4C4DFD0B9FF70275BF29D07281";
+const uint8_t InputDataObjectType::binary_fingerprint[16] = {0x0C,0x14,0x7F,0x4C,0x4D,0xFD,0x0B,0x9F,0xF7,0x02,0x75,0xBF,0x29,0xD0,0x72,0x81};
+
+uint32_t InputDataObjectType::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_name = 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->name);
+          isset_name = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->value);
+          this->__isset.value = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          int32_t ecast0;
+          xfer += iprot->readI32(ecast0);
+          this->type = (DataType::type)ecast0;
+          this->__isset.type = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 5:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->applicationArguement);
+          this->__isset.applicationArguement = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 6:
+        if (ftype == ::apache::thrift::protocol::T_BOOL) {
+          xfer += iprot->readBool(this->standardInput);
+          this->__isset.standardInput = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 7:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->userFriendlyDescription);
+          this->__isset.userFriendlyDescription = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 8:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->metaData);
+          this->__isset.metaData = 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_name)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t InputDataObjectType::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("InputDataObjectType");
+
+  xfer += oprot->writeFieldBegin("isEmpty", ::apache::thrift::protocol::T_BOOL, 1);
+  xfer += oprot->writeBool(this->isEmpty);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeString(this->name);
+  xfer += oprot->writeFieldEnd();
+
+  if (this->__isset.value) {
+    xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_STRING, 3);
+    xfer += oprot->writeString(this->value);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.type) {
+    xfer += oprot->writeFieldBegin("type", ::apache::thrift::protocol::T_I32, 4);
+    xfer += oprot->writeI32((int32_t)this->type);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.applicationArguement) {
+    xfer += oprot->writeFieldBegin("applicationArguement", ::apache::thrift::protocol::T_STRING, 5);
+    xfer += oprot->writeString(this->applicationArguement);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.standardInput) {
+    xfer += oprot->writeFieldBegin("standardInput", ::apache::thrift::protocol::T_BOOL, 6);
+    xfer += oprot->writeBool(this->standardInput);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.userFriendlyDescription) {
+    xfer += oprot->writeFieldBegin("userFriendlyDescription", ::apache::thrift::protocol::T_STRING, 7);
+    xfer += oprot->writeString(this->userFriendlyDescription);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.metaData) {
+    xfer += oprot->writeFieldBegin("metaData", ::apache::thrift::protocol::T_STRING, 8);
+    xfer += oprot->writeString(this->metaData);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(InputDataObjectType &a, InputDataObjectType &b) {
+  using ::std::swap;
+  swap(a.isEmpty, b.isEmpty);
+  swap(a.name, b.name);
+  swap(a.value, b.value);
+  swap(a.type, b.type);
+  swap(a.applicationArguement, b.applicationArguement);
+  swap(a.standardInput, b.standardInput);
+  swap(a.userFriendlyDescription, b.userFriendlyDescription);
+  swap(a.metaData, b.metaData);
+  swap(a.__isset, b.__isset);
+}
+
+const char* OutputDataObjectType::ascii_fingerprint = "FFD96F45C68610A5AC6E843C512B01EC";
+const uint8_t OutputDataObjectType::binary_fingerprint[16] = {0xFF,0xD9,0x6F,0x45,0xC6,0x86,0x10,0xA5,0xAC,0x6E,0x84,0x3C,0x51,0x2B,0x01,0xEC};
+
+uint32_t OutputDataObjectType::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_name = 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->name);
+          isset_name = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->value);
+          this->__isset.value = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          int32_t ecast1;
+          xfer += iprot->readI32(ecast1);
+          this->type = (DataType::type)ecast1;
+          this->__isset.type = 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_name)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t OutputDataObjectType::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("OutputDataObjectType");
+
+  xfer += oprot->writeFieldBegin("isEmpty", ::apache::thrift::protocol::T_BOOL, 1);
+  xfer += oprot->writeBool(this->isEmpty);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeString(this->name);
+  xfer += oprot->writeFieldEnd();
+
+  if (this->__isset.value) {
+    xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_STRING, 3);
+    xfer += oprot->writeString(this->value);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.type) {
+    xfer += oprot->writeFieldBegin("type", ::apache::thrift::protocol::T_I32, 4);
+    xfer += oprot->writeI32((int32_t)this->type);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(OutputDataObjectType &a, OutputDataObjectType &b) {
+  using ::std::swap;
+  swap(a.isEmpty, b.isEmpty);
+  swap(a.name, b.name);
+  swap(a.value, b.value);
+  swap(a.type, b.type);
+  swap(a.__isset, b.__isset);
+}
+
+const char* ApplicationInterfaceDescription::ascii_fingerprint = "EF5E3A4F34CCD8942A56C19B7B92E473";
+const uint8_t ApplicationInterfaceDescription::binary_fingerprint[16] = {0xEF,0x5E,0x3A,0x4F,0x34,0xCC,0xD8,0x94,0x2A,0x56,0xC1,0x9B,0x7B,0x92,0xE4,0x73};
+
+uint32_t ApplicationInterfaceDescription::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_applicationInterfaceId = false;
+  bool isset_applicationName = 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->applicationInterfaceId);
+          isset_applicationInterfaceId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->applicationName);
+          isset_applicationName = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->applicationModules.clear();
+            uint32_t _size2;
+            ::apache::thrift::protocol::TType _etype5;
+            xfer += iprot->readListBegin(_etype5, _size2);
+            this->applicationModules.resize(_size2);
+            uint32_t _i6;
+            for (_i6 = 0; _i6 < _size2; ++_i6)
+            {
+              xfer += iprot->readString(this->applicationModules[_i6]);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.applicationModules = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 5:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->applicationInputs.clear();
+            uint32_t _size7;
+            ::apache::thrift::protocol::TType _etype10;
+            xfer += iprot->readListBegin(_etype10, _size7);
+            this->applicationInputs.resize(_size7);
+            uint32_t _i11;
+            for (_i11 = 0; _i11 < _size7; ++_i11)
+            {
+              xfer += this->applicationInputs[_i11].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.applicationInputs = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 6:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->applicationOutputs.clear();
+            uint32_t _size12;
+            ::apache::thrift::protocol::TType _etype15;
+            xfer += iprot->readListBegin(_etype15, _size12);
+            this->applicationOutputs.resize(_size12);
+            uint32_t _i16;
+            for (_i16 = 0; _i16 < _size12; ++_i16)
+            {
+              xfer += this->applicationOutputs[_i16].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.applicationOutputs = 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_applicationInterfaceId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_applicationName)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t ApplicationInterfaceDescription::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("ApplicationInterfaceDescription");
+
+  xfer += oprot->writeFieldBegin("isEmpty", ::apache::thrift::protocol::T_BOOL, 1);
+  xfer += oprot->writeBool(this->isEmpty);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("applicationInterfaceId", ::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeString(this->applicationInterfaceId);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("applicationName", ::apache::thrift::protocol::T_STRING, 3);
+  xfer += oprot->writeString(this->applicationName);
+  xfer += oprot->writeFieldEnd();
+
+  if (this->__isset.applicationModules) {
+    xfer += oprot->writeFieldBegin("applicationModules", ::apache::thrift::protocol::T_LIST, 4);
+    {
+      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->applicationModules.size()));
+      std::vector<std::string> ::const_iterator _iter17;
+      for (_iter17 = this->applicationModules.begin(); _iter17 != this->applicationModules.end(); ++_iter17)
+      {
+        xfer += oprot->writeString((*_iter17));
+      }
+      xfer += oprot->writeListEnd();
+    }
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.applicationInputs) {
+    xfer += oprot->writeFieldBegin("applicationInputs", ::apache::thrift::protocol::T_LIST, 5);
+    {
+      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->applicationInputs.size()));
+      std::vector<InputDataObjectType> ::const_iterator _iter18;
+      for (_iter18 = this->applicationInputs.begin(); _iter18 != this->applicationInputs.end(); ++_iter18)
+      {
+        xfer += (*_iter18).write(oprot);
+      }
+      xfer += oprot->writeListEnd();
+    }
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.applicationOutputs) {
+    xfer += oprot->writeFieldBegin("applicationOutputs", ::apache::thrift::protocol::T_LIST, 6);
+    {
+      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->applicationOutputs.size()));
+      std::vector<OutputDataObjectType> ::const_iterator _iter19;
+      for (_iter19 = this->applicationOutputs.begin(); _iter19 != this->applicationOutputs.end(); ++_iter19)
+      {
+        xfer += (*_iter19).write(oprot);
+      }
+      xfer += oprot->writeListEnd();
+    }
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(ApplicationInterfaceDescription &a, ApplicationInterfaceDescription &b) {
+  using ::std::swap;
+  swap(a.isEmpty, b.isEmpty);
+  swap(a.applicationInterfaceId, b.applicationInterfaceId);
+  swap(a.applicationName, b.applicationName);
+  swap(a.applicationModules, b.applicationModules);
+  swap(a.applicationInputs, b.applicationInputs);
+  swap(a.applicationOutputs, b.applicationOutputs);
+  swap(a.__isset, b.__isset);
+}
+
+


Mime
View raw message