airavata-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From samin...@apache.org
Subject [2/6] adding generated thrift workflow files
Date Wed, 09 Jul 2014 18:28:19 GMT
http://git-wip-us.apache.org/repos/asf/airavata/blob/850c4a38/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/Workflow.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/Workflow.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/Workflow.h
new file mode 100644
index 0000000..3a2781c
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/Workflow.h
@@ -0,0 +1,1162 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+#ifndef Workflow_H
+#define Workflow_H
+
+#include <thrift/TDispatchProcessor.h>
+#include "workflowAPI_types.h"
+
+namespace airavata { namespace api { namespace workflow {
+
+class WorkflowIf {
+ public:
+  virtual ~WorkflowIf() {}
+  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 std::string& workflowTemplateId, 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 WorkflowIfFactory {
+ public:
+  typedef WorkflowIf Handler;
+
+  virtual ~WorkflowIfFactory() {}
+
+  virtual WorkflowIf* getHandler(const ::apache::thrift::TConnectionInfo& connInfo) = 0;
+  virtual void releaseHandler(WorkflowIf* /* handler */) = 0;
+};
+
+class WorkflowIfSingletonFactory : virtual public WorkflowIfFactory {
+ public:
+  WorkflowIfSingletonFactory(const boost::shared_ptr<WorkflowIf>& iface) : iface_(iface) {}
+  virtual ~WorkflowIfSingletonFactory() {}
+
+  virtual WorkflowIf* getHandler(const ::apache::thrift::TConnectionInfo&) {
+    return iface_.get();
+  }
+  virtual void releaseHandler(WorkflowIf* /* handler */) {}
+
+ protected:
+  boost::shared_ptr<WorkflowIf> iface_;
+};
+
+class WorkflowNull : virtual public WorkflowIf {
+ public:
+  virtual ~WorkflowNull() {}
+  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 std::string& /* workflowTemplateId */, 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;
+  }
+};
+
+
+class Workflow_getAllWorkflows_args {
+ public:
+
+  Workflow_getAllWorkflows_args() {
+  }
+
+  virtual ~Workflow_getAllWorkflows_args() throw() {}
+
+
+  bool operator == (const Workflow_getAllWorkflows_args & /* rhs */) const
+  {
+    return true;
+  }
+  bool operator != (const Workflow_getAllWorkflows_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Workflow_getAllWorkflows_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Workflow_getAllWorkflows_pargs {
+ public:
+
+
+  virtual ~Workflow_getAllWorkflows_pargs() throw() {}
+
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Workflow_getAllWorkflows_result__isset {
+  _Workflow_getAllWorkflows_result__isset() : success(false), ire(false), ace(false), ase(false) {}
+  bool success;
+  bool ire;
+  bool ace;
+  bool ase;
+} _Workflow_getAllWorkflows_result__isset;
+
+class Workflow_getAllWorkflows_result {
+ public:
+
+  Workflow_getAllWorkflows_result() {
+  }
+
+  virtual ~Workflow_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;
+
+  _Workflow_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 Workflow_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 Workflow_getAllWorkflows_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Workflow_getAllWorkflows_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Workflow_getAllWorkflows_presult__isset {
+  _Workflow_getAllWorkflows_presult__isset() : success(false), ire(false), ace(false), ase(false) {}
+  bool success;
+  bool ire;
+  bool ace;
+  bool ase;
+} _Workflow_getAllWorkflows_presult__isset;
+
+class Workflow_getAllWorkflows_presult {
+ public:
+
+
+  virtual ~Workflow_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;
+
+  _Workflow_getAllWorkflows_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Workflow_getWorkflow_args {
+ public:
+
+  Workflow_getWorkflow_args() : workflowTemplateId() {
+  }
+
+  virtual ~Workflow_getWorkflow_args() throw() {}
+
+  std::string workflowTemplateId;
+
+  void __set_workflowTemplateId(const std::string& val) {
+    workflowTemplateId = val;
+  }
+
+  bool operator == (const Workflow_getWorkflow_args & rhs) const
+  {
+    if (!(workflowTemplateId == rhs.workflowTemplateId))
+      return false;
+    return true;
+  }
+  bool operator != (const Workflow_getWorkflow_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Workflow_getWorkflow_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Workflow_getWorkflow_pargs {
+ public:
+
+
+  virtual ~Workflow_getWorkflow_pargs() throw() {}
+
+  const std::string* workflowTemplateId;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Workflow_getWorkflow_result__isset {
+  _Workflow_getWorkflow_result__isset() : success(false), ire(false), ace(false), ase(false) {}
+  bool success;
+  bool ire;
+  bool ace;
+  bool ase;
+} _Workflow_getWorkflow_result__isset;
+
+class Workflow_getWorkflow_result {
+ public:
+
+  Workflow_getWorkflow_result() {
+  }
+
+  virtual ~Workflow_getWorkflow_result() throw() {}
+
+   ::Workflow success;
+   ::apache::airavata::api::error::InvalidRequestException ire;
+   ::apache::airavata::api::error::AiravataClientException ace;
+   ::apache::airavata::api::error::AiravataSystemException ase;
+
+  _Workflow_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 Workflow_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 Workflow_getWorkflow_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Workflow_getWorkflow_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Workflow_getWorkflow_presult__isset {
+  _Workflow_getWorkflow_presult__isset() : success(false), ire(false), ace(false), ase(false) {}
+  bool success;
+  bool ire;
+  bool ace;
+  bool ase;
+} _Workflow_getWorkflow_presult__isset;
+
+class Workflow_getWorkflow_presult {
+ public:
+
+
+  virtual ~Workflow_getWorkflow_presult() throw() {}
+
+   ::Workflow* success;
+   ::apache::airavata::api::error::InvalidRequestException ire;
+   ::apache::airavata::api::error::AiravataClientException ace;
+   ::apache::airavata::api::error::AiravataSystemException ase;
+
+  _Workflow_getWorkflow_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Workflow_deleteWorkflow_args {
+ public:
+
+  Workflow_deleteWorkflow_args() : workflowTemplateId() {
+  }
+
+  virtual ~Workflow_deleteWorkflow_args() throw() {}
+
+  std::string workflowTemplateId;
+
+  void __set_workflowTemplateId(const std::string& val) {
+    workflowTemplateId = val;
+  }
+
+  bool operator == (const Workflow_deleteWorkflow_args & rhs) const
+  {
+    if (!(workflowTemplateId == rhs.workflowTemplateId))
+      return false;
+    return true;
+  }
+  bool operator != (const Workflow_deleteWorkflow_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Workflow_deleteWorkflow_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Workflow_deleteWorkflow_pargs {
+ public:
+
+
+  virtual ~Workflow_deleteWorkflow_pargs() throw() {}
+
+  const std::string* workflowTemplateId;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Workflow_deleteWorkflow_result__isset {
+  _Workflow_deleteWorkflow_result__isset() : ire(false), ace(false), ase(false) {}
+  bool ire;
+  bool ace;
+  bool ase;
+} _Workflow_deleteWorkflow_result__isset;
+
+class Workflow_deleteWorkflow_result {
+ public:
+
+  Workflow_deleteWorkflow_result() {
+  }
+
+  virtual ~Workflow_deleteWorkflow_result() throw() {}
+
+   ::apache::airavata::api::error::InvalidRequestException ire;
+   ::apache::airavata::api::error::AiravataClientException ace;
+   ::apache::airavata::api::error::AiravataSystemException ase;
+
+  _Workflow_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 Workflow_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 Workflow_deleteWorkflow_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Workflow_deleteWorkflow_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Workflow_deleteWorkflow_presult__isset {
+  _Workflow_deleteWorkflow_presult__isset() : ire(false), ace(false), ase(false) {}
+  bool ire;
+  bool ace;
+  bool ase;
+} _Workflow_deleteWorkflow_presult__isset;
+
+class Workflow_deleteWorkflow_presult {
+ public:
+
+
+  virtual ~Workflow_deleteWorkflow_presult() throw() {}
+
+   ::apache::airavata::api::error::InvalidRequestException ire;
+   ::apache::airavata::api::error::AiravataClientException ace;
+   ::apache::airavata::api::error::AiravataSystemException ase;
+
+  _Workflow_deleteWorkflow_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Workflow_registerWorkflow_args {
+ public:
+
+  Workflow_registerWorkflow_args() : workflowTemplateId() {
+  }
+
+  virtual ~Workflow_registerWorkflow_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 Workflow_registerWorkflow_args & rhs) const
+  {
+    if (!(workflowTemplateId == rhs.workflowTemplateId))
+      return false;
+    if (!(workflow == rhs.workflow))
+      return false;
+    return true;
+  }
+  bool operator != (const Workflow_registerWorkflow_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Workflow_registerWorkflow_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Workflow_registerWorkflow_pargs {
+ public:
+
+
+  virtual ~Workflow_registerWorkflow_pargs() throw() {}
+
+  const std::string* workflowTemplateId;
+  const  ::Workflow* workflow;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Workflow_registerWorkflow_result__isset {
+  _Workflow_registerWorkflow_result__isset() : success(false), ire(false), ace(false), ase(false) {}
+  bool success;
+  bool ire;
+  bool ace;
+  bool ase;
+} _Workflow_registerWorkflow_result__isset;
+
+class Workflow_registerWorkflow_result {
+ public:
+
+  Workflow_registerWorkflow_result() : success() {
+  }
+
+  virtual ~Workflow_registerWorkflow_result() throw() {}
+
+  std::string success;
+   ::apache::airavata::api::error::InvalidRequestException ire;
+   ::apache::airavata::api::error::AiravataClientException ace;
+   ::apache::airavata::api::error::AiravataSystemException ase;
+
+  _Workflow_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 Workflow_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 Workflow_registerWorkflow_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Workflow_registerWorkflow_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Workflow_registerWorkflow_presult__isset {
+  _Workflow_registerWorkflow_presult__isset() : success(false), ire(false), ace(false), ase(false) {}
+  bool success;
+  bool ire;
+  bool ace;
+  bool ase;
+} _Workflow_registerWorkflow_presult__isset;
+
+class Workflow_registerWorkflow_presult {
+ public:
+
+
+  virtual ~Workflow_registerWorkflow_presult() throw() {}
+
+  std::string* success;
+   ::apache::airavata::api::error::InvalidRequestException ire;
+   ::apache::airavata::api::error::AiravataClientException ace;
+   ::apache::airavata::api::error::AiravataSystemException ase;
+
+  _Workflow_registerWorkflow_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Workflow_updateWorkflow_args {
+ public:
+
+  Workflow_updateWorkflow_args() : workflowTemplateId() {
+  }
+
+  virtual ~Workflow_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 Workflow_updateWorkflow_args & rhs) const
+  {
+    if (!(workflowTemplateId == rhs.workflowTemplateId))
+      return false;
+    if (!(workflow == rhs.workflow))
+      return false;
+    return true;
+  }
+  bool operator != (const Workflow_updateWorkflow_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Workflow_updateWorkflow_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Workflow_updateWorkflow_pargs {
+ public:
+
+
+  virtual ~Workflow_updateWorkflow_pargs() throw() {}
+
+  const std::string* workflowTemplateId;
+  const  ::Workflow* workflow;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Workflow_updateWorkflow_result__isset {
+  _Workflow_updateWorkflow_result__isset() : ire(false), ace(false), ase(false) {}
+  bool ire;
+  bool ace;
+  bool ase;
+} _Workflow_updateWorkflow_result__isset;
+
+class Workflow_updateWorkflow_result {
+ public:
+
+  Workflow_updateWorkflow_result() {
+  }
+
+  virtual ~Workflow_updateWorkflow_result() throw() {}
+
+   ::apache::airavata::api::error::InvalidRequestException ire;
+   ::apache::airavata::api::error::AiravataClientException ace;
+   ::apache::airavata::api::error::AiravataSystemException ase;
+
+  _Workflow_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 Workflow_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 Workflow_updateWorkflow_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Workflow_updateWorkflow_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Workflow_updateWorkflow_presult__isset {
+  _Workflow_updateWorkflow_presult__isset() : ire(false), ace(false), ase(false) {}
+  bool ire;
+  bool ace;
+  bool ase;
+} _Workflow_updateWorkflow_presult__isset;
+
+class Workflow_updateWorkflow_presult {
+ public:
+
+
+  virtual ~Workflow_updateWorkflow_presult() throw() {}
+
+   ::apache::airavata::api::error::InvalidRequestException ire;
+   ::apache::airavata::api::error::AiravataClientException ace;
+   ::apache::airavata::api::error::AiravataSystemException ase;
+
+  _Workflow_updateWorkflow_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Workflow_getWorkflowTemplateId_args {
+ public:
+
+  Workflow_getWorkflowTemplateId_args() : workflowName() {
+  }
+
+  virtual ~Workflow_getWorkflowTemplateId_args() throw() {}
+
+  std::string workflowName;
+
+  void __set_workflowName(const std::string& val) {
+    workflowName = val;
+  }
+
+  bool operator == (const Workflow_getWorkflowTemplateId_args & rhs) const
+  {
+    if (!(workflowName == rhs.workflowName))
+      return false;
+    return true;
+  }
+  bool operator != (const Workflow_getWorkflowTemplateId_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Workflow_getWorkflowTemplateId_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Workflow_getWorkflowTemplateId_pargs {
+ public:
+
+
+  virtual ~Workflow_getWorkflowTemplateId_pargs() throw() {}
+
+  const std::string* workflowName;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Workflow_getWorkflowTemplateId_result__isset {
+  _Workflow_getWorkflowTemplateId_result__isset() : success(false), ire(false), ace(false), ase(false) {}
+  bool success;
+  bool ire;
+  bool ace;
+  bool ase;
+} _Workflow_getWorkflowTemplateId_result__isset;
+
+class Workflow_getWorkflowTemplateId_result {
+ public:
+
+  Workflow_getWorkflowTemplateId_result() : success() {
+  }
+
+  virtual ~Workflow_getWorkflowTemplateId_result() throw() {}
+
+  std::string success;
+   ::apache::airavata::api::error::InvalidRequestException ire;
+   ::apache::airavata::api::error::AiravataClientException ace;
+   ::apache::airavata::api::error::AiravataSystemException ase;
+
+  _Workflow_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 Workflow_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 Workflow_getWorkflowTemplateId_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Workflow_getWorkflowTemplateId_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Workflow_getWorkflowTemplateId_presult__isset {
+  _Workflow_getWorkflowTemplateId_presult__isset() : success(false), ire(false), ace(false), ase(false) {}
+  bool success;
+  bool ire;
+  bool ace;
+  bool ase;
+} _Workflow_getWorkflowTemplateId_presult__isset;
+
+class Workflow_getWorkflowTemplateId_presult {
+ public:
+
+
+  virtual ~Workflow_getWorkflowTemplateId_presult() throw() {}
+
+  std::string* success;
+   ::apache::airavata::api::error::InvalidRequestException ire;
+   ::apache::airavata::api::error::AiravataClientException ace;
+   ::apache::airavata::api::error::AiravataSystemException ase;
+
+  _Workflow_getWorkflowTemplateId_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Workflow_isWorkflowExistWithName_args {
+ public:
+
+  Workflow_isWorkflowExistWithName_args() : workflowName() {
+  }
+
+  virtual ~Workflow_isWorkflowExistWithName_args() throw() {}
+
+  std::string workflowName;
+
+  void __set_workflowName(const std::string& val) {
+    workflowName = val;
+  }
+
+  bool operator == (const Workflow_isWorkflowExistWithName_args & rhs) const
+  {
+    if (!(workflowName == rhs.workflowName))
+      return false;
+    return true;
+  }
+  bool operator != (const Workflow_isWorkflowExistWithName_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Workflow_isWorkflowExistWithName_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Workflow_isWorkflowExistWithName_pargs {
+ public:
+
+
+  virtual ~Workflow_isWorkflowExistWithName_pargs() throw() {}
+
+  const std::string* workflowName;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Workflow_isWorkflowExistWithName_result__isset {
+  _Workflow_isWorkflowExistWithName_result__isset() : success(false), ire(false), ace(false), ase(false) {}
+  bool success;
+  bool ire;
+  bool ace;
+  bool ase;
+} _Workflow_isWorkflowExistWithName_result__isset;
+
+class Workflow_isWorkflowExistWithName_result {
+ public:
+
+  Workflow_isWorkflowExistWithName_result() : success(0) {
+  }
+
+  virtual ~Workflow_isWorkflowExistWithName_result() throw() {}
+
+  bool success;
+   ::apache::airavata::api::error::InvalidRequestException ire;
+   ::apache::airavata::api::error::AiravataClientException ace;
+   ::apache::airavata::api::error::AiravataSystemException ase;
+
+  _Workflow_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 Workflow_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 Workflow_isWorkflowExistWithName_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Workflow_isWorkflowExistWithName_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Workflow_isWorkflowExistWithName_presult__isset {
+  _Workflow_isWorkflowExistWithName_presult__isset() : success(false), ire(false), ace(false), ase(false) {}
+  bool success;
+  bool ire;
+  bool ace;
+  bool ase;
+} _Workflow_isWorkflowExistWithName_presult__isset;
+
+class Workflow_isWorkflowExistWithName_presult {
+ public:
+
+
+  virtual ~Workflow_isWorkflowExistWithName_presult() throw() {}
+
+  bool* success;
+   ::apache::airavata::api::error::InvalidRequestException ire;
+   ::apache::airavata::api::error::AiravataClientException ace;
+   ::apache::airavata::api::error::AiravataSystemException ase;
+
+  _Workflow_isWorkflowExistWithName_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+class WorkflowClient : virtual public WorkflowIf {
+ public:
+  WorkflowClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) :
+    piprot_(prot),
+    poprot_(prot) {
+    iprot_ = prot.get();
+    oprot_ = prot.get();
+  }
+  WorkflowClient(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 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 std::string& workflowTemplateId, const  ::Workflow& workflow);
+  void send_registerWorkflow(const std::string& workflowTemplateId, 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_;
+  ::apache::thrift::protocol::TProtocol* iprot_;
+  ::apache::thrift::protocol::TProtocol* oprot_;
+};
+
+class WorkflowProcessor : public ::apache::thrift::TDispatchProcessor {
+ protected:
+  boost::shared_ptr<WorkflowIf> iface_;
+  virtual bool dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext);
+ private:
+  typedef  void (WorkflowProcessor::*ProcessFunction)(int32_t, ::apache::thrift::protocol::TProtocol*, ::apache::thrift::protocol::TProtocol*, void*);
+  typedef std::map<std::string, ProcessFunction> ProcessMap;
+  ProcessMap processMap_;
+  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:
+  WorkflowProcessor(boost::shared_ptr<WorkflowIf> iface) :
+    iface_(iface) {
+    processMap_["getAllWorkflows"] = &WorkflowProcessor::process_getAllWorkflows;
+    processMap_["getWorkflow"] = &WorkflowProcessor::process_getWorkflow;
+    processMap_["deleteWorkflow"] = &WorkflowProcessor::process_deleteWorkflow;
+    processMap_["registerWorkflow"] = &WorkflowProcessor::process_registerWorkflow;
+    processMap_["updateWorkflow"] = &WorkflowProcessor::process_updateWorkflow;
+    processMap_["getWorkflowTemplateId"] = &WorkflowProcessor::process_getWorkflowTemplateId;
+    processMap_["isWorkflowExistWithName"] = &WorkflowProcessor::process_isWorkflowExistWithName;
+  }
+
+  virtual ~WorkflowProcessor() {}
+};
+
+class WorkflowProcessorFactory : public ::apache::thrift::TProcessorFactory {
+ public:
+  WorkflowProcessorFactory(const ::boost::shared_ptr< WorkflowIfFactory >& handlerFactory) :
+      handlerFactory_(handlerFactory) {}
+
+  ::boost::shared_ptr< ::apache::thrift::TProcessor > getProcessor(const ::apache::thrift::TConnectionInfo& connInfo);
+
+ protected:
+  ::boost::shared_ptr< WorkflowIfFactory > handlerFactory_;
+};
+
+class WorkflowMultiface : virtual public WorkflowIf {
+ public:
+  WorkflowMultiface(std::vector<boost::shared_ptr<WorkflowIf> >& ifaces) : ifaces_(ifaces) {
+  }
+  virtual ~WorkflowMultiface() {}
+ protected:
+  std::vector<boost::shared_ptr<WorkflowIf> > ifaces_;
+  WorkflowMultiface() {}
+  void add(boost::shared_ptr<WorkflowIf> iface) {
+    ifaces_.push_back(iface);
+  }
+ public:
+  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 std::string& workflowTemplateId, const  ::Workflow& workflow) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->registerWorkflow(_return, workflowTemplateId, workflow);
+    }
+    ifaces_[i]->registerWorkflow(_return, workflowTemplateId, 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
+
+#endif

http://git-wip-us.apache.org/repos/asf/airavata/blob/850c4a38/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/Workflow_server.skeleton.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/Workflow_server.skeleton.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/Workflow_server.skeleton.cpp
new file mode 100644
index 0000000..6a73041
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/Workflow_server.skeleton.cpp
@@ -0,0 +1,74 @@
+// This autogenerated skeleton file illustrates how to build a server.
+// You should copy it to another filename to avoid overwriting it.
+
+#include "Workflow.h"
+#include <thrift/protocol/TBinaryProtocol.h>
+#include <thrift/server/TSimpleServer.h>
+#include <thrift/transport/TServerSocket.h>
+#include <thrift/transport/TBufferTransports.h>
+
+using namespace ::apache::thrift;
+using namespace ::apache::thrift::protocol;
+using namespace ::apache::thrift::transport;
+using namespace ::apache::thrift::server;
+
+using boost::shared_ptr;
+
+using namespace  ::airavata::api::workflow;
+
+class WorkflowHandler : virtual public WorkflowIf {
+ public:
+  WorkflowHandler() {
+    // Your initialization goes here
+  }
+
+  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 std::string& workflowTemplateId, 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) {
+  int port = 9090;
+  shared_ptr<WorkflowHandler> handler(new WorkflowHandler());
+  shared_ptr<TProcessor> processor(new WorkflowProcessor(handler));
+  shared_ptr<TServerTransport> serverTransport(new TServerSocket(port));
+  shared_ptr<TTransportFactory> transportFactory(new TBufferedTransportFactory());
+  shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory());
+
+  TSimpleServer server(processor, serverTransport, transportFactory, protocolFactory);
+  server.serve();
+  return 0;
+}
+

http://git-wip-us.apache.org/repos/asf/airavata/blob/850c4a38/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/workflowAPI_constants.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/workflowAPI_constants.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/workflowAPI_constants.cpp
new file mode 100644
index 0000000..c1755c9
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/workflowAPI_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 "workflowAPI_constants.h"
+
+namespace airavata { namespace api { namespace workflow {
+
+const workflowAPIConstants g_workflowAPI_constants;
+
+workflowAPIConstants::workflowAPIConstants() {
+  AIRAVATA_API_VERSION = "0.13.0";
+
+}
+
+}}} // namespace
+

http://git-wip-us.apache.org/repos/asf/airavata/blob/850c4a38/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/workflowAPI_constants.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/workflowAPI_constants.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/workflowAPI_constants.h
new file mode 100644
index 0000000..ffb7a9a
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/workflowAPI_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 workflowAPI_CONSTANTS_H
+#define workflowAPI_CONSTANTS_H
+
+#include "workflowAPI_types.h"
+
+namespace airavata { namespace api { namespace workflow {
+
+class workflowAPIConstants {
+ public:
+  workflowAPIConstants();
+
+  std::string AIRAVATA_API_VERSION;
+};
+
+extern const workflowAPIConstants g_workflowAPI_constants;
+
+}}} // namespace
+
+#endif

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

http://git-wip-us.apache.org/repos/asf/airavata/blob/850c4a38/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/workflowAPI_types.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/workflowAPI_types.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/workflowAPI_types.h
new file mode 100644
index 0000000..5e601f6
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/workflowAPI_types.h
@@ -0,0 +1,30 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+#ifndef workflowAPI_TYPES_H
+#define workflowAPI_TYPES_H
+
+#include <thrift/Thrift.h>
+#include <thrift/TApplicationException.h>
+#include <thrift/protocol/TProtocol.h>
+#include <thrift/transport/TTransport.h>
+
+#include <thrift/cxxfunctional.h>
+#include "airavataErrors_types.h"
+#include "airavataDataModel_types.h"
+#include "experimentModel_types.h"
+#include "workspaceModel_types.h"
+#include "computeResourceModel_types.h"
+#include "applicationDeploymentModel_types.h"
+#include "applicationInterfaceModel_types.h"
+#include "workflowDataModel_types.h"
+
+
+namespace airavata { namespace api { namespace workflow {
+
+}}} // namespace
+
+#endif

http://git-wip-us.apache.org/repos/asf/airavata/blob/850c4a38/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/workflowDataModel_constants.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/workflowDataModel_constants.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/workflowDataModel_constants.cpp
new file mode 100644
index 0000000..7335f4e
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/workflowDataModel_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 "workflowDataModel_constants.h"
+
+
+
+const workflowDataModelConstants g_workflowDataModel_constants;
+
+workflowDataModelConstants::workflowDataModelConstants() {
+  DEFAULT_ID = "DO_NOT_SET_AT_CLIENTS";
+
+}
+
+
+

http://git-wip-us.apache.org/repos/asf/airavata/blob/850c4a38/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/workflowDataModel_constants.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/workflowDataModel_constants.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/workflowDataModel_constants.h
new file mode 100644
index 0000000..29a937b
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/workflowDataModel_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 workflowDataModel_CONSTANTS_H
+#define workflowDataModel_CONSTANTS_H
+
+#include "workflowDataModel_types.h"
+
+
+
+class workflowDataModelConstants {
+ public:
+  workflowDataModelConstants();
+
+  std::string DEFAULT_ID;
+};
+
+extern const workflowDataModelConstants g_workflowDataModel_constants;
+
+
+
+#endif

http://git-wip-us.apache.org/repos/asf/airavata/blob/850c4a38/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/workflowDataModel_types.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/workflowDataModel_types.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/workflowDataModel_types.cpp
new file mode 100644
index 0000000..8b7bb07
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/workflowDataModel_types.cpp
@@ -0,0 +1,108 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+#include "workflowDataModel_types.h"
+
+#include <algorithm>
+
+
+
+const char* Workflow::ascii_fingerprint = "F4A50F0EC638C7F66026F9B6678FD89B";
+const uint8_t Workflow::binary_fingerprint[16] = {0xF4,0xA5,0x0F,0x0E,0xC6,0x38,0xC7,0xF6,0x60,0x26,0xF9,0xB6,0x67,0x8F,0xD8,0x9B};
+
+uint32_t Workflow::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_templateId = 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_STRING) {
+          xfer += iprot->readString(this->templateId);
+          isset_templateId = 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->graph);
+          this->__isset.graph = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_templateId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_name)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t Workflow::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Workflow");
+
+  xfer += oprot->writeFieldBegin("templateId", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->templateId);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeString(this->name);
+  xfer += oprot->writeFieldEnd();
+
+  if (this->__isset.graph) {
+    xfer += oprot->writeFieldBegin("graph", ::apache::thrift::protocol::T_STRING, 3);
+    xfer += oprot->writeString(this->graph);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(Workflow &a, Workflow &b) {
+  using ::std::swap;
+  swap(a.templateId, b.templateId);
+  swap(a.name, b.name);
+  swap(a.graph, b.graph);
+  swap(a.__isset, b.__isset);
+}
+
+

http://git-wip-us.apache.org/repos/asf/airavata/blob/850c4a38/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/workflowDataModel_types.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/workflowDataModel_types.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/workflowDataModel_types.h
new file mode 100644
index 0000000..3ec5a3d
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/workflowDataModel_types.h
@@ -0,0 +1,82 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+#ifndef workflowDataModel_TYPES_H
+#define workflowDataModel_TYPES_H
+
+#include <thrift/Thrift.h>
+#include <thrift/TApplicationException.h>
+#include <thrift/protocol/TProtocol.h>
+#include <thrift/transport/TTransport.h>
+
+#include <thrift/cxxfunctional.h>
+
+
+
+
+typedef struct _Workflow__isset {
+  _Workflow__isset() : graph(false) {}
+  bool graph;
+} _Workflow__isset;
+
+class Workflow {
+ public:
+
+  static const char* ascii_fingerprint; // = "F4A50F0EC638C7F66026F9B6678FD89B";
+  static const uint8_t binary_fingerprint[16]; // = {0xF4,0xA5,0x0F,0x0E,0xC6,0x38,0xC7,0xF6,0x60,0x26,0xF9,0xB6,0x67,0x8F,0xD8,0x9B};
+
+  Workflow() : templateId("DO_NOT_SET_AT_CLIENTS"), name(), graph() {
+  }
+
+  virtual ~Workflow() throw() {}
+
+  std::string templateId;
+  std::string name;
+  std::string graph;
+
+  _Workflow__isset __isset;
+
+  void __set_templateId(const std::string& val) {
+    templateId = val;
+  }
+
+  void __set_name(const std::string& val) {
+    name = val;
+  }
+
+  void __set_graph(const std::string& val) {
+    graph = val;
+    __isset.graph = true;
+  }
+
+  bool operator == (const Workflow & rhs) const
+  {
+    if (!(templateId == rhs.templateId))
+      return false;
+    if (!(name == rhs.name))
+      return false;
+    if (__isset.graph != rhs.__isset.graph)
+      return false;
+    else if (__isset.graph && !(graph == rhs.graph))
+      return false;
+    return true;
+  }
+  bool operator != (const Workflow &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Workflow & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(Workflow &a, Workflow &b);
+
+
+
+#endif

http://git-wip-us.apache.org/repos/asf/airavata/blob/850c4a38/airavata-api/airavata-client-sdks/airavata-php-sdk/src/main/resources/lib/Airavata/API/Workflow/Types.php
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-php-sdk/src/main/resources/lib/Airavata/API/Workflow/Types.php b/airavata-api/airavata-client-sdks/airavata-php-sdk/src/main/resources/lib/Airavata/API/Workflow/Types.php
new file mode 100644
index 0000000..b5ffe55
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-php-sdk/src/main/resources/lib/Airavata/API/Workflow/Types.php
@@ -0,0 +1,22 @@
+<?php
+namespace Airavata\API\Workflow;
+
+/**
+ * Autogenerated by Thrift Compiler (0.9.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+use Thrift\Base\TBase;
+use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
+
+
+$GLOBALS['workflowAPI_CONSTANTS']['AIRAVATA_API_VERSION'] = "0.13.0";
+
+


Mime
View raw message