airavata-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From chath...@apache.org
Subject [4/7] airavata git commit: adding CRUD operations to gateway - AIRAVATA-1608, AIRAVATA-1604
Date Mon, 02 Mar 2015 20:27:50 GMT
http://git-wip-us.apache.org/repos/asf/airavata/blob/658e5e9e/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 397421e..776ee04 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
@@ -33,6 +33,12 @@ class AiravataIf {
  public:
   virtual ~AiravataIf() {}
   virtual void getAPIVersion(std::string& _return) = 0;
+  virtual void addGateway(std::string& _return, const  ::apache::airavata::model::workspace::Gateway& gateway) = 0;
+  virtual void updateGateway(const std::string& gatewayId, const  ::apache::airavata::model::workspace::Gateway& updatedGateway) = 0;
+  virtual void getGateway( ::apache::airavata::model::workspace::Gateway& _return, const std::string& gatewayId) = 0;
+  virtual bool deleteGateway(const std::string& gatewayId) = 0;
+  virtual void getAllGateways(std::vector< ::apache::airavata::model::workspace::Gateway> & _return) = 0;
+  virtual bool isGatewayExist(const std::string& gatewayId) = 0;
   virtual void createProject(std::string& _return, const  ::apache::airavata::model::workspace::Project& project) = 0;
   virtual void updateProject(const std::string& projectId, const  ::apache::airavata::model::workspace::Project& updatedProject) = 0;
   virtual void getProject( ::apache::airavata::model::workspace::Project& _return, const std::string& projectId) = 0;
@@ -169,6 +175,26 @@ class AiravataNull : virtual public AiravataIf {
   void getAPIVersion(std::string& /* _return */) {
     return;
   }
+  void addGateway(std::string& /* _return */, const  ::apache::airavata::model::workspace::Gateway& /* gateway */) {
+    return;
+  }
+  void updateGateway(const std::string& /* gatewayId */, const  ::apache::airavata::model::workspace::Gateway& /* updatedGateway */) {
+    return;
+  }
+  void getGateway( ::apache::airavata::model::workspace::Gateway& /* _return */, const std::string& /* gatewayId */) {
+    return;
+  }
+  bool deleteGateway(const std::string& /* gatewayId */) {
+    bool _return = false;
+    return _return;
+  }
+  void getAllGateways(std::vector< ::apache::airavata::model::workspace::Gateway> & /* _return */) {
+    return;
+  }
+  bool isGatewayExist(const std::string& /* gatewayId */) {
+    bool _return = false;
+    return _return;
+  }
   void createProject(std::string& /* _return */, const  ::apache::airavata::model::workspace::Project& /* project */) {
     return;
   }
@@ -459,81 +485,862 @@ class AiravataNull : virtual public AiravataIf {
   void registerGatewayResourceProfile(std::string& /* _return */, const  ::apache::airavata::model::appcatalog::gatewayprofile::GatewayResourceProfile& /* gatewayResourceProfile */) {
     return;
   }
-  void getGatewayResourceProfile( ::apache::airavata::model::appcatalog::gatewayprofile::GatewayResourceProfile& /* _return */, const std::string& /* gatewayID */) {
-    return;
+  void getGatewayResourceProfile( ::apache::airavata::model::appcatalog::gatewayprofile::GatewayResourceProfile& /* _return */, const std::string& /* gatewayID */) {
+    return;
+  }
+  bool updateGatewayResourceProfile(const std::string& /* gatewayID */, const  ::apache::airavata::model::appcatalog::gatewayprofile::GatewayResourceProfile& /* gatewayResourceProfile */) {
+    bool _return = false;
+    return _return;
+  }
+  bool deleteGatewayResourceProfile(const std::string& /* gatewayID */) {
+    bool _return = false;
+    return _return;
+  }
+  bool addGatewayComputeResourcePreference(const std::string& /* gatewayID */, const std::string& /* computeResourceId */, const  ::apache::airavata::model::appcatalog::gatewayprofile::ComputeResourcePreference& /* computeResourcePreference */) {
+    bool _return = false;
+    return _return;
+  }
+  void getGatewayComputeResourcePreference( ::apache::airavata::model::appcatalog::gatewayprofile::ComputeResourcePreference& /* _return */, const std::string& /* gatewayID */, const std::string& /* computeResourceId */) {
+    return;
+  }
+  void getAllGatewayComputeResourcePreferences(std::vector< ::apache::airavata::model::appcatalog::gatewayprofile::ComputeResourcePreference> & /* _return */, const std::string& /* gatewayID */) {
+    return;
+  }
+  void getAllGatewayComputeResources(std::vector< ::apache::airavata::model::appcatalog::gatewayprofile::GatewayResourceProfile> & /* _return */) {
+    return;
+  }
+  bool updateGatewayComputeResourcePreference(const std::string& /* gatewayID */, const std::string& /* computeResourceId */, const  ::apache::airavata::model::appcatalog::gatewayprofile::ComputeResourcePreference& /* computeResourcePreference */) {
+    bool _return = false;
+    return _return;
+  }
+  bool deleteGatewayComputeResourcePreference(const std::string& /* gatewayID */, const std::string& /* computeResourceId */) {
+    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;
+  }
+};
+
+
+class Airavata_getAPIVersion_args {
+ public:
+
+  Airavata_getAPIVersion_args() {
+  }
+
+  virtual ~Airavata_getAPIVersion_args() throw() {}
+
+
+  bool operator == (const Airavata_getAPIVersion_args & /* rhs */) const
+  {
+    return true;
+  }
+  bool operator != (const Airavata_getAPIVersion_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Airavata_getAPIVersion_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Airavata_getAPIVersion_pargs {
+ public:
+
+
+  virtual ~Airavata_getAPIVersion_pargs() throw() {}
+
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_getAPIVersion_result__isset {
+  _Airavata_getAPIVersion_result__isset() : success(false), ire(false), ace(false), ase(false) {}
+  bool success;
+  bool ire;
+  bool ace;
+  bool ase;
+} _Airavata_getAPIVersion_result__isset;
+
+class Airavata_getAPIVersion_result {
+ public:
+
+  Airavata_getAPIVersion_result() : success() {
+  }
+
+  virtual ~Airavata_getAPIVersion_result() throw() {}
+
+  std::string success;
+   ::apache::airavata::api::error::InvalidRequestException ire;
+   ::apache::airavata::api::error::AiravataClientException ace;
+   ::apache::airavata::api::error::AiravataSystemException ase;
+
+  _Airavata_getAPIVersion_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_getAPIVersion_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_getAPIVersion_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Airavata_getAPIVersion_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_getAPIVersion_presult__isset {
+  _Airavata_getAPIVersion_presult__isset() : success(false), ire(false), ace(false), ase(false) {}
+  bool success;
+  bool ire;
+  bool ace;
+  bool ase;
+} _Airavata_getAPIVersion_presult__isset;
+
+class Airavata_getAPIVersion_presult {
+ public:
+
+
+  virtual ~Airavata_getAPIVersion_presult() throw() {}
+
+  std::string* success;
+   ::apache::airavata::api::error::InvalidRequestException ire;
+   ::apache::airavata::api::error::AiravataClientException ace;
+   ::apache::airavata::api::error::AiravataSystemException ase;
+
+  _Airavata_getAPIVersion_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Airavata_addGateway_args {
+ public:
+
+  Airavata_addGateway_args() {
+  }
+
+  virtual ~Airavata_addGateway_args() throw() {}
+
+   ::apache::airavata::model::workspace::Gateway gateway;
+
+  void __set_gateway(const  ::apache::airavata::model::workspace::Gateway& val) {
+    gateway = val;
+  }
+
+  bool operator == (const Airavata_addGateway_args & rhs) const
+  {
+    if (!(gateway == rhs.gateway))
+      return false;
+    return true;
+  }
+  bool operator != (const Airavata_addGateway_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Airavata_addGateway_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Airavata_addGateway_pargs {
+ public:
+
+
+  virtual ~Airavata_addGateway_pargs() throw() {}
+
+  const  ::apache::airavata::model::workspace::Gateway* gateway;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_addGateway_result__isset {
+  _Airavata_addGateway_result__isset() : success(false), ire(false), ace(false), ase(false) {}
+  bool success;
+  bool ire;
+  bool ace;
+  bool ase;
+} _Airavata_addGateway_result__isset;
+
+class Airavata_addGateway_result {
+ public:
+
+  Airavata_addGateway_result() : success() {
+  }
+
+  virtual ~Airavata_addGateway_result() throw() {}
+
+  std::string success;
+   ::apache::airavata::api::error::InvalidRequestException ire;
+   ::apache::airavata::api::error::AiravataClientException ace;
+   ::apache::airavata::api::error::AiravataSystemException ase;
+
+  _Airavata_addGateway_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_addGateway_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_addGateway_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Airavata_addGateway_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_addGateway_presult__isset {
+  _Airavata_addGateway_presult__isset() : success(false), ire(false), ace(false), ase(false) {}
+  bool success;
+  bool ire;
+  bool ace;
+  bool ase;
+} _Airavata_addGateway_presult__isset;
+
+class Airavata_addGateway_presult {
+ public:
+
+
+  virtual ~Airavata_addGateway_presult() throw() {}
+
+  std::string* success;
+   ::apache::airavata::api::error::InvalidRequestException ire;
+   ::apache::airavata::api::error::AiravataClientException ace;
+   ::apache::airavata::api::error::AiravataSystemException ase;
+
+  _Airavata_addGateway_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Airavata_updateGateway_args {
+ public:
+
+  Airavata_updateGateway_args() : gatewayId() {
+  }
+
+  virtual ~Airavata_updateGateway_args() throw() {}
+
+  std::string gatewayId;
+   ::apache::airavata::model::workspace::Gateway updatedGateway;
+
+  void __set_gatewayId(const std::string& val) {
+    gatewayId = val;
+  }
+
+  void __set_updatedGateway(const  ::apache::airavata::model::workspace::Gateway& val) {
+    updatedGateway = val;
+  }
+
+  bool operator == (const Airavata_updateGateway_args & rhs) const
+  {
+    if (!(gatewayId == rhs.gatewayId))
+      return false;
+    if (!(updatedGateway == rhs.updatedGateway))
+      return false;
+    return true;
+  }
+  bool operator != (const Airavata_updateGateway_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Airavata_updateGateway_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Airavata_updateGateway_pargs {
+ public:
+
+
+  virtual ~Airavata_updateGateway_pargs() throw() {}
+
+  const std::string* gatewayId;
+  const  ::apache::airavata::model::workspace::Gateway* updatedGateway;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_updateGateway_result__isset {
+  _Airavata_updateGateway_result__isset() : ire(false), ace(false), ase(false) {}
+  bool ire;
+  bool ace;
+  bool ase;
+} _Airavata_updateGateway_result__isset;
+
+class Airavata_updateGateway_result {
+ public:
+
+  Airavata_updateGateway_result() {
+  }
+
+  virtual ~Airavata_updateGateway_result() throw() {}
+
+   ::apache::airavata::api::error::InvalidRequestException ire;
+   ::apache::airavata::api::error::AiravataClientException ace;
+   ::apache::airavata::api::error::AiravataSystemException ase;
+
+  _Airavata_updateGateway_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_updateGateway_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_updateGateway_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Airavata_updateGateway_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_updateGateway_presult__isset {
+  _Airavata_updateGateway_presult__isset() : ire(false), ace(false), ase(false) {}
+  bool ire;
+  bool ace;
+  bool ase;
+} _Airavata_updateGateway_presult__isset;
+
+class Airavata_updateGateway_presult {
+ public:
+
+
+  virtual ~Airavata_updateGateway_presult() throw() {}
+
+   ::apache::airavata::api::error::InvalidRequestException ire;
+   ::apache::airavata::api::error::AiravataClientException ace;
+   ::apache::airavata::api::error::AiravataSystemException ase;
+
+  _Airavata_updateGateway_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Airavata_getGateway_args {
+ public:
+
+  Airavata_getGateway_args() : gatewayId() {
+  }
+
+  virtual ~Airavata_getGateway_args() throw() {}
+
+  std::string gatewayId;
+
+  void __set_gatewayId(const std::string& val) {
+    gatewayId = val;
+  }
+
+  bool operator == (const Airavata_getGateway_args & rhs) const
+  {
+    if (!(gatewayId == rhs.gatewayId))
+      return false;
+    return true;
+  }
+  bool operator != (const Airavata_getGateway_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Airavata_getGateway_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Airavata_getGateway_pargs {
+ public:
+
+
+  virtual ~Airavata_getGateway_pargs() throw() {}
+
+  const std::string* gatewayId;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_getGateway_result__isset {
+  _Airavata_getGateway_result__isset() : success(false), ire(false), ace(false), ase(false) {}
+  bool success;
+  bool ire;
+  bool ace;
+  bool ase;
+} _Airavata_getGateway_result__isset;
+
+class Airavata_getGateway_result {
+ public:
+
+  Airavata_getGateway_result() {
+  }
+
+  virtual ~Airavata_getGateway_result() throw() {}
+
+   ::apache::airavata::model::workspace::Gateway success;
+   ::apache::airavata::api::error::InvalidRequestException ire;
+   ::apache::airavata::api::error::AiravataClientException ace;
+   ::apache::airavata::api::error::AiravataSystemException ase;
+
+  _Airavata_getGateway_result__isset __isset;
+
+  void __set_success(const  ::apache::airavata::model::workspace::Gateway& 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_getGateway_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_getGateway_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Airavata_getGateway_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_getGateway_presult__isset {
+  _Airavata_getGateway_presult__isset() : success(false), ire(false), ace(false), ase(false) {}
+  bool success;
+  bool ire;
+  bool ace;
+  bool ase;
+} _Airavata_getGateway_presult__isset;
+
+class Airavata_getGateway_presult {
+ public:
+
+
+  virtual ~Airavata_getGateway_presult() throw() {}
+
+   ::apache::airavata::model::workspace::Gateway* success;
+   ::apache::airavata::api::error::InvalidRequestException ire;
+   ::apache::airavata::api::error::AiravataClientException ace;
+   ::apache::airavata::api::error::AiravataSystemException ase;
+
+  _Airavata_getGateway_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Airavata_deleteGateway_args {
+ public:
+
+  Airavata_deleteGateway_args() : gatewayId() {
+  }
+
+  virtual ~Airavata_deleteGateway_args() throw() {}
+
+  std::string gatewayId;
+
+  void __set_gatewayId(const std::string& val) {
+    gatewayId = val;
+  }
+
+  bool operator == (const Airavata_deleteGateway_args & rhs) const
+  {
+    if (!(gatewayId == rhs.gatewayId))
+      return false;
+    return true;
+  }
+  bool operator != (const Airavata_deleteGateway_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Airavata_deleteGateway_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Airavata_deleteGateway_pargs {
+ public:
+
+
+  virtual ~Airavata_deleteGateway_pargs() throw() {}
+
+  const std::string* gatewayId;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_deleteGateway_result__isset {
+  _Airavata_deleteGateway_result__isset() : success(false), ire(false), ace(false), ase(false) {}
+  bool success;
+  bool ire;
+  bool ace;
+  bool ase;
+} _Airavata_deleteGateway_result__isset;
+
+class Airavata_deleteGateway_result {
+ public:
+
+  Airavata_deleteGateway_result() : success(0) {
+  }
+
+  virtual ~Airavata_deleteGateway_result() throw() {}
+
+  bool success;
+   ::apache::airavata::api::error::InvalidRequestException ire;
+   ::apache::airavata::api::error::AiravataClientException ace;
+   ::apache::airavata::api::error::AiravataSystemException ase;
+
+  _Airavata_deleteGateway_result__isset __isset;
+
+  void __set_success(const bool val) {
+    success = val;
   }
-  bool updateGatewayResourceProfile(const std::string& /* gatewayID */, const  ::apache::airavata::model::appcatalog::gatewayprofile::GatewayResourceProfile& /* gatewayResourceProfile */) {
-    bool _return = false;
-    return _return;
+
+  void __set_ire(const  ::apache::airavata::api::error::InvalidRequestException& val) {
+    ire = val;
   }
-  bool deleteGatewayResourceProfile(const std::string& /* gatewayID */) {
-    bool _return = false;
-    return _return;
+
+  void __set_ace(const  ::apache::airavata::api::error::AiravataClientException& val) {
+    ace = val;
   }
-  bool addGatewayComputeResourcePreference(const std::string& /* gatewayID */, const std::string& /* computeResourceId */, const  ::apache::airavata::model::appcatalog::gatewayprofile::ComputeResourcePreference& /* computeResourcePreference */) {
-    bool _return = false;
-    return _return;
+
+  void __set_ase(const  ::apache::airavata::api::error::AiravataSystemException& val) {
+    ase = val;
   }
-  void getGatewayComputeResourcePreference( ::apache::airavata::model::appcatalog::gatewayprofile::ComputeResourcePreference& /* _return */, const std::string& /* gatewayID */, const std::string& /* computeResourceId */) {
-    return;
+
+  bool operator == (const Airavata_deleteGateway_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;
   }
-  void getAllGatewayComputeResourcePreferences(std::vector< ::apache::airavata::model::appcatalog::gatewayprofile::ComputeResourcePreference> & /* _return */, const std::string& /* gatewayID */) {
-    return;
+  bool operator != (const Airavata_deleteGateway_result &rhs) const {
+    return !(*this == rhs);
   }
-  void getAllGatewayComputeResources(std::vector< ::apache::airavata::model::appcatalog::gatewayprofile::GatewayResourceProfile> & /* _return */) {
-    return;
+
+  bool operator < (const Airavata_deleteGateway_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_deleteGateway_presult__isset {
+  _Airavata_deleteGateway_presult__isset() : success(false), ire(false), ace(false), ase(false) {}
+  bool success;
+  bool ire;
+  bool ace;
+  bool ase;
+} _Airavata_deleteGateway_presult__isset;
+
+class Airavata_deleteGateway_presult {
+ public:
+
+
+  virtual ~Airavata_deleteGateway_presult() throw() {}
+
+  bool* success;
+   ::apache::airavata::api::error::InvalidRequestException ire;
+   ::apache::airavata::api::error::AiravataClientException ace;
+   ::apache::airavata::api::error::AiravataSystemException ase;
+
+  _Airavata_deleteGateway_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Airavata_getAllGateways_args {
+ public:
+
+  Airavata_getAllGateways_args() {
   }
-  bool updateGatewayComputeResourcePreference(const std::string& /* gatewayID */, const std::string& /* computeResourceId */, const  ::apache::airavata::model::appcatalog::gatewayprofile::ComputeResourcePreference& /* computeResourcePreference */) {
-    bool _return = false;
-    return _return;
+
+  virtual ~Airavata_getAllGateways_args() throw() {}
+
+
+  bool operator == (const Airavata_getAllGateways_args & /* rhs */) const
+  {
+    return true;
   }
-  bool deleteGatewayComputeResourcePreference(const std::string& /* gatewayID */, const std::string& /* computeResourceId */) {
-    bool _return = false;
-    return _return;
+  bool operator != (const Airavata_getAllGateways_args &rhs) const {
+    return !(*this == rhs);
   }
-  void getAllWorkflows(std::vector<std::string> & /* _return */) {
-    return;
+
+  bool operator < (const Airavata_getAllGateways_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Airavata_getAllGateways_pargs {
+ public:
+
+
+  virtual ~Airavata_getAllGateways_pargs() throw() {}
+
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_getAllGateways_result__isset {
+  _Airavata_getAllGateways_result__isset() : success(false), ire(false), ace(false), ase(false) {}
+  bool success;
+  bool ire;
+  bool ace;
+  bool ase;
+} _Airavata_getAllGateways_result__isset;
+
+class Airavata_getAllGateways_result {
+ public:
+
+  Airavata_getAllGateways_result() {
   }
-  void getWorkflow( ::Workflow& /* _return */, const std::string& /* workflowTemplateId */) {
-    return;
+
+  virtual ~Airavata_getAllGateways_result() throw() {}
+
+  std::vector< ::apache::airavata::model::workspace::Gateway>  success;
+   ::apache::airavata::api::error::InvalidRequestException ire;
+   ::apache::airavata::api::error::AiravataClientException ace;
+   ::apache::airavata::api::error::AiravataSystemException ase;
+
+  _Airavata_getAllGateways_result__isset __isset;
+
+  void __set_success(const std::vector< ::apache::airavata::model::workspace::Gateway> & val) {
+    success = val;
   }
-  void deleteWorkflow(const std::string& /* workflowTemplateId */) {
-    return;
+
+  void __set_ire(const  ::apache::airavata::api::error::InvalidRequestException& val) {
+    ire = val;
   }
-  void registerWorkflow(std::string& /* _return */, const  ::Workflow& /* workflow */) {
-    return;
+
+  void __set_ace(const  ::apache::airavata::api::error::AiravataClientException& val) {
+    ace = val;
   }
-  void updateWorkflow(const std::string& /* workflowTemplateId */, const  ::Workflow& /* workflow */) {
-    return;
+
+  void __set_ase(const  ::apache::airavata::api::error::AiravataSystemException& val) {
+    ase = val;
   }
-  void getWorkflowTemplateId(std::string& /* _return */, const std::string& /* workflowName */) {
-    return;
+
+  bool operator == (const Airavata_getAllGateways_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 isWorkflowExistWithName(const std::string& /* workflowName */) {
-    bool _return = false;
-    return _return;
+  bool operator != (const Airavata_getAllGateways_result &rhs) const {
+    return !(*this == rhs);
   }
+
+  bool operator < (const Airavata_getAllGateways_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
 };
 
+typedef struct _Airavata_getAllGateways_presult__isset {
+  _Airavata_getAllGateways_presult__isset() : success(false), ire(false), ace(false), ase(false) {}
+  bool success;
+  bool ire;
+  bool ace;
+  bool ase;
+} _Airavata_getAllGateways_presult__isset;
 
-class Airavata_getAPIVersion_args {
+class Airavata_getAllGateways_presult {
  public:
 
-  Airavata_getAPIVersion_args() {
+
+  virtual ~Airavata_getAllGateways_presult() throw() {}
+
+  std::vector< ::apache::airavata::model::workspace::Gateway> * success;
+   ::apache::airavata::api::error::InvalidRequestException ire;
+   ::apache::airavata::api::error::AiravataClientException ace;
+   ::apache::airavata::api::error::AiravataSystemException ase;
+
+  _Airavata_getAllGateways_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Airavata_isGatewayExist_args {
+ public:
+
+  Airavata_isGatewayExist_args() : gatewayId() {
   }
 
-  virtual ~Airavata_getAPIVersion_args() throw() {}
+  virtual ~Airavata_isGatewayExist_args() throw() {}
 
+  std::string gatewayId;
 
-  bool operator == (const Airavata_getAPIVersion_args & /* rhs */) const
+  void __set_gatewayId(const std::string& val) {
+    gatewayId = val;
+  }
+
+  bool operator == (const Airavata_isGatewayExist_args & rhs) const
   {
+    if (!(gatewayId == rhs.gatewayId))
+      return false;
     return true;
   }
-  bool operator != (const Airavata_getAPIVersion_args &rhs) const {
+  bool operator != (const Airavata_isGatewayExist_args &rhs) const {
     return !(*this == rhs);
   }
 
-  bool operator < (const Airavata_getAPIVersion_args & ) const;
+  bool operator < (const Airavata_isGatewayExist_args & ) const;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
@@ -541,41 +1348,42 @@ class Airavata_getAPIVersion_args {
 };
 
 
-class Airavata_getAPIVersion_pargs {
+class Airavata_isGatewayExist_pargs {
  public:
 
 
-  virtual ~Airavata_getAPIVersion_pargs() throw() {}
+  virtual ~Airavata_isGatewayExist_pargs() throw() {}
 
+  const std::string* gatewayId;
 
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
 };
 
-typedef struct _Airavata_getAPIVersion_result__isset {
-  _Airavata_getAPIVersion_result__isset() : success(false), ire(false), ace(false), ase(false) {}
+typedef struct _Airavata_isGatewayExist_result__isset {
+  _Airavata_isGatewayExist_result__isset() : success(false), ire(false), ace(false), ase(false) {}
   bool success;
   bool ire;
   bool ace;
   bool ase;
-} _Airavata_getAPIVersion_result__isset;
+} _Airavata_isGatewayExist_result__isset;
 
-class Airavata_getAPIVersion_result {
+class Airavata_isGatewayExist_result {
  public:
 
-  Airavata_getAPIVersion_result() : success() {
+  Airavata_isGatewayExist_result() : success(0) {
   }
 
-  virtual ~Airavata_getAPIVersion_result() throw() {}
+  virtual ~Airavata_isGatewayExist_result() throw() {}
 
-  std::string success;
+  bool success;
    ::apache::airavata::api::error::InvalidRequestException ire;
    ::apache::airavata::api::error::AiravataClientException ace;
    ::apache::airavata::api::error::AiravataSystemException ase;
 
-  _Airavata_getAPIVersion_result__isset __isset;
+  _Airavata_isGatewayExist_result__isset __isset;
 
-  void __set_success(const std::string& val) {
+  void __set_success(const bool val) {
     success = val;
   }
 
@@ -591,7 +1399,7 @@ class Airavata_getAPIVersion_result {
     ase = val;
   }
 
-  bool operator == (const Airavata_getAPIVersion_result & rhs) const
+  bool operator == (const Airavata_isGatewayExist_result & rhs) const
   {
     if (!(success == rhs.success))
       return false;
@@ -603,37 +1411,37 @@ class Airavata_getAPIVersion_result {
       return false;
     return true;
   }
-  bool operator != (const Airavata_getAPIVersion_result &rhs) const {
+  bool operator != (const Airavata_isGatewayExist_result &rhs) const {
     return !(*this == rhs);
   }
 
-  bool operator < (const Airavata_getAPIVersion_result & ) const;
+  bool operator < (const Airavata_isGatewayExist_result & ) const;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
 };
 
-typedef struct _Airavata_getAPIVersion_presult__isset {
-  _Airavata_getAPIVersion_presult__isset() : success(false), ire(false), ace(false), ase(false) {}
+typedef struct _Airavata_isGatewayExist_presult__isset {
+  _Airavata_isGatewayExist_presult__isset() : success(false), ire(false), ace(false), ase(false) {}
   bool success;
   bool ire;
   bool ace;
   bool ase;
-} _Airavata_getAPIVersion_presult__isset;
+} _Airavata_isGatewayExist_presult__isset;
 
-class Airavata_getAPIVersion_presult {
+class Airavata_isGatewayExist_presult {
  public:
 
 
-  virtual ~Airavata_getAPIVersion_presult() throw() {}
+  virtual ~Airavata_isGatewayExist_presult() throw() {}
 
-  std::string* success;
+  bool* success;
    ::apache::airavata::api::error::InvalidRequestException ire;
    ::apache::airavata::api::error::AiravataClientException ace;
    ::apache::airavata::api::error::AiravataSystemException ase;
 
-  _Airavata_getAPIVersion_presult__isset __isset;
+  _Airavata_isGatewayExist_presult__isset __isset;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
@@ -14785,6 +15593,24 @@ class AiravataClient : virtual public AiravataIf {
   void getAPIVersion(std::string& _return);
   void send_getAPIVersion();
   void recv_getAPIVersion(std::string& _return);
+  void addGateway(std::string& _return, const  ::apache::airavata::model::workspace::Gateway& gateway);
+  void send_addGateway(const  ::apache::airavata::model::workspace::Gateway& gateway);
+  void recv_addGateway(std::string& _return);
+  void updateGateway(const std::string& gatewayId, const  ::apache::airavata::model::workspace::Gateway& updatedGateway);
+  void send_updateGateway(const std::string& gatewayId, const  ::apache::airavata::model::workspace::Gateway& updatedGateway);
+  void recv_updateGateway();
+  void getGateway( ::apache::airavata::model::workspace::Gateway& _return, const std::string& gatewayId);
+  void send_getGateway(const std::string& gatewayId);
+  void recv_getGateway( ::apache::airavata::model::workspace::Gateway& _return);
+  bool deleteGateway(const std::string& gatewayId);
+  void send_deleteGateway(const std::string& gatewayId);
+  bool recv_deleteGateway();
+  void getAllGateways(std::vector< ::apache::airavata::model::workspace::Gateway> & _return);
+  void send_getAllGateways();
+  void recv_getAllGateways(std::vector< ::apache::airavata::model::workspace::Gateway> & _return);
+  bool isGatewayExist(const std::string& gatewayId);
+  void send_isGatewayExist(const std::string& gatewayId);
+  bool recv_isGatewayExist();
   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);
@@ -15113,6 +15939,12 @@ class AiravataProcessor : public ::apache::thrift::TDispatchProcessor {
   typedef std::map<std::string, ProcessFunction> ProcessMap;
   ProcessMap processMap_;
   void process_getAPIVersion(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_addGateway(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_updateGateway(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_getGateway(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_deleteGateway(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_getAllGateways(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_isGatewayExist(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
   void process_createProject(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
   void process_updateProject(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
   void process_getProject(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
@@ -15221,6 +16053,12 @@ class AiravataProcessor : public ::apache::thrift::TDispatchProcessor {
   AiravataProcessor(boost::shared_ptr<AiravataIf> iface) :
     iface_(iface) {
     processMap_["getAPIVersion"] = &AiravataProcessor::process_getAPIVersion;
+    processMap_["addGateway"] = &AiravataProcessor::process_addGateway;
+    processMap_["updateGateway"] = &AiravataProcessor::process_updateGateway;
+    processMap_["getGateway"] = &AiravataProcessor::process_getGateway;
+    processMap_["deleteGateway"] = &AiravataProcessor::process_deleteGateway;
+    processMap_["getAllGateways"] = &AiravataProcessor::process_getAllGateways;
+    processMap_["isGatewayExist"] = &AiravataProcessor::process_isGatewayExist;
     processMap_["createProject"] = &AiravataProcessor::process_createProject;
     processMap_["updateProject"] = &AiravataProcessor::process_updateProject;
     processMap_["getProject"] = &AiravataProcessor::process_getProject;
@@ -15363,6 +16201,63 @@ class AiravataMultiface : virtual public AiravataIf {
     return;
   }
 
+  void addGateway(std::string& _return, const  ::apache::airavata::model::workspace::Gateway& gateway) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->addGateway(_return, gateway);
+    }
+    ifaces_[i]->addGateway(_return, gateway);
+    return;
+  }
+
+  void updateGateway(const std::string& gatewayId, const  ::apache::airavata::model::workspace::Gateway& updatedGateway) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->updateGateway(gatewayId, updatedGateway);
+    }
+    ifaces_[i]->updateGateway(gatewayId, updatedGateway);
+  }
+
+  void getGateway( ::apache::airavata::model::workspace::Gateway& _return, const std::string& gatewayId) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->getGateway(_return, gatewayId);
+    }
+    ifaces_[i]->getGateway(_return, gatewayId);
+    return;
+  }
+
+  bool deleteGateway(const std::string& gatewayId) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->deleteGateway(gatewayId);
+    }
+    return ifaces_[i]->deleteGateway(gatewayId);
+  }
+
+  void getAllGateways(std::vector< ::apache::airavata::model::workspace::Gateway> & _return) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->getAllGateways(_return);
+    }
+    ifaces_[i]->getAllGateways(_return);
+    return;
+  }
+
+  bool isGatewayExist(const std::string& gatewayId) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->isGatewayExist(gatewayId);
+    }
+    return ifaces_[i]->isGatewayExist(gatewayId);
+  }
+
   void createProject(std::string& _return, const  ::apache::airavata::model::workspace::Project& project) {
     size_t sz = ifaces_.size();
     size_t i = 0;

http://git-wip-us.apache.org/repos/asf/airavata/blob/658e5e9e/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 ca5abee..e68589f 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
@@ -44,6 +44,36 @@ class AiravataHandler : virtual public AiravataIf {
     printf("getAPIVersion\n");
   }
 
+  void addGateway(std::string& _return, const  ::apache::airavata::model::workspace::Gateway& gateway) {
+    // Your implementation goes here
+    printf("addGateway\n");
+  }
+
+  void updateGateway(const std::string& gatewayId, const  ::apache::airavata::model::workspace::Gateway& updatedGateway) {
+    // Your implementation goes here
+    printf("updateGateway\n");
+  }
+
+  void getGateway( ::apache::airavata::model::workspace::Gateway& _return, const std::string& gatewayId) {
+    // Your implementation goes here
+    printf("getGateway\n");
+  }
+
+  bool deleteGateway(const std::string& gatewayId) {
+    // Your implementation goes here
+    printf("deleteGateway\n");
+  }
+
+  void getAllGateways(std::vector< ::apache::airavata::model::workspace::Gateway> & _return) {
+    // Your implementation goes here
+    printf("getAllGateways\n");
+  }
+
+  bool isGatewayExist(const std::string& gatewayId) {
+    // Your implementation goes here
+    printf("isGatewayExist\n");
+  }
+
   void createProject(std::string& _return, const  ::apache::airavata::model::workspace::Project& project) {
     // Your implementation goes here
     printf("createProject\n");

http://git-wip-us.apache.org/repos/asf/airavata/blob/658e5e9e/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/gatewayResourceProfileModel_constants.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/gatewayResourceProfileModel_constants.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/gatewayResourceProfileModel_constants.cpp
index 574728d..d130bfd 100644
--- a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/gatewayResourceProfileModel_constants.cpp
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/gatewayResourceProfileModel_constants.cpp
@@ -28,8 +28,6 @@ namespace apache { namespace airavata { namespace model { namespace appcatalog {
 const gatewayResourceProfileModelConstants g_gatewayResourceProfileModel_constants;
 
 gatewayResourceProfileModelConstants::gatewayResourceProfileModelConstants() {
-  DEFAULT_ID = "DO_NOT_SET_AT_CLIENTS";
-
 }
 
 }}}}} // namespace

http://git-wip-us.apache.org/repos/asf/airavata/blob/658e5e9e/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/gatewayResourceProfileModel_constants.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/gatewayResourceProfileModel_constants.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/gatewayResourceProfileModel_constants.h
index c033c3c..da93846 100644
--- a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/gatewayResourceProfileModel_constants.h
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/gatewayResourceProfileModel_constants.h
@@ -32,7 +32,6 @@ class gatewayResourceProfileModelConstants {
  public:
   gatewayResourceProfileModelConstants();
 
-  std::string DEFAULT_ID;
 };
 
 extern const gatewayResourceProfileModelConstants g_gatewayResourceProfileModel_constants;

http://git-wip-us.apache.org/repos/asf/airavata/blob/658e5e9e/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/gatewayResourceProfileModel_types.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/gatewayResourceProfileModel_types.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/gatewayResourceProfileModel_types.cpp
index a996421..87fd134 100644
--- a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/gatewayResourceProfileModel_types.cpp
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/gatewayResourceProfileModel_types.cpp
@@ -182,8 +182,8 @@ void swap(ComputeResourcePreference &a, ComputeResourcePreference &b) {
   swap(a.__isset, b.__isset);
 }
 
-const char* GatewayResourceProfile::ascii_fingerprint = "42DA2625493A482A59D0742432A025BD";
-const uint8_t GatewayResourceProfile::binary_fingerprint[16] = {0x42,0xDA,0x26,0x25,0x49,0x3A,0x48,0x2A,0x59,0xD0,0x74,0x24,0x32,0xA0,0x25,0xBD};
+const char* GatewayResourceProfile::ascii_fingerprint = "2C13C97D8E01026228E6E378E58505CC";
+const uint8_t GatewayResourceProfile::binary_fingerprint[16] = {0x2C,0x13,0xC9,0x7D,0x8E,0x01,0x02,0x62,0x28,0xE6,0xE3,0x78,0xE5,0x85,0x05,0xCC};
 
 uint32_t GatewayResourceProfile::read(::apache::thrift::protocol::TProtocol* iprot) {
 
@@ -197,7 +197,6 @@ uint32_t GatewayResourceProfile::read(::apache::thrift::protocol::TProtocol* ipr
   using ::apache::thrift::protocol::TProtocolException;
 
   bool isset_gatewayID = false;
-  bool isset_gatewayName = false;
 
   while (true)
   {
@@ -216,22 +215,6 @@ uint32_t GatewayResourceProfile::read(::apache::thrift::protocol::TProtocol* ipr
         }
         break;
       case 2:
-        if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readString(this->gatewayName);
-          isset_gatewayName = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 3:
-        if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readString(this->gatewayDescription);
-          this->__isset.gatewayDescription = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 4:
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->computeResourcePreferences.clear();
@@ -262,8 +245,6 @@ uint32_t GatewayResourceProfile::read(::apache::thrift::protocol::TProtocol* ipr
 
   if (!isset_gatewayID)
     throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_gatewayName)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
   return xfer;
 }
 
@@ -275,17 +256,8 @@ uint32_t GatewayResourceProfile::write(::apache::thrift::protocol::TProtocol* op
   xfer += oprot->writeString(this->gatewayID);
   xfer += oprot->writeFieldEnd();
 
-  xfer += oprot->writeFieldBegin("gatewayName", ::apache::thrift::protocol::T_STRING, 2);
-  xfer += oprot->writeString(this->gatewayName);
-  xfer += oprot->writeFieldEnd();
-
-  if (this->__isset.gatewayDescription) {
-    xfer += oprot->writeFieldBegin("gatewayDescription", ::apache::thrift::protocol::T_STRING, 3);
-    xfer += oprot->writeString(this->gatewayDescription);
-    xfer += oprot->writeFieldEnd();
-  }
   if (this->__isset.computeResourcePreferences) {
-    xfer += oprot->writeFieldBegin("computeResourcePreferences", ::apache::thrift::protocol::T_LIST, 4);
+    xfer += oprot->writeFieldBegin("computeResourcePreferences", ::apache::thrift::protocol::T_LIST, 2);
     {
       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->computeResourcePreferences.size()));
       std::vector<ComputeResourcePreference> ::const_iterator _iter7;
@@ -305,8 +277,6 @@ uint32_t GatewayResourceProfile::write(::apache::thrift::protocol::TProtocol* op
 void swap(GatewayResourceProfile &a, GatewayResourceProfile &b) {
   using ::std::swap;
   swap(a.gatewayID, b.gatewayID);
-  swap(a.gatewayName, b.gatewayName);
-  swap(a.gatewayDescription, b.gatewayDescription);
   swap(a.computeResourcePreferences, b.computeResourcePreferences);
   swap(a.__isset, b.__isset);
 }

http://git-wip-us.apache.org/repos/asf/airavata/blob/658e5e9e/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/gatewayResourceProfileModel_types.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/gatewayResourceProfileModel_types.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/gatewayResourceProfileModel_types.h
index db18209..231d73f 100644
--- a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/gatewayResourceProfileModel_types.h
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/gatewayResourceProfileModel_types.h
@@ -140,25 +140,22 @@ class ComputeResourcePreference {
 void swap(ComputeResourcePreference &a, ComputeResourcePreference &b);
 
 typedef struct _GatewayResourceProfile__isset {
-  _GatewayResourceProfile__isset() : gatewayDescription(false), computeResourcePreferences(false) {}
-  bool gatewayDescription;
+  _GatewayResourceProfile__isset() : computeResourcePreferences(false) {}
   bool computeResourcePreferences;
 } _GatewayResourceProfile__isset;
 
 class GatewayResourceProfile {
  public:
 
-  static const char* ascii_fingerprint; // = "42DA2625493A482A59D0742432A025BD";
-  static const uint8_t binary_fingerprint[16]; // = {0x42,0xDA,0x26,0x25,0x49,0x3A,0x48,0x2A,0x59,0xD0,0x74,0x24,0x32,0xA0,0x25,0xBD};
+  static const char* ascii_fingerprint; // = "2C13C97D8E01026228E6E378E58505CC";
+  static const uint8_t binary_fingerprint[16]; // = {0x2C,0x13,0xC9,0x7D,0x8E,0x01,0x02,0x62,0x28,0xE6,0xE3,0x78,0xE5,0x85,0x05,0xCC};
 
-  GatewayResourceProfile() : gatewayID("DO_NOT_SET_AT_CLIENTS"), gatewayName(), gatewayDescription() {
+  GatewayResourceProfile() : gatewayID() {
   }
 
   virtual ~GatewayResourceProfile() throw() {}
 
   std::string gatewayID;
-  std::string gatewayName;
-  std::string gatewayDescription;
   std::vector<ComputeResourcePreference>  computeResourcePreferences;
 
   _GatewayResourceProfile__isset __isset;
@@ -167,15 +164,6 @@ class GatewayResourceProfile {
     gatewayID = val;
   }
 
-  void __set_gatewayName(const std::string& val) {
-    gatewayName = val;
-  }
-
-  void __set_gatewayDescription(const std::string& val) {
-    gatewayDescription = val;
-    __isset.gatewayDescription = true;
-  }
-
   void __set_computeResourcePreferences(const std::vector<ComputeResourcePreference> & val) {
     computeResourcePreferences = val;
     __isset.computeResourcePreferences = true;
@@ -185,12 +173,6 @@ class GatewayResourceProfile {
   {
     if (!(gatewayID == rhs.gatewayID))
       return false;
-    if (!(gatewayName == rhs.gatewayName))
-      return false;
-    if (__isset.gatewayDescription != rhs.__isset.gatewayDescription)
-      return false;
-    else if (__isset.gatewayDescription && !(gatewayDescription == rhs.gatewayDescription))
-      return false;
     if (__isset.computeResourcePreferences != rhs.__isset.computeResourcePreferences)
       return false;
     else if (__isset.computeResourcePreferences && !(computeResourcePreferences == rhs.computeResourcePreferences))

http://git-wip-us.apache.org/repos/asf/airavata/blob/658e5e9e/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/workspaceModel_types.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/workspaceModel_types.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/workspaceModel_types.cpp
index 7bc863a..311ea63 100644
--- a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/workspaceModel_types.cpp
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/workspaceModel_types.cpp
@@ -398,8 +398,8 @@ void swap(User &a, User &b) {
   swap(a.__isset, b.__isset);
 }
 
-const char* Gateway::ascii_fingerprint = "07A9615F837F7D0A952B595DD3020972";
-const uint8_t Gateway::binary_fingerprint[16] = {0x07,0xA9,0x61,0x5F,0x83,0x7F,0x7D,0x0A,0x95,0x2B,0x59,0x5D,0xD3,0x02,0x09,0x72};
+const char* Gateway::ascii_fingerprint = "6BA700CA2E5FC52A8DA5ADCF811DC8DA";
+const uint8_t Gateway::binary_fingerprint[16] = {0x6B,0xA7,0x00,0xCA,0x2E,0x5F,0xC5,0x2A,0x8D,0xA5,0xAD,0xCF,0x81,0x1D,0xC8,0xDA};
 
 uint32_t Gateway::read(::apache::thrift::protocol::TProtocol* iprot) {
 
@@ -413,7 +413,6 @@ uint32_t Gateway::read(::apache::thrift::protocol::TProtocol* iprot) {
   using ::apache::thrift::protocol::TProtocolException;
 
   bool isset_gatewayId = false;
-  bool isset_name = false;
 
   while (true)
   {
@@ -433,8 +432,24 @@ uint32_t Gateway::read(::apache::thrift::protocol::TProtocol* iprot) {
         break;
       case 2:
         if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readString(this->name);
-          isset_name = true;
+          xfer += iprot->readString(this->gatewayName);
+          this->__isset.gatewayName = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->domain);
+          this->__isset.domain = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->emailAddress);
+          this->__isset.emailAddress = true;
         } else {
           xfer += iprot->skip(ftype);
         }
@@ -450,8 +465,6 @@ uint32_t Gateway::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   if (!isset_gatewayId)
     throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_name)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
   return xfer;
 }
 
@@ -463,10 +476,21 @@ uint32_t Gateway::write(::apache::thrift::protocol::TProtocol* oprot) const {
   xfer += oprot->writeString(this->gatewayId);
   xfer += oprot->writeFieldEnd();
 
-  xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 2);
-  xfer += oprot->writeString(this->name);
-  xfer += oprot->writeFieldEnd();
-
+  if (this->__isset.gatewayName) {
+    xfer += oprot->writeFieldBegin("gatewayName", ::apache::thrift::protocol::T_STRING, 2);
+    xfer += oprot->writeString(this->gatewayName);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.domain) {
+    xfer += oprot->writeFieldBegin("domain", ::apache::thrift::protocol::T_STRING, 3);
+    xfer += oprot->writeString(this->domain);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.emailAddress) {
+    xfer += oprot->writeFieldBegin("emailAddress", ::apache::thrift::protocol::T_STRING, 4);
+    xfer += oprot->writeString(this->emailAddress);
+    xfer += oprot->writeFieldEnd();
+  }
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
   return xfer;
@@ -475,7 +499,10 @@ uint32_t Gateway::write(::apache::thrift::protocol::TProtocol* oprot) const {
 void swap(Gateway &a, Gateway &b) {
   using ::std::swap;
   swap(a.gatewayId, b.gatewayId);
-  swap(a.name, b.name);
+  swap(a.gatewayName, b.gatewayName);
+  swap(a.domain, b.domain);
+  swap(a.emailAddress, b.emailAddress);
+  swap(a.__isset, b.__isset);
 }
 
 }}}} // namespace

http://git-wip-us.apache.org/repos/asf/airavata/blob/658e5e9e/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/workspaceModel_types.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/workspaceModel_types.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/workspaceModel_types.h
index f2a68b8..41593a6 100644
--- a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/workspaceModel_types.h
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/workspaceModel_types.h
@@ -241,34 +241,65 @@ class User {
 
 void swap(User &a, User &b);
 
+typedef struct _Gateway__isset {
+  _Gateway__isset() : gatewayName(false), domain(false), emailAddress(false) {}
+  bool gatewayName;
+  bool domain;
+  bool emailAddress;
+} _Gateway__isset;
 
 class Gateway {
  public:
 
-  static const char* ascii_fingerprint; // = "07A9615F837F7D0A952B595DD3020972";
-  static const uint8_t binary_fingerprint[16]; // = {0x07,0xA9,0x61,0x5F,0x83,0x7F,0x7D,0x0A,0x95,0x2B,0x59,0x5D,0xD3,0x02,0x09,0x72};
+  static const char* ascii_fingerprint; // = "6BA700CA2E5FC52A8DA5ADCF811DC8DA";
+  static const uint8_t binary_fingerprint[16]; // = {0x6B,0xA7,0x00,0xCA,0x2E,0x5F,0xC5,0x2A,0x8D,0xA5,0xAD,0xCF,0x81,0x1D,0xC8,0xDA};
 
-  Gateway() : gatewayId("DO_NOT_SET_AT_CLIENTS"), name() {
+  Gateway() : gatewayId(), gatewayName(), domain(), emailAddress() {
   }
 
   virtual ~Gateway() throw() {}
 
   std::string gatewayId;
-  std::string name;
+  std::string gatewayName;
+  std::string domain;
+  std::string emailAddress;
+
+  _Gateway__isset __isset;
 
   void __set_gatewayId(const std::string& val) {
     gatewayId = val;
   }
 
-  void __set_name(const std::string& val) {
-    name = val;
+  void __set_gatewayName(const std::string& val) {
+    gatewayName = val;
+    __isset.gatewayName = true;
+  }
+
+  void __set_domain(const std::string& val) {
+    domain = val;
+    __isset.domain = true;
+  }
+
+  void __set_emailAddress(const std::string& val) {
+    emailAddress = val;
+    __isset.emailAddress = true;
   }
 
   bool operator == (const Gateway & rhs) const
   {
     if (!(gatewayId == rhs.gatewayId))
       return false;
-    if (!(name == rhs.name))
+    if (__isset.gatewayName != rhs.__isset.gatewayName)
+      return false;
+    else if (__isset.gatewayName && !(gatewayName == rhs.gatewayName))
+      return false;
+    if (__isset.domain != rhs.__isset.domain)
+      return false;
+    else if (__isset.domain && !(domain == rhs.domain))
+      return false;
+    if (__isset.emailAddress != rhs.__isset.emailAddress)
+      return false;
+    else if (__isset.emailAddress && !(emailAddress == rhs.emailAddress))
       return false;
     return true;
   }


Mime
View raw message