airavata-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From chath...@apache.org
Subject [23/44] adding workflow related changes back to airavata api
Date Wed, 05 Nov 2014 18:30:11 GMT
http://git-wip-us.apache.org/repos/asf/airavata/blob/ede66edf/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/Airavata.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/Airavata.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/Airavata.h
index 7387517..b68d927 100644
--- a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/Airavata.h
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/Airavata.h
@@ -63,6 +63,7 @@ class AiravataIf {
   virtual void registerApplicationModule(std::string& _return, const  ::apache::airavata::model::appcatalog::appdeployment::ApplicationModule& applicationModule) = 0;
   virtual void getApplicationModule( ::apache::airavata::model::appcatalog::appdeployment::ApplicationModule& _return, const std::string& appModuleId) = 0;
   virtual bool updateApplicationModule(const std::string& appModuleId, const  ::apache::airavata::model::appcatalog::appdeployment::ApplicationModule& applicationModule) = 0;
+  virtual void getAllModules(std::vector< ::apache::airavata::model::appcatalog::appdeployment::ApplicationModule> & _return) = 0;
   virtual bool deleteApplicationModule(const std::string& appModuleId) = 0;
   virtual void registerApplicationDeployment(std::string& _return, const  ::apache::airavata::model::appcatalog::appdeployment::ApplicationDeploymentDescription& applicationDeployment) = 0;
   virtual void getApplicationDeployment( ::apache::airavata::model::appcatalog::appdeployment::ApplicationDeploymentDescription& _return, const std::string& appDeploymentId) = 0;
@@ -123,6 +124,13 @@ class AiravataIf {
   virtual void getAllGatewayComputeResourcePreferences(std::vector< ::apache::airavata::model::appcatalog::gatewayprofile::ComputeResourcePreference> & _return, const std::string& gatewayID) = 0;
   virtual bool updateGatewayComputeResourcePreference(const std::string& gatewayID, const std::string& computeResourceId, const  ::apache::airavata::model::appcatalog::gatewayprofile::ComputeResourcePreference& computeResourcePreference) = 0;
   virtual bool deleteGatewayComputeResourcePreference(const std::string& gatewayID, const std::string& computeResourceId) = 0;
+  virtual void getAllWorkflows(std::vector<std::string> & _return) = 0;
+  virtual void getWorkflow( ::Workflow& _return, const std::string& workflowTemplateId) = 0;
+  virtual void deleteWorkflow(const std::string& workflowTemplateId) = 0;
+  virtual void registerWorkflow(std::string& _return, const  ::Workflow& workflow) = 0;
+  virtual void updateWorkflow(const std::string& workflowTemplateId, const  ::Workflow& workflow) = 0;
+  virtual void getWorkflowTemplateId(std::string& _return, const std::string& workflowName) = 0;
+  virtual bool isWorkflowExistWithName(const std::string& workflowName) = 0;
 };
 
 class AiravataIfFactory {
@@ -247,6 +255,9 @@ class AiravataNull : virtual public AiravataIf {
     bool _return = false;
     return _return;
   }
+  void getAllModules(std::vector< ::apache::airavata::model::appcatalog::appdeployment::ApplicationModule> & /* _return */) {
+    return;
+  }
   bool deleteApplicationModule(const std::string& /* appModuleId */) {
     bool _return = false;
     return _return;
@@ -454,6 +465,28 @@ class AiravataNull : virtual public AiravataIf {
     bool _return = false;
     return _return;
   }
+  void getAllWorkflows(std::vector<std::string> & /* _return */) {
+    return;
+  }
+  void getWorkflow( ::Workflow& /* _return */, const std::string& /* workflowTemplateId */) {
+    return;
+  }
+  void deleteWorkflow(const std::string& /* workflowTemplateId */) {
+    return;
+  }
+  void registerWorkflow(std::string& /* _return */, const  ::Workflow& /* workflow */) {
+    return;
+  }
+  void updateWorkflow(const std::string& /* workflowTemplateId */, const  ::Workflow& /* workflow */) {
+    return;
+  }
+  void getWorkflowTemplateId(std::string& /* _return */, const std::string& /* workflowName */) {
+    return;
+  }
+  bool isWorkflowExistWithName(const std::string& /* workflowName */) {
+    bool _return = false;
+    return _return;
+  }
 };
 
 
@@ -4684,6 +4717,130 @@ class Airavata_updateApplicationModule_presult {
 };
 
 
+class Airavata_getAllModules_args {
+ public:
+
+  Airavata_getAllModules_args() {
+  }
+
+  virtual ~Airavata_getAllModules_args() throw() {}
+
+
+  bool operator == (const Airavata_getAllModules_args & /* rhs */) const
+  {
+    return true;
+  }
+  bool operator != (const Airavata_getAllModules_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Airavata_getAllModules_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Airavata_getAllModules_pargs {
+ public:
+
+
+  virtual ~Airavata_getAllModules_pargs() throw() {}
+
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_getAllModules_result__isset {
+  _Airavata_getAllModules_result__isset() : success(false), ire(false), ace(false), ase(false) {}
+  bool success;
+  bool ire;
+  bool ace;
+  bool ase;
+} _Airavata_getAllModules_result__isset;
+
+class Airavata_getAllModules_result {
+ public:
+
+  Airavata_getAllModules_result() {
+  }
+
+  virtual ~Airavata_getAllModules_result() throw() {}
+
+  std::vector< ::apache::airavata::model::appcatalog::appdeployment::ApplicationModule>  success;
+   ::apache::airavata::api::error::InvalidRequestException ire;
+   ::apache::airavata::api::error::AiravataClientException ace;
+   ::apache::airavata::api::error::AiravataSystemException ase;
+
+  _Airavata_getAllModules_result__isset __isset;
+
+  void __set_success(const std::vector< ::apache::airavata::model::appcatalog::appdeployment::ApplicationModule> & val) {
+    success = val;
+  }
+
+  void __set_ire(const  ::apache::airavata::api::error::InvalidRequestException& val) {
+    ire = val;
+  }
+
+  void __set_ace(const  ::apache::airavata::api::error::AiravataClientException& val) {
+    ace = val;
+  }
+
+  void __set_ase(const  ::apache::airavata::api::error::AiravataSystemException& val) {
+    ase = val;
+  }
+
+  bool operator == (const Airavata_getAllModules_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(ire == rhs.ire))
+      return false;
+    if (!(ace == rhs.ace))
+      return false;
+    if (!(ase == rhs.ase))
+      return false;
+    return true;
+  }
+  bool operator != (const Airavata_getAllModules_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Airavata_getAllModules_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_getAllModules_presult__isset {
+  _Airavata_getAllModules_presult__isset() : success(false), ire(false), ace(false), ase(false) {}
+  bool success;
+  bool ire;
+  bool ace;
+  bool ase;
+} _Airavata_getAllModules_presult__isset;
+
+class Airavata_getAllModules_presult {
+ public:
+
+
+  virtual ~Airavata_getAllModules_presult() throw() {}
+
+  std::vector< ::apache::airavata::model::appcatalog::appdeployment::ApplicationModule> * success;
+   ::apache::airavata::api::error::InvalidRequestException ire;
+   ::apache::airavata::api::error::AiravataClientException ace;
+   ::apache::airavata::api::error::AiravataSystemException ase;
+
+  _Airavata_getAllModules_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
 class Airavata_deleteApplicationModule_args {
  public:
 
@@ -12867,121 +13024,1028 @@ class Airavata_deleteGatewayComputeResourcePreference_presult {
 
 };
 
-class AiravataClient : virtual public AiravataIf {
+
+class Airavata_getAllWorkflows_args {
  public:
-  AiravataClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) :
-    piprot_(prot),
-    poprot_(prot) {
-    iprot_ = prot.get();
-    oprot_ = prot.get();
+
+  Airavata_getAllWorkflows_args() {
   }
-  AiravataClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, boost::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) :
-    piprot_(iprot),
-    poprot_(oprot) {
-    iprot_ = iprot.get();
-    oprot_ = oprot.get();
+
+  virtual ~Airavata_getAllWorkflows_args() throw() {}
+
+
+  bool operator == (const Airavata_getAllWorkflows_args & /* rhs */) const
+  {
+    return true;
   }
-  boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() {
-    return piprot_;
+  bool operator != (const Airavata_getAllWorkflows_args &rhs) const {
+    return !(*this == rhs);
   }
-  boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() {
-    return poprot_;
+
+  bool operator < (const Airavata_getAllWorkflows_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Airavata_getAllWorkflows_pargs {
+ public:
+
+
+  virtual ~Airavata_getAllWorkflows_pargs() throw() {}
+
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_getAllWorkflows_result__isset {
+  _Airavata_getAllWorkflows_result__isset() : success(false), ire(false), ace(false), ase(false) {}
+  bool success;
+  bool ire;
+  bool ace;
+  bool ase;
+} _Airavata_getAllWorkflows_result__isset;
+
+class Airavata_getAllWorkflows_result {
+ public:
+
+  Airavata_getAllWorkflows_result() {
   }
-  void getAPIVersion(std::string& _return);
-  void send_getAPIVersion();
-  void recv_getAPIVersion(std::string& _return);
-  void createProject(std::string& _return, const  ::apache::airavata::model::workspace::Project& project);
-  void send_createProject(const  ::apache::airavata::model::workspace::Project& project);
-  void recv_createProject(std::string& _return);
-  void updateProject(const std::string& projectId, const  ::apache::airavata::model::workspace::Project& updatedProject);
-  void send_updateProject(const std::string& projectId, const  ::apache::airavata::model::workspace::Project& updatedProject);
-  void recv_updateProject();
-  void getProject( ::apache::airavata::model::workspace::Project& _return, const std::string& projectId);
-  void send_getProject(const std::string& projectId);
-  void recv_getProject( ::apache::airavata::model::workspace::Project& _return);
-  void getAllUserProjects(std::vector< ::apache::airavata::model::workspace::Project> & _return, const std::string& userName);
-  void send_getAllUserProjects(const std::string& userName);
-  void recv_getAllUserProjects(std::vector< ::apache::airavata::model::workspace::Project> & _return);
-  void searchProjectsByProjectName(std::vector< ::apache::airavata::model::workspace::Project> & _return, const std::string& userName, const std::string& projectName);
-  void send_searchProjectsByProjectName(const std::string& userName, const std::string& projectName);
-  void recv_searchProjectsByProjectName(std::vector< ::apache::airavata::model::workspace::Project> & _return);
-  void searchProjectsByProjectDesc(std::vector< ::apache::airavata::model::workspace::Project> & _return, const std::string& userName, const std::string& description);
-  void send_searchProjectsByProjectDesc(const std::string& userName, const std::string& description);
-  void recv_searchProjectsByProjectDesc(std::vector< ::apache::airavata::model::workspace::Project> & _return);
-  void searchExperimentsByName(std::vector< ::apache::airavata::model::workspace::experiment::ExperimentSummary> & _return, const std::string& userName, const std::string& expName);
-  void send_searchExperimentsByName(const std::string& userName, const std::string& expName);
-  void recv_searchExperimentsByName(std::vector< ::apache::airavata::model::workspace::experiment::ExperimentSummary> & _return);
-  void searchExperimentsByDesc(std::vector< ::apache::airavata::model::workspace::experiment::ExperimentSummary> & _return, const std::string& userName, const std::string& description);
-  void send_searchExperimentsByDesc(const std::string& userName, const std::string& description);
-  void recv_searchExperimentsByDesc(std::vector< ::apache::airavata::model::workspace::experiment::ExperimentSummary> & _return);
-  void searchExperimentsByApplication(std::vector< ::apache::airavata::model::workspace::experiment::ExperimentSummary> & _return, const std::string& userName, const std::string& applicationId);
-  void send_searchExperimentsByApplication(const std::string& userName, const std::string& applicationId);
-  void recv_searchExperimentsByApplication(std::vector< ::apache::airavata::model::workspace::experiment::ExperimentSummary> & _return);
-  void searchExperimentsByStatus(std::vector< ::apache::airavata::model::workspace::experiment::ExperimentSummary> & _return, const std::string& userName, const  ::apache::airavata::model::workspace::experiment::ExperimentState::type experimentState);
-  void send_searchExperimentsByStatus(const std::string& userName, const  ::apache::airavata::model::workspace::experiment::ExperimentState::type experimentState);
-  void recv_searchExperimentsByStatus(std::vector< ::apache::airavata::model::workspace::experiment::ExperimentSummary> & _return);
-  void searchExperimentsByCreationTime(std::vector< ::apache::airavata::model::workspace::experiment::ExperimentSummary> & _return, const std::string& userName, const int64_t fromTime, const int64_t toTime);
-  void send_searchExperimentsByCreationTime(const std::string& userName, const int64_t fromTime, const int64_t toTime);
-  void recv_searchExperimentsByCreationTime(std::vector< ::apache::airavata::model::workspace::experiment::ExperimentSummary> & _return);
-  void getAllExperimentsInProject(std::vector< ::apache::airavata::model::workspace::experiment::Experiment> & _return, const std::string& projectId);
-  void send_getAllExperimentsInProject(const std::string& projectId);
-  void recv_getAllExperimentsInProject(std::vector< ::apache::airavata::model::workspace::experiment::Experiment> & _return);
-  void getAllUserExperiments(std::vector< ::apache::airavata::model::workspace::experiment::Experiment> & _return, const std::string& userName);
-  void send_getAllUserExperiments(const std::string& userName);
-  void recv_getAllUserExperiments(std::vector< ::apache::airavata::model::workspace::experiment::Experiment> & _return);
-  void createExperiment(std::string& _return, const  ::apache::airavata::model::workspace::experiment::Experiment& experiment);
-  void send_createExperiment(const  ::apache::airavata::model::workspace::experiment::Experiment& experiment);
-  void recv_createExperiment(std::string& _return);
-  void getExperiment( ::apache::airavata::model::workspace::experiment::Experiment& _return, const std::string& airavataExperimentId);
-  void send_getExperiment(const std::string& airavataExperimentId);
-  void recv_getExperiment( ::apache::airavata::model::workspace::experiment::Experiment& _return);
-  void updateExperiment(const std::string& airavataExperimentId, const  ::apache::airavata::model::workspace::experiment::Experiment& experiment);
-  void send_updateExperiment(const std::string& airavataExperimentId, const  ::apache::airavata::model::workspace::experiment::Experiment& experiment);
-  void recv_updateExperiment();
-  void updateExperimentConfiguration(const std::string& airavataExperimentId, const  ::apache::airavata::model::workspace::experiment::UserConfigurationData& userConfiguration);
-  void send_updateExperimentConfiguration(const std::string& airavataExperimentId, const  ::apache::airavata::model::workspace::experiment::UserConfigurationData& userConfiguration);
-  void recv_updateExperimentConfiguration();
-  void updateResourceScheduleing(const std::string& airavataExperimentId, const  ::apache::airavata::model::workspace::experiment::ComputationalResourceScheduling& resourceScheduling);
-  void send_updateResourceScheduleing(const std::string& airavataExperimentId, const  ::apache::airavata::model::workspace::experiment::ComputationalResourceScheduling& resourceScheduling);
-  void recv_updateResourceScheduleing();
-  bool validateExperiment(const std::string& airavataExperimentId);
-  void send_validateExperiment(const std::string& airavataExperimentId);
-  bool recv_validateExperiment();
-  void launchExperiment(const std::string& airavataExperimentId, const std::string& airavataCredStoreToken);
-  void send_launchExperiment(const std::string& airavataExperimentId, const std::string& airavataCredStoreToken);
-  void recv_launchExperiment();
-  void getExperimentStatus( ::apache::airavata::model::workspace::experiment::ExperimentStatus& _return, const std::string& airavataExperimentId);
-  void send_getExperimentStatus(const std::string& airavataExperimentId);
-  void recv_getExperimentStatus( ::apache::airavata::model::workspace::experiment::ExperimentStatus& _return);
-  void getExperimentOutputs(std::vector< ::apache::airavata::model::workspace::experiment::DataObjectType> & _return, const std::string& airavataExperimentId);
-  void send_getExperimentOutputs(const std::string& airavataExperimentId);
-  void recv_getExperimentOutputs(std::vector< ::apache::airavata::model::workspace::experiment::DataObjectType> & _return);
-  void getJobStatuses(std::map<std::string,  ::apache::airavata::model::workspace::experiment::JobStatus> & _return, const std::string& airavataExperimentId);
-  void send_getJobStatuses(const std::string& airavataExperimentId);
-  void recv_getJobStatuses(std::map<std::string,  ::apache::airavata::model::workspace::experiment::JobStatus> & _return);
-  void getJobDetails(std::vector< ::apache::airavata::model::workspace::experiment::JobDetails> & _return, const std::string& airavataExperimentId);
-  void send_getJobDetails(const std::string& airavataExperimentId);
-  void recv_getJobDetails(std::vector< ::apache::airavata::model::workspace::experiment::JobDetails> & _return);
-  void getDataTransferDetails(std::vector< ::apache::airavata::model::workspace::experiment::DataTransferDetails> & _return, const std::string& airavataExperimentId);
-  void send_getDataTransferDetails(const std::string& airavataExperimentId);
-  void recv_getDataTransferDetails(std::vector< ::apache::airavata::model::workspace::experiment::DataTransferDetails> & _return);
-  void cloneExperiment(std::string& _return, const std::string& existingExperimentID, const std::string& newExperimentName);
-  void send_cloneExperiment(const std::string& existingExperimentID, const std::string& newExperimentName);
-  void recv_cloneExperiment(std::string& _return);
-  void terminateExperiment(const std::string& airavataExperimentId);
-  void send_terminateExperiment(const std::string& airavataExperimentId);
-  void recv_terminateExperiment();
-  void registerApplicationModule(std::string& _return, const  ::apache::airavata::model::appcatalog::appdeployment::ApplicationModule& applicationModule);
-  void send_registerApplicationModule(const  ::apache::airavata::model::appcatalog::appdeployment::ApplicationModule& applicationModule);
-  void recv_registerApplicationModule(std::string& _return);
-  void getApplicationModule( ::apache::airavata::model::appcatalog::appdeployment::ApplicationModule& _return, const std::string& appModuleId);
-  void send_getApplicationModule(const std::string& appModuleId);
-  void recv_getApplicationModule( ::apache::airavata::model::appcatalog::appdeployment::ApplicationModule& _return);
-  bool updateApplicationModule(const std::string& appModuleId, const  ::apache::airavata::model::appcatalog::appdeployment::ApplicationModule& applicationModule);
-  void send_updateApplicationModule(const std::string& appModuleId, const  ::apache::airavata::model::appcatalog::appdeployment::ApplicationModule& applicationModule);
-  bool recv_updateApplicationModule();
-  bool deleteApplicationModule(const std::string& appModuleId);
-  void send_deleteApplicationModule(const std::string& appModuleId);
+
+  virtual ~Airavata_getAllWorkflows_result() throw() {}
+
+  std::vector<std::string>  success;
+   ::apache::airavata::api::error::InvalidRequestException ire;
+   ::apache::airavata::api::error::AiravataClientException ace;
+   ::apache::airavata::api::error::AiravataSystemException ase;
+
+  _Airavata_getAllWorkflows_result__isset __isset;
+
+  void __set_success(const std::vector<std::string> & val) {
+    success = val;
+  }
+
+  void __set_ire(const  ::apache::airavata::api::error::InvalidRequestException& val) {
+    ire = val;
+  }
+
+  void __set_ace(const  ::apache::airavata::api::error::AiravataClientException& val) {
+    ace = val;
+  }
+
+  void __set_ase(const  ::apache::airavata::api::error::AiravataSystemException& val) {
+    ase = val;
+  }
+
+  bool operator == (const Airavata_getAllWorkflows_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(ire == rhs.ire))
+      return false;
+    if (!(ace == rhs.ace))
+      return false;
+    if (!(ase == rhs.ase))
+      return false;
+    return true;
+  }
+  bool operator != (const Airavata_getAllWorkflows_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Airavata_getAllWorkflows_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_getAllWorkflows_presult__isset {
+  _Airavata_getAllWorkflows_presult__isset() : success(false), ire(false), ace(false), ase(false) {}
+  bool success;
+  bool ire;
+  bool ace;
+  bool ase;
+} _Airavata_getAllWorkflows_presult__isset;
+
+class Airavata_getAllWorkflows_presult {
+ public:
+
+
+  virtual ~Airavata_getAllWorkflows_presult() throw() {}
+
+  std::vector<std::string> * success;
+   ::apache::airavata::api::error::InvalidRequestException ire;
+   ::apache::airavata::api::error::AiravataClientException ace;
+   ::apache::airavata::api::error::AiravataSystemException ase;
+
+  _Airavata_getAllWorkflows_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Airavata_getWorkflow_args {
+ public:
+
+  Airavata_getWorkflow_args() : workflowTemplateId() {
+  }
+
+  virtual ~Airavata_getWorkflow_args() throw() {}
+
+  std::string workflowTemplateId;
+
+  void __set_workflowTemplateId(const std::string& val) {
+    workflowTemplateId = val;
+  }
+
+  bool operator == (const Airavata_getWorkflow_args & rhs) const
+  {
+    if (!(workflowTemplateId == rhs.workflowTemplateId))
+      return false;
+    return true;
+  }
+  bool operator != (const Airavata_getWorkflow_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Airavata_getWorkflow_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Airavata_getWorkflow_pargs {
+ public:
+
+
+  virtual ~Airavata_getWorkflow_pargs() throw() {}
+
+  const std::string* workflowTemplateId;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_getWorkflow_result__isset {
+  _Airavata_getWorkflow_result__isset() : success(false), ire(false), ace(false), ase(false) {}
+  bool success;
+  bool ire;
+  bool ace;
+  bool ase;
+} _Airavata_getWorkflow_result__isset;
+
+class Airavata_getWorkflow_result {
+ public:
+
+  Airavata_getWorkflow_result() {
+  }
+
+  virtual ~Airavata_getWorkflow_result() throw() {}
+
+   ::Workflow success;
+   ::apache::airavata::api::error::InvalidRequestException ire;
+   ::apache::airavata::api::error::AiravataClientException ace;
+   ::apache::airavata::api::error::AiravataSystemException ase;
+
+  _Airavata_getWorkflow_result__isset __isset;
+
+  void __set_success(const  ::Workflow& val) {
+    success = val;
+  }
+
+  void __set_ire(const  ::apache::airavata::api::error::InvalidRequestException& val) {
+    ire = val;
+  }
+
+  void __set_ace(const  ::apache::airavata::api::error::AiravataClientException& val) {
+    ace = val;
+  }
+
+  void __set_ase(const  ::apache::airavata::api::error::AiravataSystemException& val) {
+    ase = val;
+  }
+
+  bool operator == (const Airavata_getWorkflow_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(ire == rhs.ire))
+      return false;
+    if (!(ace == rhs.ace))
+      return false;
+    if (!(ase == rhs.ase))
+      return false;
+    return true;
+  }
+  bool operator != (const Airavata_getWorkflow_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Airavata_getWorkflow_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_getWorkflow_presult__isset {
+  _Airavata_getWorkflow_presult__isset() : success(false), ire(false), ace(false), ase(false) {}
+  bool success;
+  bool ire;
+  bool ace;
+  bool ase;
+} _Airavata_getWorkflow_presult__isset;
+
+class Airavata_getWorkflow_presult {
+ public:
+
+
+  virtual ~Airavata_getWorkflow_presult() throw() {}
+
+   ::Workflow* success;
+   ::apache::airavata::api::error::InvalidRequestException ire;
+   ::apache::airavata::api::error::AiravataClientException ace;
+   ::apache::airavata::api::error::AiravataSystemException ase;
+
+  _Airavata_getWorkflow_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Airavata_deleteWorkflow_args {
+ public:
+
+  Airavata_deleteWorkflow_args() : workflowTemplateId() {
+  }
+
+  virtual ~Airavata_deleteWorkflow_args() throw() {}
+
+  std::string workflowTemplateId;
+
+  void __set_workflowTemplateId(const std::string& val) {
+    workflowTemplateId = val;
+  }
+
+  bool operator == (const Airavata_deleteWorkflow_args & rhs) const
+  {
+    if (!(workflowTemplateId == rhs.workflowTemplateId))
+      return false;
+    return true;
+  }
+  bool operator != (const Airavata_deleteWorkflow_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Airavata_deleteWorkflow_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Airavata_deleteWorkflow_pargs {
+ public:
+
+
+  virtual ~Airavata_deleteWorkflow_pargs() throw() {}
+
+  const std::string* workflowTemplateId;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_deleteWorkflow_result__isset {
+  _Airavata_deleteWorkflow_result__isset() : ire(false), ace(false), ase(false) {}
+  bool ire;
+  bool ace;
+  bool ase;
+} _Airavata_deleteWorkflow_result__isset;
+
+class Airavata_deleteWorkflow_result {
+ public:
+
+  Airavata_deleteWorkflow_result() {
+  }
+
+  virtual ~Airavata_deleteWorkflow_result() throw() {}
+
+   ::apache::airavata::api::error::InvalidRequestException ire;
+   ::apache::airavata::api::error::AiravataClientException ace;
+   ::apache::airavata::api::error::AiravataSystemException ase;
+
+  _Airavata_deleteWorkflow_result__isset __isset;
+
+  void __set_ire(const  ::apache::airavata::api::error::InvalidRequestException& val) {
+    ire = val;
+  }
+
+  void __set_ace(const  ::apache::airavata::api::error::AiravataClientException& val) {
+    ace = val;
+  }
+
+  void __set_ase(const  ::apache::airavata::api::error::AiravataSystemException& val) {
+    ase = val;
+  }
+
+  bool operator == (const Airavata_deleteWorkflow_result & rhs) const
+  {
+    if (!(ire == rhs.ire))
+      return false;
+    if (!(ace == rhs.ace))
+      return false;
+    if (!(ase == rhs.ase))
+      return false;
+    return true;
+  }
+  bool operator != (const Airavata_deleteWorkflow_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Airavata_deleteWorkflow_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_deleteWorkflow_presult__isset {
+  _Airavata_deleteWorkflow_presult__isset() : ire(false), ace(false), ase(false) {}
+  bool ire;
+  bool ace;
+  bool ase;
+} _Airavata_deleteWorkflow_presult__isset;
+
+class Airavata_deleteWorkflow_presult {
+ public:
+
+
+  virtual ~Airavata_deleteWorkflow_presult() throw() {}
+
+   ::apache::airavata::api::error::InvalidRequestException ire;
+   ::apache::airavata::api::error::AiravataClientException ace;
+   ::apache::airavata::api::error::AiravataSystemException ase;
+
+  _Airavata_deleteWorkflow_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Airavata_registerWorkflow_args {
+ public:
+
+  Airavata_registerWorkflow_args() {
+  }
+
+  virtual ~Airavata_registerWorkflow_args() throw() {}
+
+   ::Workflow workflow;
+
+  void __set_workflow(const  ::Workflow& val) {
+    workflow = val;
+  }
+
+  bool operator == (const Airavata_registerWorkflow_args & rhs) const
+  {
+    if (!(workflow == rhs.workflow))
+      return false;
+    return true;
+  }
+  bool operator != (const Airavata_registerWorkflow_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Airavata_registerWorkflow_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Airavata_registerWorkflow_pargs {
+ public:
+
+
+  virtual ~Airavata_registerWorkflow_pargs() throw() {}
+
+  const  ::Workflow* workflow;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_registerWorkflow_result__isset {
+  _Airavata_registerWorkflow_result__isset() : success(false), ire(false), ace(false), ase(false) {}
+  bool success;
+  bool ire;
+  bool ace;
+  bool ase;
+} _Airavata_registerWorkflow_result__isset;
+
+class Airavata_registerWorkflow_result {
+ public:
+
+  Airavata_registerWorkflow_result() : success() {
+  }
+
+  virtual ~Airavata_registerWorkflow_result() throw() {}
+
+  std::string success;
+   ::apache::airavata::api::error::InvalidRequestException ire;
+   ::apache::airavata::api::error::AiravataClientException ace;
+   ::apache::airavata::api::error::AiravataSystemException ase;
+
+  _Airavata_registerWorkflow_result__isset __isset;
+
+  void __set_success(const std::string& val) {
+    success = val;
+  }
+
+  void __set_ire(const  ::apache::airavata::api::error::InvalidRequestException& val) {
+    ire = val;
+  }
+
+  void __set_ace(const  ::apache::airavata::api::error::AiravataClientException& val) {
+    ace = val;
+  }
+
+  void __set_ase(const  ::apache::airavata::api::error::AiravataSystemException& val) {
+    ase = val;
+  }
+
+  bool operator == (const Airavata_registerWorkflow_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(ire == rhs.ire))
+      return false;
+    if (!(ace == rhs.ace))
+      return false;
+    if (!(ase == rhs.ase))
+      return false;
+    return true;
+  }
+  bool operator != (const Airavata_registerWorkflow_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Airavata_registerWorkflow_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_registerWorkflow_presult__isset {
+  _Airavata_registerWorkflow_presult__isset() : success(false), ire(false), ace(false), ase(false) {}
+  bool success;
+  bool ire;
+  bool ace;
+  bool ase;
+} _Airavata_registerWorkflow_presult__isset;
+
+class Airavata_registerWorkflow_presult {
+ public:
+
+
+  virtual ~Airavata_registerWorkflow_presult() throw() {}
+
+  std::string* success;
+   ::apache::airavata::api::error::InvalidRequestException ire;
+   ::apache::airavata::api::error::AiravataClientException ace;
+   ::apache::airavata::api::error::AiravataSystemException ase;
+
+  _Airavata_registerWorkflow_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Airavata_updateWorkflow_args {
+ public:
+
+  Airavata_updateWorkflow_args() : workflowTemplateId() {
+  }
+
+  virtual ~Airavata_updateWorkflow_args() throw() {}
+
+  std::string workflowTemplateId;
+   ::Workflow workflow;
+
+  void __set_workflowTemplateId(const std::string& val) {
+    workflowTemplateId = val;
+  }
+
+  void __set_workflow(const  ::Workflow& val) {
+    workflow = val;
+  }
+
+  bool operator == (const Airavata_updateWorkflow_args & rhs) const
+  {
+    if (!(workflowTemplateId == rhs.workflowTemplateId))
+      return false;
+    if (!(workflow == rhs.workflow))
+      return false;
+    return true;
+  }
+  bool operator != (const Airavata_updateWorkflow_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Airavata_updateWorkflow_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Airavata_updateWorkflow_pargs {
+ public:
+
+
+  virtual ~Airavata_updateWorkflow_pargs() throw() {}
+
+  const std::string* workflowTemplateId;
+  const  ::Workflow* workflow;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_updateWorkflow_result__isset {
+  _Airavata_updateWorkflow_result__isset() : ire(false), ace(false), ase(false) {}
+  bool ire;
+  bool ace;
+  bool ase;
+} _Airavata_updateWorkflow_result__isset;
+
+class Airavata_updateWorkflow_result {
+ public:
+
+  Airavata_updateWorkflow_result() {
+  }
+
+  virtual ~Airavata_updateWorkflow_result() throw() {}
+
+   ::apache::airavata::api::error::InvalidRequestException ire;
+   ::apache::airavata::api::error::AiravataClientException ace;
+   ::apache::airavata::api::error::AiravataSystemException ase;
+
+  _Airavata_updateWorkflow_result__isset __isset;
+
+  void __set_ire(const  ::apache::airavata::api::error::InvalidRequestException& val) {
+    ire = val;
+  }
+
+  void __set_ace(const  ::apache::airavata::api::error::AiravataClientException& val) {
+    ace = val;
+  }
+
+  void __set_ase(const  ::apache::airavata::api::error::AiravataSystemException& val) {
+    ase = val;
+  }
+
+  bool operator == (const Airavata_updateWorkflow_result & rhs) const
+  {
+    if (!(ire == rhs.ire))
+      return false;
+    if (!(ace == rhs.ace))
+      return false;
+    if (!(ase == rhs.ase))
+      return false;
+    return true;
+  }
+  bool operator != (const Airavata_updateWorkflow_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Airavata_updateWorkflow_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_updateWorkflow_presult__isset {
+  _Airavata_updateWorkflow_presult__isset() : ire(false), ace(false), ase(false) {}
+  bool ire;
+  bool ace;
+  bool ase;
+} _Airavata_updateWorkflow_presult__isset;
+
+class Airavata_updateWorkflow_presult {
+ public:
+
+
+  virtual ~Airavata_updateWorkflow_presult() throw() {}
+
+   ::apache::airavata::api::error::InvalidRequestException ire;
+   ::apache::airavata::api::error::AiravataClientException ace;
+   ::apache::airavata::api::error::AiravataSystemException ase;
+
+  _Airavata_updateWorkflow_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Airavata_getWorkflowTemplateId_args {
+ public:
+
+  Airavata_getWorkflowTemplateId_args() : workflowName() {
+  }
+
+  virtual ~Airavata_getWorkflowTemplateId_args() throw() {}
+
+  std::string workflowName;
+
+  void __set_workflowName(const std::string& val) {
+    workflowName = val;
+  }
+
+  bool operator == (const Airavata_getWorkflowTemplateId_args & rhs) const
+  {
+    if (!(workflowName == rhs.workflowName))
+      return false;
+    return true;
+  }
+  bool operator != (const Airavata_getWorkflowTemplateId_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Airavata_getWorkflowTemplateId_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Airavata_getWorkflowTemplateId_pargs {
+ public:
+
+
+  virtual ~Airavata_getWorkflowTemplateId_pargs() throw() {}
+
+  const std::string* workflowName;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_getWorkflowTemplateId_result__isset {
+  _Airavata_getWorkflowTemplateId_result__isset() : success(false), ire(false), ace(false), ase(false) {}
+  bool success;
+  bool ire;
+  bool ace;
+  bool ase;
+} _Airavata_getWorkflowTemplateId_result__isset;
+
+class Airavata_getWorkflowTemplateId_result {
+ public:
+
+  Airavata_getWorkflowTemplateId_result() : success() {
+  }
+
+  virtual ~Airavata_getWorkflowTemplateId_result() throw() {}
+
+  std::string success;
+   ::apache::airavata::api::error::InvalidRequestException ire;
+   ::apache::airavata::api::error::AiravataClientException ace;
+   ::apache::airavata::api::error::AiravataSystemException ase;
+
+  _Airavata_getWorkflowTemplateId_result__isset __isset;
+
+  void __set_success(const std::string& val) {
+    success = val;
+  }
+
+  void __set_ire(const  ::apache::airavata::api::error::InvalidRequestException& val) {
+    ire = val;
+  }
+
+  void __set_ace(const  ::apache::airavata::api::error::AiravataClientException& val) {
+    ace = val;
+  }
+
+  void __set_ase(const  ::apache::airavata::api::error::AiravataSystemException& val) {
+    ase = val;
+  }
+
+  bool operator == (const Airavata_getWorkflowTemplateId_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(ire == rhs.ire))
+      return false;
+    if (!(ace == rhs.ace))
+      return false;
+    if (!(ase == rhs.ase))
+      return false;
+    return true;
+  }
+  bool operator != (const Airavata_getWorkflowTemplateId_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Airavata_getWorkflowTemplateId_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_getWorkflowTemplateId_presult__isset {
+  _Airavata_getWorkflowTemplateId_presult__isset() : success(false), ire(false), ace(false), ase(false) {}
+  bool success;
+  bool ire;
+  bool ace;
+  bool ase;
+} _Airavata_getWorkflowTemplateId_presult__isset;
+
+class Airavata_getWorkflowTemplateId_presult {
+ public:
+
+
+  virtual ~Airavata_getWorkflowTemplateId_presult() throw() {}
+
+  std::string* success;
+   ::apache::airavata::api::error::InvalidRequestException ire;
+   ::apache::airavata::api::error::AiravataClientException ace;
+   ::apache::airavata::api::error::AiravataSystemException ase;
+
+  _Airavata_getWorkflowTemplateId_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Airavata_isWorkflowExistWithName_args {
+ public:
+
+  Airavata_isWorkflowExistWithName_args() : workflowName() {
+  }
+
+  virtual ~Airavata_isWorkflowExistWithName_args() throw() {}
+
+  std::string workflowName;
+
+  void __set_workflowName(const std::string& val) {
+    workflowName = val;
+  }
+
+  bool operator == (const Airavata_isWorkflowExistWithName_args & rhs) const
+  {
+    if (!(workflowName == rhs.workflowName))
+      return false;
+    return true;
+  }
+  bool operator != (const Airavata_isWorkflowExistWithName_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Airavata_isWorkflowExistWithName_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Airavata_isWorkflowExistWithName_pargs {
+ public:
+
+
+  virtual ~Airavata_isWorkflowExistWithName_pargs() throw() {}
+
+  const std::string* workflowName;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_isWorkflowExistWithName_result__isset {
+  _Airavata_isWorkflowExistWithName_result__isset() : success(false), ire(false), ace(false), ase(false) {}
+  bool success;
+  bool ire;
+  bool ace;
+  bool ase;
+} _Airavata_isWorkflowExistWithName_result__isset;
+
+class Airavata_isWorkflowExistWithName_result {
+ public:
+
+  Airavata_isWorkflowExistWithName_result() : success(0) {
+  }
+
+  virtual ~Airavata_isWorkflowExistWithName_result() throw() {}
+
+  bool success;
+   ::apache::airavata::api::error::InvalidRequestException ire;
+   ::apache::airavata::api::error::AiravataClientException ace;
+   ::apache::airavata::api::error::AiravataSystemException ase;
+
+  _Airavata_isWorkflowExistWithName_result__isset __isset;
+
+  void __set_success(const bool val) {
+    success = val;
+  }
+
+  void __set_ire(const  ::apache::airavata::api::error::InvalidRequestException& val) {
+    ire = val;
+  }
+
+  void __set_ace(const  ::apache::airavata::api::error::AiravataClientException& val) {
+    ace = val;
+  }
+
+  void __set_ase(const  ::apache::airavata::api::error::AiravataSystemException& val) {
+    ase = val;
+  }
+
+  bool operator == (const Airavata_isWorkflowExistWithName_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(ire == rhs.ire))
+      return false;
+    if (!(ace == rhs.ace))
+      return false;
+    if (!(ase == rhs.ase))
+      return false;
+    return true;
+  }
+  bool operator != (const Airavata_isWorkflowExistWithName_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Airavata_isWorkflowExistWithName_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_isWorkflowExistWithName_presult__isset {
+  _Airavata_isWorkflowExistWithName_presult__isset() : success(false), ire(false), ace(false), ase(false) {}
+  bool success;
+  bool ire;
+  bool ace;
+  bool ase;
+} _Airavata_isWorkflowExistWithName_presult__isset;
+
+class Airavata_isWorkflowExistWithName_presult {
+ public:
+
+
+  virtual ~Airavata_isWorkflowExistWithName_presult() throw() {}
+
+  bool* success;
+   ::apache::airavata::api::error::InvalidRequestException ire;
+   ::apache::airavata::api::error::AiravataClientException ace;
+   ::apache::airavata::api::error::AiravataSystemException ase;
+
+  _Airavata_isWorkflowExistWithName_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+class AiravataClient : virtual public AiravataIf {
+ public:
+  AiravataClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) :
+    piprot_(prot),
+    poprot_(prot) {
+    iprot_ = prot.get();
+    oprot_ = prot.get();
+  }
+  AiravataClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, boost::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) :
+    piprot_(iprot),
+    poprot_(oprot) {
+    iprot_ = iprot.get();
+    oprot_ = oprot.get();
+  }
+  boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() {
+    return piprot_;
+  }
+  boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() {
+    return poprot_;
+  }
+  void getAPIVersion(std::string& _return);
+  void send_getAPIVersion();
+  void recv_getAPIVersion(std::string& _return);
+  void createProject(std::string& _return, const  ::apache::airavata::model::workspace::Project& project);
+  void send_createProject(const  ::apache::airavata::model::workspace::Project& project);
+  void recv_createProject(std::string& _return);
+  void updateProject(const std::string& projectId, const  ::apache::airavata::model::workspace::Project& updatedProject);
+  void send_updateProject(const std::string& projectId, const  ::apache::airavata::model::workspace::Project& updatedProject);
+  void recv_updateProject();
+  void getProject( ::apache::airavata::model::workspace::Project& _return, const std::string& projectId);
+  void send_getProject(const std::string& projectId);
+  void recv_getProject( ::apache::airavata::model::workspace::Project& _return);
+  void getAllUserProjects(std::vector< ::apache::airavata::model::workspace::Project> & _return, const std::string& userName);
+  void send_getAllUserProjects(const std::string& userName);
+  void recv_getAllUserProjects(std::vector< ::apache::airavata::model::workspace::Project> & _return);
+  void searchProjectsByProjectName(std::vector< ::apache::airavata::model::workspace::Project> & _return, const std::string& userName, const std::string& projectName);
+  void send_searchProjectsByProjectName(const std::string& userName, const std::string& projectName);
+  void recv_searchProjectsByProjectName(std::vector< ::apache::airavata::model::workspace::Project> & _return);
+  void searchProjectsByProjectDesc(std::vector< ::apache::airavata::model::workspace::Project> & _return, const std::string& userName, const std::string& description);
+  void send_searchProjectsByProjectDesc(const std::string& userName, const std::string& description);
+  void recv_searchProjectsByProjectDesc(std::vector< ::apache::airavata::model::workspace::Project> & _return);
+  void searchExperimentsByName(std::vector< ::apache::airavata::model::workspace::experiment::ExperimentSummary> & _return, const std::string& userName, const std::string& expName);
+  void send_searchExperimentsByName(const std::string& userName, const std::string& expName);
+  void recv_searchExperimentsByName(std::vector< ::apache::airavata::model::workspace::experiment::ExperimentSummary> & _return);
+  void searchExperimentsByDesc(std::vector< ::apache::airavata::model::workspace::experiment::ExperimentSummary> & _return, const std::string& userName, const std::string& description);
+  void send_searchExperimentsByDesc(const std::string& userName, const std::string& description);
+  void recv_searchExperimentsByDesc(std::vector< ::apache::airavata::model::workspace::experiment::ExperimentSummary> & _return);
+  void searchExperimentsByApplication(std::vector< ::apache::airavata::model::workspace::experiment::ExperimentSummary> & _return, const std::string& userName, const std::string& applicationId);
+  void send_searchExperimentsByApplication(const std::string& userName, const std::string& applicationId);
+  void recv_searchExperimentsByApplication(std::vector< ::apache::airavata::model::workspace::experiment::ExperimentSummary> & _return);
+  void searchExperimentsByStatus(std::vector< ::apache::airavata::model::workspace::experiment::ExperimentSummary> & _return, const std::string& userName, const  ::apache::airavata::model::workspace::experiment::ExperimentState::type experimentState);
+  void send_searchExperimentsByStatus(const std::string& userName, const  ::apache::airavata::model::workspace::experiment::ExperimentState::type experimentState);
+  void recv_searchExperimentsByStatus(std::vector< ::apache::airavata::model::workspace::experiment::ExperimentSummary> & _return);
+  void searchExperimentsByCreationTime(std::vector< ::apache::airavata::model::workspace::experiment::ExperimentSummary> & _return, const std::string& userName, const int64_t fromTime, const int64_t toTime);
+  void send_searchExperimentsByCreationTime(const std::string& userName, const int64_t fromTime, const int64_t toTime);
+  void recv_searchExperimentsByCreationTime(std::vector< ::apache::airavata::model::workspace::experiment::ExperimentSummary> & _return);
+  void getAllExperimentsInProject(std::vector< ::apache::airavata::model::workspace::experiment::Experiment> & _return, const std::string& projectId);
+  void send_getAllExperimentsInProject(const std::string& projectId);
+  void recv_getAllExperimentsInProject(std::vector< ::apache::airavata::model::workspace::experiment::Experiment> & _return);
+  void getAllUserExperiments(std::vector< ::apache::airavata::model::workspace::experiment::Experiment> & _return, const std::string& userName);
+  void send_getAllUserExperiments(const std::string& userName);
+  void recv_getAllUserExperiments(std::vector< ::apache::airavata::model::workspace::experiment::Experiment> & _return);
+  void createExperiment(std::string& _return, const  ::apache::airavata::model::workspace::experiment::Experiment& experiment);
+  void send_createExperiment(const  ::apache::airavata::model::workspace::experiment::Experiment& experiment);
+  void recv_createExperiment(std::string& _return);
+  void getExperiment( ::apache::airavata::model::workspace::experiment::Experiment& _return, const std::string& airavataExperimentId);
+  void send_getExperiment(const std::string& airavataExperimentId);
+  void recv_getExperiment( ::apache::airavata::model::workspace::experiment::Experiment& _return);
+  void updateExperiment(const std::string& airavataExperimentId, const  ::apache::airavata::model::workspace::experiment::Experiment& experiment);
+  void send_updateExperiment(const std::string& airavataExperimentId, const  ::apache::airavata::model::workspace::experiment::Experiment& experiment);
+  void recv_updateExperiment();
+  void updateExperimentConfiguration(const std::string& airavataExperimentId, const  ::apache::airavata::model::workspace::experiment::UserConfigurationData& userConfiguration);
+  void send_updateExperimentConfiguration(const std::string& airavataExperimentId, const  ::apache::airavata::model::workspace::experiment::UserConfigurationData& userConfiguration);
+  void recv_updateExperimentConfiguration();
+  void updateResourceScheduleing(const std::string& airavataExperimentId, const  ::apache::airavata::model::workspace::experiment::ComputationalResourceScheduling& resourceScheduling);
+  void send_updateResourceScheduleing(const std::string& airavataExperimentId, const  ::apache::airavata::model::workspace::experiment::ComputationalResourceScheduling& resourceScheduling);
+  void recv_updateResourceScheduleing();
+  bool validateExperiment(const std::string& airavataExperimentId);
+  void send_validateExperiment(const std::string& airavataExperimentId);
+  bool recv_validateExperiment();
+  void launchExperiment(const std::string& airavataExperimentId, const std::string& airavataCredStoreToken);
+  void send_launchExperiment(const std::string& airavataExperimentId, const std::string& airavataCredStoreToken);
+  void recv_launchExperiment();
+  void getExperimentStatus( ::apache::airavata::model::workspace::experiment::ExperimentStatus& _return, const std::string& airavataExperimentId);
+  void send_getExperimentStatus(const std::string& airavataExperimentId);
+  void recv_getExperimentStatus( ::apache::airavata::model::workspace::experiment::ExperimentStatus& _return);
+  void getExperimentOutputs(std::vector< ::apache::airavata::model::workspace::experiment::DataObjectType> & _return, const std::string& airavataExperimentId);
+  void send_getExperimentOutputs(const std::string& airavataExperimentId);
+  void recv_getExperimentOutputs(std::vector< ::apache::airavata::model::workspace::experiment::DataObjectType> & _return);
+  void getJobStatuses(std::map<std::string,  ::apache::airavata::model::workspace::experiment::JobStatus> & _return, const std::string& airavataExperimentId);
+  void send_getJobStatuses(const std::string& airavataExperimentId);
+  void recv_getJobStatuses(std::map<std::string,  ::apache::airavata::model::workspace::experiment::JobStatus> & _return);
+  void getJobDetails(std::vector< ::apache::airavata::model::workspace::experiment::JobDetails> & _return, const std::string& airavataExperimentId);
+  void send_getJobDetails(const std::string& airavataExperimentId);
+  void recv_getJobDetails(std::vector< ::apache::airavata::model::workspace::experiment::JobDetails> & _return);
+  void getDataTransferDetails(std::vector< ::apache::airavata::model::workspace::experiment::DataTransferDetails> & _return, const std::string& airavataExperimentId);
+  void send_getDataTransferDetails(const std::string& airavataExperimentId);
+  void recv_getDataTransferDetails(std::vector< ::apache::airavata::model::workspace::experiment::DataTransferDetails> & _return);
+  void cloneExperiment(std::string& _return, const std::string& existingExperimentID, const std::string& newExperimentName);
+  void send_cloneExperiment(const std::string& existingExperimentID, const std::string& newExperimentName);
+  void recv_cloneExperiment(std::string& _return);
+  void terminateExperiment(const std::string& airavataExperimentId);
+  void send_terminateExperiment(const std::string& airavataExperimentId);
+  void recv_terminateExperiment();
+  void registerApplicationModule(std::string& _return, const  ::apache::airavata::model::appcatalog::appdeployment::ApplicationModule& applicationModule);
+  void send_registerApplicationModule(const  ::apache::airavata::model::appcatalog::appdeployment::ApplicationModule& applicationModule);
+  void recv_registerApplicationModule(std::string& _return);
+  void getApplicationModule( ::apache::airavata::model::appcatalog::appdeployment::ApplicationModule& _return, const std::string& appModuleId);
+  void send_getApplicationModule(const std::string& appModuleId);
+  void recv_getApplicationModule( ::apache::airavata::model::appcatalog::appdeployment::ApplicationModule& _return);
+  bool updateApplicationModule(const std::string& appModuleId, const  ::apache::airavata::model::appcatalog::appdeployment::ApplicationModule& applicationModule);
+  void send_updateApplicationModule(const std::string& appModuleId, const  ::apache::airavata::model::appcatalog::appdeployment::ApplicationModule& applicationModule);
+  bool recv_updateApplicationModule();
+  void getAllModules(std::vector< ::apache::airavata::model::appcatalog::appdeployment::ApplicationModule> & _return);
+  void send_getAllModules();
+  void recv_getAllModules(std::vector< ::apache::airavata::model::appcatalog::appdeployment::ApplicationModule> & _return);
+  bool deleteApplicationModule(const std::string& appModuleId);
+  void send_deleteApplicationModule(const std::string& appModuleId);
   bool recv_deleteApplicationModule();
   void registerApplicationDeployment(std::string& _return, const  ::apache::airavata::model::appcatalog::appdeployment::ApplicationDeploymentDescription& applicationDeployment);
   void send_registerApplicationDeployment(const  ::apache::airavata::model::appcatalog::appdeployment::ApplicationDeploymentDescription& applicationDeployment);
@@ -13160,6 +14224,27 @@ class AiravataClient : virtual public AiravataIf {
   bool deleteGatewayComputeResourcePreference(const std::string& gatewayID, const std::string& computeResourceId);
   void send_deleteGatewayComputeResourcePreference(const std::string& gatewayID, const std::string& computeResourceId);
   bool recv_deleteGatewayComputeResourcePreference();
+  void getAllWorkflows(std::vector<std::string> & _return);
+  void send_getAllWorkflows();
+  void recv_getAllWorkflows(std::vector<std::string> & _return);
+  void getWorkflow( ::Workflow& _return, const std::string& workflowTemplateId);
+  void send_getWorkflow(const std::string& workflowTemplateId);
+  void recv_getWorkflow( ::Workflow& _return);
+  void deleteWorkflow(const std::string& workflowTemplateId);
+  void send_deleteWorkflow(const std::string& workflowTemplateId);
+  void recv_deleteWorkflow();
+  void registerWorkflow(std::string& _return, const  ::Workflow& workflow);
+  void send_registerWorkflow(const  ::Workflow& workflow);
+  void recv_registerWorkflow(std::string& _return);
+  void updateWorkflow(const std::string& workflowTemplateId, const  ::Workflow& workflow);
+  void send_updateWorkflow(const std::string& workflowTemplateId, const  ::Workflow& workflow);
+  void recv_updateWorkflow();
+  void getWorkflowTemplateId(std::string& _return, const std::string& workflowName);
+  void send_getWorkflowTemplateId(const std::string& workflowName);
+  void recv_getWorkflowTemplateId(std::string& _return);
+  bool isWorkflowExistWithName(const std::string& workflowName);
+  void send_isWorkflowExistWithName(const std::string& workflowName);
+  bool recv_isWorkflowExistWithName();
  protected:
   boost::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_;
   boost::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_;
@@ -13206,6 +14291,7 @@ class AiravataProcessor : public ::apache::thrift::TDispatchProcessor {
   void process_registerApplicationModule(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
   void process_getApplicationModule(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
   void process_updateApplicationModule(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_getAllModules(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
   void process_deleteApplicationModule(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
   void process_registerApplicationDeployment(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);
@@ -13266,6 +14352,13 @@ class AiravataProcessor : public ::apache::thrift::TDispatchProcessor {
   void process_getAllGatewayComputeResourcePreferences(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
   void process_updateGatewayComputeResourcePreference(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
   void process_deleteGatewayComputeResourcePreference(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_getAllWorkflows(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_getWorkflow(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_deleteWorkflow(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_registerWorkflow(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_updateWorkflow(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_getWorkflowTemplateId(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_isWorkflowExistWithName(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  public:
   AiravataProcessor(boost::shared_ptr<AiravataIf> iface) :
     iface_(iface) {
@@ -13300,6 +14393,7 @@ class AiravataProcessor : public ::apache::thrift::TDispatchProcessor {
     processMap_["registerApplicationModule"] = &AiravataProcessor::process_registerApplicationModule;
     processMap_["getApplicationModule"] = &AiravataProcessor::process_getApplicationModule;
     processMap_["updateApplicationModule"] = &AiravataProcessor::process_updateApplicationModule;
+    processMap_["getAllModules"] = &AiravataProcessor::process_getAllModules;
     processMap_["deleteApplicationModule"] = &AiravataProcessor::process_deleteApplicationModule;
     processMap_["registerApplicationDeployment"] = &AiravataProcessor::process_registerApplicationDeployment;
     processMap_["getApplicationDeployment"] = &AiravataProcessor::process_getApplicationDeployment;
@@ -13360,6 +14454,13 @@ class AiravataProcessor : public ::apache::thrift::TDispatchProcessor {
     processMap_["getAllGatewayComputeResourcePreferences"] = &AiravataProcessor::process_getAllGatewayComputeResourcePreferences;
     processMap_["updateGatewayComputeResourcePreference"] = &AiravataProcessor::process_updateGatewayComputeResourcePreference;
     processMap_["deleteGatewayComputeResourcePreference"] = &AiravataProcessor::process_deleteGatewayComputeResourcePreference;
+    processMap_["getAllWorkflows"] = &AiravataProcessor::process_getAllWorkflows;
+    processMap_["getWorkflow"] = &AiravataProcessor::process_getWorkflow;
+    processMap_["deleteWorkflow"] = &AiravataProcessor::process_deleteWorkflow;
+    processMap_["registerWorkflow"] = &AiravataProcessor::process_registerWorkflow;
+    processMap_["updateWorkflow"] = &AiravataProcessor::process_updateWorkflow;
+    processMap_["getWorkflowTemplateId"] = &AiravataProcessor::process_getWorkflowTemplateId;
+    processMap_["isWorkflowExistWithName"] = &AiravataProcessor::process_isWorkflowExistWithName;
   }
 
   virtual ~AiravataProcessor() {}
@@ -13690,6 +14791,16 @@ class AiravataMultiface : virtual public AiravataIf {
     return ifaces_[i]->updateApplicationModule(appModuleId, applicationModule);
   }
 
+  void getAllModules(std::vector< ::apache::airavata::model::appcatalog::appdeployment::ApplicationModule> & _return) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->getAllModules(_return);
+    }
+    ifaces_[i]->getAllModules(_return);
+    return;
+  }
+
   bool deleteApplicationModule(const std::string& appModuleId) {
     size_t sz = ifaces_.size();
     size_t i = 0;
@@ -14263,6 +15374,73 @@ class AiravataMultiface : virtual public AiravataIf {
     return ifaces_[i]->deleteGatewayComputeResourcePreference(gatewayID, computeResourceId);
   }
 
+  void getAllWorkflows(std::vector<std::string> & _return) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->getAllWorkflows(_return);
+    }
+    ifaces_[i]->getAllWorkflows(_return);
+    return;
+  }
+
+  void getWorkflow( ::Workflow& _return, const std::string& workflowTemplateId) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->getWorkflow(_return, workflowTemplateId);
+    }
+    ifaces_[i]->getWorkflow(_return, workflowTemplateId);
+    return;
+  }
+
+  void deleteWorkflow(const std::string& workflowTemplateId) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->deleteWorkflow(workflowTemplateId);
+    }
+    ifaces_[i]->deleteWorkflow(workflowTemplateId);
+  }
+
+  void registerWorkflow(std::string& _return, const  ::Workflow& workflow) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->registerWorkflow(_return, workflow);
+    }
+    ifaces_[i]->registerWorkflow(_return, workflow);
+    return;
+  }
+
+  void updateWorkflow(const std::string& workflowTemplateId, const  ::Workflow& workflow) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->updateWorkflow(workflowTemplateId, workflow);
+    }
+    ifaces_[i]->updateWorkflow(workflowTemplateId, workflow);
+  }
+
+  void getWorkflowTemplateId(std::string& _return, const std::string& workflowName) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->getWorkflowTemplateId(_return, workflowName);
+    }
+    ifaces_[i]->getWorkflowTemplateId(_return, workflowName);
+    return;
+  }
+
+  bool isWorkflowExistWithName(const std::string& workflowName) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->isWorkflowExistWithName(workflowName);
+    }
+    return ifaces_[i]->isWorkflowExistWithName(workflowName);
+  }
+
 };
 
 }}} // namespace

http://git-wip-us.apache.org/repos/asf/airavata/blob/ede66edf/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/Airavata_server.skeleton.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/Airavata_server.skeleton.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/Airavata_server.skeleton.cpp
index 2b7e03f..ce06c45 100644
--- a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/Airavata_server.skeleton.cpp
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/Airavata_server.skeleton.cpp
@@ -194,6 +194,11 @@ class AiravataHandler : virtual public AiravataIf {
     printf("updateApplicationModule\n");
   }
 
+  void getAllModules(std::vector< ::apache::airavata::model::appcatalog::appdeployment::ApplicationModule> & _return) {
+    // Your implementation goes here
+    printf("getAllModules\n");
+  }
+
   bool deleteApplicationModule(const std::string& appModuleId) {
     // Your implementation goes here
     printf("deleteApplicationModule\n");
@@ -494,6 +499,41 @@ class AiravataHandler : virtual public AiravataIf {
     printf("deleteGatewayComputeResourcePreference\n");
   }
 
+  void getAllWorkflows(std::vector<std::string> & _return) {
+    // Your implementation goes here
+    printf("getAllWorkflows\n");
+  }
+
+  void getWorkflow( ::Workflow& _return, const std::string& workflowTemplateId) {
+    // Your implementation goes here
+    printf("getWorkflow\n");
+  }
+
+  void deleteWorkflow(const std::string& workflowTemplateId) {
+    // Your implementation goes here
+    printf("deleteWorkflow\n");
+  }
+
+  void registerWorkflow(std::string& _return, const  ::Workflow& workflow) {
+    // Your implementation goes here
+    printf("registerWorkflow\n");
+  }
+
+  void updateWorkflow(const std::string& workflowTemplateId, const  ::Workflow& workflow) {
+    // Your implementation goes here
+    printf("updateWorkflow\n");
+  }
+
+  void getWorkflowTemplateId(std::string& _return, const std::string& workflowName) {
+    // Your implementation goes here
+    printf("getWorkflowTemplateId\n");
+  }
+
+  bool isWorkflowExistWithName(const std::string& workflowName) {
+    // Your implementation goes here
+    printf("isWorkflowExistWithName\n");
+  }
+
 };
 
 int main(int argc, char **argv) {

http://git-wip-us.apache.org/repos/asf/airavata/blob/ede66edf/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/Workflow.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/Workflow.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/Workflow.cpp
index 546e96e..075a25a 100644
--- a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/Workflow.cpp
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/Workflow.cpp
@@ -94,14 +94,14 @@ uint32_t Workflow_getAllWorkflows_result::read(::apache::thrift::protocol::TProt
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->success.clear();
-            uint32_t _size277;
-            ::apache::thrift::protocol::TType _etype280;
-            xfer += iprot->readListBegin(_etype280, _size277);
-            this->success.resize(_size277);
-            uint32_t _i281;
-            for (_i281 = 0; _i281 < _size277; ++_i281)
+            uint32_t _size288;
+            ::apache::thrift::protocol::TType _etype291;
+            xfer += iprot->readListBegin(_etype291, _size288);
+            this->success.resize(_size288);
+            uint32_t _i292;
+            for (_i292 = 0; _i292 < _size288; ++_i292)
             {
-              xfer += iprot->readString(this->success[_i281]);
+              xfer += iprot->readString(this->success[_i292]);
             }
             xfer += iprot->readListEnd();
           }
@@ -156,10 +156,10 @@ uint32_t Workflow_getAllWorkflows_result::write(::apache::thrift::protocol::TPro
     xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
     {
       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size()));
-      std::vector<std::string> ::const_iterator _iter282;
-      for (_iter282 = this->success.begin(); _iter282 != this->success.end(); ++_iter282)
+      std::vector<std::string> ::const_iterator _iter293;
+      for (_iter293 = this->success.begin(); _iter293 != this->success.end(); ++_iter293)
       {
-        xfer += oprot->writeString((*_iter282));
+        xfer += oprot->writeString((*_iter293));
       }
       xfer += oprot->writeListEnd();
     }
@@ -206,14 +206,14 @@ uint32_t Workflow_getAllWorkflows_presult::read(::apache::thrift::protocol::TPro
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             (*(this->success)).clear();
-            uint32_t _size283;
-            ::apache::thrift::protocol::TType _etype286;
-            xfer += iprot->readListBegin(_etype286, _size283);
-            (*(this->success)).resize(_size283);
-            uint32_t _i287;
-            for (_i287 = 0; _i287 < _size283; ++_i287)
+            uint32_t _size294;
+            ::apache::thrift::protocol::TType _etype297;
+            xfer += iprot->readListBegin(_etype297, _size294);
+            (*(this->success)).resize(_size294);
+            uint32_t _i298;
+            for (_i298 = 0; _i298 < _size294; ++_i298)
             {
-              xfer += iprot->readString((*(this->success))[_i287]);
+              xfer += iprot->readString((*(this->success))[_i298]);
             }
             xfer += iprot->readListEnd();
           }


Mime
View raw message