You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@airavata.apache.org by sm...@apache.org on 2014/07/07 07:25:18 UTC

[2/4] API Methods required by PHP Gateway - AIRAVATA-1296

http://git-wip-us.apache.org/repos/asf/airavata/blob/2d5d054b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/Airavata.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/Airavata.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/Airavata.cpp
index 9d6a6fd..d9743be 100644
--- a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/Airavata.cpp
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/Airavata.cpp
@@ -9277,6 +9277,263 @@ uint32_t Airavata_getApplicationOutputs_presult::read(::apache::thrift::protocol
   return xfer;
 }
 
+uint32_t Airavata_getAvailableAppInterfaceComputeResources_args::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_appInterfaceId = 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->appInterfaceId);
+          isset_appInterfaceId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_appInterfaceId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t Airavata_getAvailableAppInterfaceComputeResources_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Airavata_getAvailableAppInterfaceComputeResources_args");
+
+  xfer += oprot->writeFieldBegin("appInterfaceId", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->appInterfaceId);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Airavata_getAvailableAppInterfaceComputeResources_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Airavata_getAvailableAppInterfaceComputeResources_pargs");
+
+  xfer += oprot->writeFieldBegin("appInterfaceId", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString((*(this->appInterfaceId)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Airavata_getAvailableAppInterfaceComputeResources_result::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;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->success.clear();
+            uint32_t _size147;
+            ::apache::thrift::protocol::TType _etype150;
+            xfer += iprot->readListBegin(_etype150, _size147);
+            this->success.resize(_size147);
+            uint32_t _i151;
+            for (_i151 = 0; _i151 < _size147; ++_i151)
+            {
+              xfer += iprot->readString(this->success[_i151]);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ace.read(iprot);
+          this->__isset.ace = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ase.read(iprot);
+          this->__isset.ase = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Airavata_getAvailableAppInterfaceComputeResources_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("Airavata_getAvailableAppInterfaceComputeResources_result");
+
+  if (this->__isset.success) {
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
+    {
+      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size()));
+      std::vector<std::string> ::const_iterator _iter152;
+      for (_iter152 = this->success.begin(); _iter152 != this->success.end(); ++_iter152)
+      {
+        xfer += oprot->writeString((*_iter152));
+      }
+      xfer += oprot->writeListEnd();
+    }
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ire) {
+    xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->ire.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ace) {
+    xfer += oprot->writeFieldBegin("ace", ::apache::thrift::protocol::T_STRUCT, 2);
+    xfer += this->ace.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ase) {
+    xfer += oprot->writeFieldBegin("ase", ::apache::thrift::protocol::T_STRUCT, 3);
+    xfer += this->ase.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Airavata_getAvailableAppInterfaceComputeResources_presult::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;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            (*(this->success)).clear();
+            uint32_t _size153;
+            ::apache::thrift::protocol::TType _etype156;
+            xfer += iprot->readListBegin(_etype156, _size153);
+            (*(this->success)).resize(_size153);
+            uint32_t _i157;
+            for (_i157 = 0; _i157 < _size153; ++_i157)
+            {
+              xfer += iprot->readString((*(this->success))[_i157]);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ace.read(iprot);
+          this->__isset.ace = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ase.read(iprot);
+          this->__isset.ase = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
 uint32_t Airavata_registerComputeResource_args::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   uint32_t xfer = 0;
@@ -9635,15 +9892,240 @@ uint32_t Airavata_getComputeResource_result::read(::apache::thrift::protocol::TP
   return xfer;
 }
 
-uint32_t Airavata_getComputeResource_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t Airavata_getComputeResource_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("Airavata_getComputeResource_result");
+
+  if (this->__isset.success) {
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0);
+    xfer += this->success.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ire) {
+    xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->ire.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ace) {
+    xfer += oprot->writeFieldBegin("ace", ::apache::thrift::protocol::T_STRUCT, 2);
+    xfer += this->ace.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ase) {
+    xfer += oprot->writeFieldBegin("ase", ::apache::thrift::protocol::T_STRUCT, 3);
+    xfer += this->ase.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Airavata_getComputeResource_presult::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;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->success)).read(iprot);
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ace.read(iprot);
+          this->__isset.ace = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ase.read(iprot);
+          this->__isset.ase = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Airavata_getAllComputeResourceNames_args::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;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    xfer += iprot->skip(ftype);
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Airavata_getAllComputeResourceNames_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Airavata_getAllComputeResourceNames_args");
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Airavata_getAllComputeResourceNames_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Airavata_getAllComputeResourceNames_pargs");
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Airavata_getAllComputeResourceNames_result::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;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_MAP) {
+          {
+            this->success.clear();
+            uint32_t _size158;
+            ::apache::thrift::protocol::TType _ktype159;
+            ::apache::thrift::protocol::TType _vtype160;
+            xfer += iprot->readMapBegin(_ktype159, _vtype160, _size158);
+            uint32_t _i162;
+            for (_i162 = 0; _i162 < _size158; ++_i162)
+            {
+              std::string _key163;
+              xfer += iprot->readString(_key163);
+              std::string& _val164 = this->success[_key163];
+              xfer += iprot->readString(_val164);
+            }
+            xfer += iprot->readMapEnd();
+          }
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ire.read(iprot);
+          this->__isset.ire = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ace.read(iprot);
+          this->__isset.ace = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ase.read(iprot);
+          this->__isset.ase = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Airavata_getAllComputeResourceNames_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
 
   uint32_t xfer = 0;
 
-  xfer += oprot->writeStructBegin("Airavata_getComputeResource_result");
+  xfer += oprot->writeStructBegin("Airavata_getAllComputeResourceNames_result");
 
   if (this->__isset.success) {
-    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0);
-    xfer += this->success.write(oprot);
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_MAP, 0);
+    {
+      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size()));
+      std::map<std::string, std::string> ::const_iterator _iter165;
+      for (_iter165 = this->success.begin(); _iter165 != this->success.end(); ++_iter165)
+      {
+        xfer += oprot->writeString(_iter165->first);
+        xfer += oprot->writeString(_iter165->second);
+      }
+      xfer += oprot->writeMapEnd();
+    }
     xfer += oprot->writeFieldEnd();
   } else if (this->__isset.ire) {
     xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
@@ -9663,7 +10145,7 @@ uint32_t Airavata_getComputeResource_result::write(::apache::thrift::protocol::T
   return xfer;
 }
 
-uint32_t Airavata_getComputeResource_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t Airavata_getAllComputeResourceNames_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   uint32_t xfer = 0;
   std::string fname;
@@ -9684,8 +10166,23 @@ uint32_t Airavata_getComputeResource_presult::read(::apache::thrift::protocol::T
     switch (fid)
     {
       case 0:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += (*(this->success)).read(iprot);
+        if (ftype == ::apache::thrift::protocol::T_MAP) {
+          {
+            (*(this->success)).clear();
+            uint32_t _size166;
+            ::apache::thrift::protocol::TType _ktype167;
+            ::apache::thrift::protocol::TType _vtype168;
+            xfer += iprot->readMapBegin(_ktype167, _vtype168, _size166);
+            uint32_t _i170;
+            for (_i170 = 0; _i170 < _size166; ++_i170)
+            {
+              std::string _key171;
+              xfer += iprot->readString(_key171);
+              std::string& _val172 = (*(this->success))[_key171];
+              xfer += iprot->readString(_val172);
+            }
+            xfer += iprot->readMapEnd();
+          }
           this->__isset.success = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -13244,17 +13741,17 @@ uint32_t Airavata_changeJobSubmissionPriorities_args::read(::apache::thrift::pro
         if (ftype == ::apache::thrift::protocol::T_MAP) {
           {
             this->jobSubmissionPriorityMap.clear();
-            uint32_t _size147;
-            ::apache::thrift::protocol::TType _ktype148;
-            ::apache::thrift::protocol::TType _vtype149;
-            xfer += iprot->readMapBegin(_ktype148, _vtype149, _size147);
-            uint32_t _i151;
-            for (_i151 = 0; _i151 < _size147; ++_i151)
+            uint32_t _size173;
+            ::apache::thrift::protocol::TType _ktype174;
+            ::apache::thrift::protocol::TType _vtype175;
+            xfer += iprot->readMapBegin(_ktype174, _vtype175, _size173);
+            uint32_t _i177;
+            for (_i177 = 0; _i177 < _size173; ++_i177)
             {
-              std::string _key152;
-              xfer += iprot->readString(_key152);
-              int32_t& _val153 = this->jobSubmissionPriorityMap[_key152];
-              xfer += iprot->readI32(_val153);
+              std::string _key178;
+              xfer += iprot->readString(_key178);
+              int32_t& _val179 = this->jobSubmissionPriorityMap[_key178];
+              xfer += iprot->readI32(_val179);
             }
             xfer += iprot->readMapEnd();
           }
@@ -13284,11 +13781,11 @@ uint32_t Airavata_changeJobSubmissionPriorities_args::write(::apache::thrift::pr
   xfer += oprot->writeFieldBegin("jobSubmissionPriorityMap", ::apache::thrift::protocol::T_MAP, 1);
   {
     xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_I32, static_cast<uint32_t>(this->jobSubmissionPriorityMap.size()));
-    std::map<std::string, int32_t> ::const_iterator _iter154;
-    for (_iter154 = this->jobSubmissionPriorityMap.begin(); _iter154 != this->jobSubmissionPriorityMap.end(); ++_iter154)
+    std::map<std::string, int32_t> ::const_iterator _iter180;
+    for (_iter180 = this->jobSubmissionPriorityMap.begin(); _iter180 != this->jobSubmissionPriorityMap.end(); ++_iter180)
     {
-      xfer += oprot->writeString(_iter154->first);
-      xfer += oprot->writeI32(_iter154->second);
+      xfer += oprot->writeString(_iter180->first);
+      xfer += oprot->writeI32(_iter180->second);
     }
     xfer += oprot->writeMapEnd();
   }
@@ -13306,11 +13803,11 @@ uint32_t Airavata_changeJobSubmissionPriorities_pargs::write(::apache::thrift::p
   xfer += oprot->writeFieldBegin("jobSubmissionPriorityMap", ::apache::thrift::protocol::T_MAP, 1);
   {
     xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_I32, static_cast<uint32_t>((*(this->jobSubmissionPriorityMap)).size()));
-    std::map<std::string, int32_t> ::const_iterator _iter155;
-    for (_iter155 = (*(this->jobSubmissionPriorityMap)).begin(); _iter155 != (*(this->jobSubmissionPriorityMap)).end(); ++_iter155)
+    std::map<std::string, int32_t> ::const_iterator _iter181;
+    for (_iter181 = (*(this->jobSubmissionPriorityMap)).begin(); _iter181 != (*(this->jobSubmissionPriorityMap)).end(); ++_iter181)
     {
-      xfer += oprot->writeString(_iter155->first);
-      xfer += oprot->writeI32(_iter155->second);
+      xfer += oprot->writeString(_iter181->first);
+      xfer += oprot->writeI32(_iter181->second);
     }
     xfer += oprot->writeMapEnd();
   }
@@ -13502,17 +13999,17 @@ uint32_t Airavata_changeDataMovementPriorities_args::read(::apache::thrift::prot
         if (ftype == ::apache::thrift::protocol::T_MAP) {
           {
             this->dataMovementPriorityMap.clear();
-            uint32_t _size156;
-            ::apache::thrift::protocol::TType _ktype157;
-            ::apache::thrift::protocol::TType _vtype158;
-            xfer += iprot->readMapBegin(_ktype157, _vtype158, _size156);
-            uint32_t _i160;
-            for (_i160 = 0; _i160 < _size156; ++_i160)
+            uint32_t _size182;
+            ::apache::thrift::protocol::TType _ktype183;
+            ::apache::thrift::protocol::TType _vtype184;
+            xfer += iprot->readMapBegin(_ktype183, _vtype184, _size182);
+            uint32_t _i186;
+            for (_i186 = 0; _i186 < _size182; ++_i186)
             {
-              std::string _key161;
-              xfer += iprot->readString(_key161);
-              int32_t& _val162 = this->dataMovementPriorityMap[_key161];
-              xfer += iprot->readI32(_val162);
+              std::string _key187;
+              xfer += iprot->readString(_key187);
+              int32_t& _val188 = this->dataMovementPriorityMap[_key187];
+              xfer += iprot->readI32(_val188);
             }
             xfer += iprot->readMapEnd();
           }
@@ -13542,11 +14039,11 @@ uint32_t Airavata_changeDataMovementPriorities_args::write(::apache::thrift::pro
   xfer += oprot->writeFieldBegin("dataMovementPriorityMap", ::apache::thrift::protocol::T_MAP, 1);
   {
     xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_I32, static_cast<uint32_t>(this->dataMovementPriorityMap.size()));
-    std::map<std::string, int32_t> ::const_iterator _iter163;
-    for (_iter163 = this->dataMovementPriorityMap.begin(); _iter163 != this->dataMovementPriorityMap.end(); ++_iter163)
+    std::map<std::string, int32_t> ::const_iterator _iter189;
+    for (_iter189 = this->dataMovementPriorityMap.begin(); _iter189 != this->dataMovementPriorityMap.end(); ++_iter189)
     {
-      xfer += oprot->writeString(_iter163->first);
-      xfer += oprot->writeI32(_iter163->second);
+      xfer += oprot->writeString(_iter189->first);
+      xfer += oprot->writeI32(_iter189->second);
     }
     xfer += oprot->writeMapEnd();
   }
@@ -13564,11 +14061,11 @@ uint32_t Airavata_changeDataMovementPriorities_pargs::write(::apache::thrift::pr
   xfer += oprot->writeFieldBegin("dataMovementPriorityMap", ::apache::thrift::protocol::T_MAP, 1);
   {
     xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_I32, static_cast<uint32_t>((*(this->dataMovementPriorityMap)).size()));
-    std::map<std::string, int32_t> ::const_iterator _iter164;
-    for (_iter164 = (*(this->dataMovementPriorityMap)).begin(); _iter164 != (*(this->dataMovementPriorityMap)).end(); ++_iter164)
+    std::map<std::string, int32_t> ::const_iterator _iter190;
+    for (_iter190 = (*(this->dataMovementPriorityMap)).begin(); _iter190 != (*(this->dataMovementPriorityMap)).end(); ++_iter190)
     {
-      xfer += oprot->writeString(_iter164->first);
-      xfer += oprot->writeI32(_iter164->second);
+      xfer += oprot->writeString(_iter190->first);
+      xfer += oprot->writeI32(_iter190->second);
     }
     xfer += oprot->writeMapEnd();
   }
@@ -14275,8 +14772,8 @@ uint32_t Airavata_registerGatewayResourceProfile_result::read(::apache::thrift::
     switch (fid)
     {
       case 0:
-        if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readString(this->success);
+        if (ftype == ::apache::thrift::protocol::T_BOOL) {
+          xfer += iprot->readBool(this->success);
           this->__isset.success = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -14325,8 +14822,8 @@ uint32_t Airavata_registerGatewayResourceProfile_result::write(::apache::thrift:
   xfer += oprot->writeStructBegin("Airavata_registerGatewayResourceProfile_result");
 
   if (this->__isset.success) {
-    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRING, 0);
-    xfer += oprot->writeString(this->success);
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0);
+    xfer += oprot->writeBool(this->success);
     xfer += oprot->writeFieldEnd();
   } else if (this->__isset.ire) {
     xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
@@ -14367,8 +14864,8 @@ uint32_t Airavata_registerGatewayResourceProfile_presult::read(::apache::thrift:
     switch (fid)
     {
       case 0:
-        if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readString((*(this->success)));
+        if (ftype == ::apache::thrift::protocol::T_BOOL) {
+          xfer += iprot->readBool((*(this->success)));
           this->__isset.success = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -15704,14 +16201,14 @@ uint32_t Airavata_getAllGatewayComputeResourcePreferences_result::read(::apache:
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->success.clear();
-            uint32_t _size165;
-            ::apache::thrift::protocol::TType _etype168;
-            xfer += iprot->readListBegin(_etype168, _size165);
-            this->success.resize(_size165);
-            uint32_t _i169;
-            for (_i169 = 0; _i169 < _size165; ++_i169)
+            uint32_t _size191;
+            ::apache::thrift::protocol::TType _etype194;
+            xfer += iprot->readListBegin(_etype194, _size191);
+            this->success.resize(_size191);
+            uint32_t _i195;
+            for (_i195 = 0; _i195 < _size191; ++_i195)
             {
-              xfer += this->success[_i169].read(iprot);
+              xfer += this->success[_i195].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -15766,10 +16263,10 @@ uint32_t Airavata_getAllGatewayComputeResourcePreferences_result::write(::apache
     xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
     {
       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
-      std::vector< ::ComputeResourcePreference> ::const_iterator _iter170;
-      for (_iter170 = this->success.begin(); _iter170 != this->success.end(); ++_iter170)
+      std::vector< ::ComputeResourcePreference> ::const_iterator _iter196;
+      for (_iter196 = this->success.begin(); _iter196 != this->success.end(); ++_iter196)
       {
-        xfer += (*_iter170).write(oprot);
+        xfer += (*_iter196).write(oprot);
       }
       xfer += oprot->writeListEnd();
     }
@@ -15816,14 +16313,14 @@ uint32_t Airavata_getAllGatewayComputeResourcePreferences_presult::read(::apache
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             (*(this->success)).clear();
-            uint32_t _size171;
-            ::apache::thrift::protocol::TType _etype174;
-            xfer += iprot->readListBegin(_etype174, _size171);
-            (*(this->success)).resize(_size171);
-            uint32_t _i175;
-            for (_i175 = 0; _i175 < _size171; ++_i175)
+            uint32_t _size197;
+            ::apache::thrift::protocol::TType _etype200;
+            xfer += iprot->readListBegin(_etype200, _size197);
+            (*(this->success)).resize(_size197);
+            uint32_t _i201;
+            for (_i201 = 0; _i201 < _size197; ++_i201)
             {
-              xfer += (*(this->success))[_i175].read(iprot);
+              xfer += (*(this->success))[_i201].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -18968,6 +19465,73 @@ void AiravataClient::recv_getApplicationOutputs(std::vector< ::OutputDataObjectT
   throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getApplicationOutputs failed: unknown result");
 }
 
+void AiravataClient::getAvailableAppInterfaceComputeResources(std::vector<std::string> & _return, const std::string& appInterfaceId)
+{
+  send_getAvailableAppInterfaceComputeResources(appInterfaceId);
+  recv_getAvailableAppInterfaceComputeResources(_return);
+}
+
+void AiravataClient::send_getAvailableAppInterfaceComputeResources(const std::string& appInterfaceId)
+{
+  int32_t cseqid = 0;
+  oprot_->writeMessageBegin("getAvailableAppInterfaceComputeResources", ::apache::thrift::protocol::T_CALL, cseqid);
+
+  Airavata_getAvailableAppInterfaceComputeResources_pargs args;
+  args.appInterfaceId = &appInterfaceId;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+}
+
+void AiravataClient::recv_getAvailableAppInterfaceComputeResources(std::vector<std::string> & _return)
+{
+
+  int32_t rseqid = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TMessageType mtype;
+
+  iprot_->readMessageBegin(fname, mtype, rseqid);
+  if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+    ::apache::thrift::TApplicationException x;
+    x.read(iprot_);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+    throw x;
+  }
+  if (mtype != ::apache::thrift::protocol::T_REPLY) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  if (fname.compare("getAvailableAppInterfaceComputeResources") != 0) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  Airavata_getAvailableAppInterfaceComputeResources_presult result;
+  result.success = &_return;
+  result.read(iprot_);
+  iprot_->readMessageEnd();
+  iprot_->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    // _return pointer has now been filled
+    return;
+  }
+  if (result.__isset.ire) {
+    throw result.ire;
+  }
+  if (result.__isset.ace) {
+    throw result.ace;
+  }
+  if (result.__isset.ase) {
+    throw result.ase;
+  }
+  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getAvailableAppInterfaceComputeResources failed: unknown result");
+}
+
 void AiravataClient::registerComputeResource(std::string& _return, const  ::ComputeResourceDescription& computeResourceDescription)
 {
   send_registerComputeResource(computeResourceDescription);
@@ -19102,6 +19666,72 @@ void AiravataClient::recv_getComputeResource( ::ComputeResourceDescription& _ret
   throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getComputeResource failed: unknown result");
 }
 
+void AiravataClient::getAllComputeResourceNames(std::map<std::string, std::string> & _return)
+{
+  send_getAllComputeResourceNames();
+  recv_getAllComputeResourceNames(_return);
+}
+
+void AiravataClient::send_getAllComputeResourceNames()
+{
+  int32_t cseqid = 0;
+  oprot_->writeMessageBegin("getAllComputeResourceNames", ::apache::thrift::protocol::T_CALL, cseqid);
+
+  Airavata_getAllComputeResourceNames_pargs args;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+}
+
+void AiravataClient::recv_getAllComputeResourceNames(std::map<std::string, std::string> & _return)
+{
+
+  int32_t rseqid = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TMessageType mtype;
+
+  iprot_->readMessageBegin(fname, mtype, rseqid);
+  if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+    ::apache::thrift::TApplicationException x;
+    x.read(iprot_);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+    throw x;
+  }
+  if (mtype != ::apache::thrift::protocol::T_REPLY) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  if (fname.compare("getAllComputeResourceNames") != 0) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  Airavata_getAllComputeResourceNames_presult result;
+  result.success = &_return;
+  result.read(iprot_);
+  iprot_->readMessageEnd();
+  iprot_->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    // _return pointer has now been filled
+    return;
+  }
+  if (result.__isset.ire) {
+    throw result.ire;
+  }
+  if (result.__isset.ace) {
+    throw result.ace;
+  }
+  if (result.__isset.ase) {
+    throw result.ase;
+  }
+  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getAllComputeResourceNames failed: unknown result");
+}
+
 bool AiravataClient::updateComputeResource(const std::string& computeResourceId, const  ::ComputeResourceDescription& computeResourceDescription)
 {
   send_updateComputeResource(computeResourceId, computeResourceDescription);
@@ -20326,10 +20956,10 @@ bool AiravataClient::recv_deleteDataMovementInterface()
   throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "deleteDataMovementInterface failed: unknown result");
 }
 
-void AiravataClient::registerGatewayResourceProfile(std::string& _return, const  ::GatewayResourceProfile& gatewayResourceProfile)
+bool AiravataClient::registerGatewayResourceProfile(const  ::GatewayResourceProfile& gatewayResourceProfile)
 {
   send_registerGatewayResourceProfile(gatewayResourceProfile);
-  recv_registerGatewayResourceProfile(_return);
+  return recv_registerGatewayResourceProfile();
 }
 
 void AiravataClient::send_registerGatewayResourceProfile(const  ::GatewayResourceProfile& gatewayResourceProfile)
@@ -20346,7 +20976,7 @@ void AiravataClient::send_registerGatewayResourceProfile(const  ::GatewayResourc
   oprot_->getTransport()->flush();
 }
 
-void AiravataClient::recv_registerGatewayResourceProfile(std::string& _return)
+bool AiravataClient::recv_registerGatewayResourceProfile()
 {
 
   int32_t rseqid = 0;
@@ -20371,6 +21001,7 @@ void AiravataClient::recv_registerGatewayResourceProfile(std::string& _return)
     iprot_->readMessageEnd();
     iprot_->getTransport()->readEnd();
   }
+  bool _return;
   Airavata_registerGatewayResourceProfile_presult result;
   result.success = &_return;
   result.read(iprot_);
@@ -20378,8 +21009,7 @@ void AiravataClient::recv_registerGatewayResourceProfile(std::string& _return)
   iprot_->getTransport()->readEnd();
 
   if (result.__isset.success) {
-    // _return pointer has now been filled
-    return;
+    return _return;
   }
   if (result.__isset.ire) {
     throw result.ire;
@@ -23403,6 +24033,69 @@ void AiravataProcessor::process_getApplicationOutputs(int32_t seqid, ::apache::t
   }
 }
 
+void AiravataProcessor::process_getAvailableAppInterfaceComputeResources(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+  void* ctx = NULL;
+  if (this->eventHandler_.get() != NULL) {
+    ctx = this->eventHandler_->getContext("Airavata.getAvailableAppInterfaceComputeResources", callContext);
+  }
+  ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Airavata.getAvailableAppInterfaceComputeResources");
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preRead(ctx, "Airavata.getAvailableAppInterfaceComputeResources");
+  }
+
+  Airavata_getAvailableAppInterfaceComputeResources_args args;
+  args.read(iprot);
+  iprot->readMessageEnd();
+  uint32_t bytes = iprot->getTransport()->readEnd();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postRead(ctx, "Airavata.getAvailableAppInterfaceComputeResources", bytes);
+  }
+
+  Airavata_getAvailableAppInterfaceComputeResources_result result;
+  try {
+    iface_->getAvailableAppInterfaceComputeResources(result.success, args.appInterfaceId);
+    result.__isset.success = true;
+  } catch ( ::airavata::api::error::InvalidRequestException &ire) {
+    result.ire = ire;
+    result.__isset.ire = true;
+  } catch ( ::airavata::api::error::AiravataClientException &ace) {
+    result.ace = ace;
+    result.__isset.ace = true;
+  } catch ( ::airavata::api::error::AiravataSystemException &ase) {
+    result.ase = ase;
+    result.__isset.ase = true;
+  } catch (const std::exception& e) {
+    if (this->eventHandler_.get() != NULL) {
+      this->eventHandler_->handlerError(ctx, "Airavata.getAvailableAppInterfaceComputeResources");
+    }
+
+    ::apache::thrift::TApplicationException x(e.what());
+    oprot->writeMessageBegin("getAvailableAppInterfaceComputeResources", ::apache::thrift::protocol::T_EXCEPTION, seqid);
+    x.write(oprot);
+    oprot->writeMessageEnd();
+    oprot->getTransport()->writeEnd();
+    oprot->getTransport()->flush();
+    return;
+  }
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preWrite(ctx, "Airavata.getAvailableAppInterfaceComputeResources");
+  }
+
+  oprot->writeMessageBegin("getAvailableAppInterfaceComputeResources", ::apache::thrift::protocol::T_REPLY, seqid);
+  result.write(oprot);
+  oprot->writeMessageEnd();
+  bytes = oprot->getTransport()->writeEnd();
+  oprot->getTransport()->flush();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postWrite(ctx, "Airavata.getAvailableAppInterfaceComputeResources", bytes);
+  }
+}
+
 void AiravataProcessor::process_registerComputeResource(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
 {
   void* ctx = NULL;
@@ -23529,6 +24222,69 @@ void AiravataProcessor::process_getComputeResource(int32_t seqid, ::apache::thri
   }
 }
 
+void AiravataProcessor::process_getAllComputeResourceNames(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+  void* ctx = NULL;
+  if (this->eventHandler_.get() != NULL) {
+    ctx = this->eventHandler_->getContext("Airavata.getAllComputeResourceNames", callContext);
+  }
+  ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Airavata.getAllComputeResourceNames");
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preRead(ctx, "Airavata.getAllComputeResourceNames");
+  }
+
+  Airavata_getAllComputeResourceNames_args args;
+  args.read(iprot);
+  iprot->readMessageEnd();
+  uint32_t bytes = iprot->getTransport()->readEnd();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postRead(ctx, "Airavata.getAllComputeResourceNames", bytes);
+  }
+
+  Airavata_getAllComputeResourceNames_result result;
+  try {
+    iface_->getAllComputeResourceNames(result.success);
+    result.__isset.success = true;
+  } catch ( ::airavata::api::error::InvalidRequestException &ire) {
+    result.ire = ire;
+    result.__isset.ire = true;
+  } catch ( ::airavata::api::error::AiravataClientException &ace) {
+    result.ace = ace;
+    result.__isset.ace = true;
+  } catch ( ::airavata::api::error::AiravataSystemException &ase) {
+    result.ase = ase;
+    result.__isset.ase = true;
+  } catch (const std::exception& e) {
+    if (this->eventHandler_.get() != NULL) {
+      this->eventHandler_->handlerError(ctx, "Airavata.getAllComputeResourceNames");
+    }
+
+    ::apache::thrift::TApplicationException x(e.what());
+    oprot->writeMessageBegin("getAllComputeResourceNames", ::apache::thrift::protocol::T_EXCEPTION, seqid);
+    x.write(oprot);
+    oprot->writeMessageEnd();
+    oprot->getTransport()->writeEnd();
+    oprot->getTransport()->flush();
+    return;
+  }
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preWrite(ctx, "Airavata.getAllComputeResourceNames");
+  }
+
+  oprot->writeMessageBegin("getAllComputeResourceNames", ::apache::thrift::protocol::T_REPLY, seqid);
+  result.write(oprot);
+  oprot->writeMessageEnd();
+  bytes = oprot->getTransport()->writeEnd();
+  oprot->getTransport()->flush();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postWrite(ctx, "Airavata.getAllComputeResourceNames", bytes);
+  }
+}
+
 void AiravataProcessor::process_updateComputeResource(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
 {
   void* ctx = NULL;
@@ -24686,7 +25442,7 @@ void AiravataProcessor::process_registerGatewayResourceProfile(int32_t seqid, ::
 
   Airavata_registerGatewayResourceProfile_result result;
   try {
-    iface_->registerGatewayResourceProfile(result.success, args.gatewayResourceProfile);
+    result.success = iface_->registerGatewayResourceProfile(args.gatewayResourceProfile);
     result.__isset.success = true;
   } catch ( ::airavata::api::error::InvalidRequestException &ire) {
     result.ire = ire;

http://git-wip-us.apache.org/repos/asf/airavata/blob/2d5d054b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/Airavata.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/Airavata.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/Airavata.h
index 30b1818..9c76171 100644
--- a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/Airavata.h
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/Airavata.h
@@ -54,8 +54,10 @@ class AiravataIf {
   virtual bool deleteApplicationInterface(const std::string& appInterfaceId) = 0;
   virtual void getApplicationInputs(std::vector< ::InputDataObjectType> & _return, const std::string& appInterfaceId) = 0;
   virtual void getApplicationOutputs(std::vector< ::OutputDataObjectType> & _return, const std::string& appInterfaceId) = 0;
+  virtual void getAvailableAppInterfaceComputeResources(std::vector<std::string> & _return, const std::string& appInterfaceId) = 0;
   virtual void registerComputeResource(std::string& _return, const  ::ComputeResourceDescription& computeResourceDescription) = 0;
   virtual void getComputeResource( ::ComputeResourceDescription& _return, const std::string& computeResourceId) = 0;
+  virtual void getAllComputeResourceNames(std::map<std::string, std::string> & _return) = 0;
   virtual bool updateComputeResource(const std::string& computeResourceId, const  ::ComputeResourceDescription& computeResourceDescription) = 0;
   virtual bool deleteComputeResource(const std::string& computeResourceId) = 0;
   virtual bool addLocalSubmissionDetails(const std::string& computeResourceId, const int32_t priorityOrder, const  ::LOCALSubmission& localSubmission) = 0;
@@ -74,7 +76,7 @@ class AiravataIf {
   virtual bool changeDataMovementPriorities(const std::map<std::string, int32_t> & dataMovementPriorityMap) = 0;
   virtual bool deleteJobSubmissionInterface(const std::string& jobSubmissionInterfaceId) = 0;
   virtual bool deleteDataMovementInterface(const std::string& dataMovementInterfaceId) = 0;
-  virtual void registerGatewayResourceProfile(std::string& _return, const  ::GatewayResourceProfile& gatewayResourceProfile) = 0;
+  virtual bool registerGatewayResourceProfile(const  ::GatewayResourceProfile& gatewayResourceProfile) = 0;
   virtual void getGatewayResourceProfile( ::GatewayResourceProfile& _return, const std::string& gatewayID) = 0;
   virtual bool updateGatewayResourceProfile(const std::string& gatewayID, const  ::GatewayResourceProfile& gatewayResourceProfile) = 0;
   virtual bool deleteGatewayResourceProfile(const std::string& gatewayID) = 0;
@@ -236,12 +238,18 @@ class AiravataNull : virtual public AiravataIf {
   void getApplicationOutputs(std::vector< ::OutputDataObjectType> & /* _return */, const std::string& /* appInterfaceId */) {
     return;
   }
+  void getAvailableAppInterfaceComputeResources(std::vector<std::string> & /* _return */, const std::string& /* appInterfaceId */) {
+    return;
+  }
   void registerComputeResource(std::string& /* _return */, const  ::ComputeResourceDescription& /* computeResourceDescription */) {
     return;
   }
   void getComputeResource( ::ComputeResourceDescription& /* _return */, const std::string& /* computeResourceId */) {
     return;
   }
+  void getAllComputeResourceNames(std::map<std::string, std::string> & /* _return */) {
+    return;
+  }
   bool updateComputeResource(const std::string& /* computeResourceId */, const  ::ComputeResourceDescription& /* computeResourceDescription */) {
     bool _return = false;
     return _return;
@@ -314,8 +322,9 @@ class AiravataNull : virtual public AiravataIf {
     bool _return = false;
     return _return;
   }
-  void registerGatewayResourceProfile(std::string& /* _return */, const  ::GatewayResourceProfile& /* gatewayResourceProfile */) {
-    return;
+  bool registerGatewayResourceProfile(const  ::GatewayResourceProfile& /* gatewayResourceProfile */) {
+    bool _return = false;
+    return _return;
   }
   void getGatewayResourceProfile( ::GatewayResourceProfile& /* _return */, const std::string& /* gatewayID */) {
     return;
@@ -5524,6 +5533,138 @@ class Airavata_getApplicationOutputs_presult {
 };
 
 
+class Airavata_getAvailableAppInterfaceComputeResources_args {
+ public:
+
+  Airavata_getAvailableAppInterfaceComputeResources_args() : appInterfaceId() {
+  }
+
+  virtual ~Airavata_getAvailableAppInterfaceComputeResources_args() throw() {}
+
+  std::string appInterfaceId;
+
+  void __set_appInterfaceId(const std::string& val) {
+    appInterfaceId = val;
+  }
+
+  bool operator == (const Airavata_getAvailableAppInterfaceComputeResources_args & rhs) const
+  {
+    if (!(appInterfaceId == rhs.appInterfaceId))
+      return false;
+    return true;
+  }
+  bool operator != (const Airavata_getAvailableAppInterfaceComputeResources_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Airavata_getAvailableAppInterfaceComputeResources_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Airavata_getAvailableAppInterfaceComputeResources_pargs {
+ public:
+
+
+  virtual ~Airavata_getAvailableAppInterfaceComputeResources_pargs() throw() {}
+
+  const std::string* appInterfaceId;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_getAvailableAppInterfaceComputeResources_result__isset {
+  _Airavata_getAvailableAppInterfaceComputeResources_result__isset() : success(false), ire(false), ace(false), ase(false) {}
+  bool success;
+  bool ire;
+  bool ace;
+  bool ase;
+} _Airavata_getAvailableAppInterfaceComputeResources_result__isset;
+
+class Airavata_getAvailableAppInterfaceComputeResources_result {
+ public:
+
+  Airavata_getAvailableAppInterfaceComputeResources_result() {
+  }
+
+  virtual ~Airavata_getAvailableAppInterfaceComputeResources_result() throw() {}
+
+  std::vector<std::string>  success;
+   ::airavata::api::error::InvalidRequestException ire;
+   ::airavata::api::error::AiravataClientException ace;
+   ::airavata::api::error::AiravataSystemException ase;
+
+  _Airavata_getAvailableAppInterfaceComputeResources_result__isset __isset;
+
+  void __set_success(const std::vector<std::string> & val) {
+    success = val;
+  }
+
+  void __set_ire(const  ::airavata::api::error::InvalidRequestException& val) {
+    ire = val;
+  }
+
+  void __set_ace(const  ::airavata::api::error::AiravataClientException& val) {
+    ace = val;
+  }
+
+  void __set_ase(const  ::airavata::api::error::AiravataSystemException& val) {
+    ase = val;
+  }
+
+  bool operator == (const Airavata_getAvailableAppInterfaceComputeResources_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_getAvailableAppInterfaceComputeResources_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Airavata_getAvailableAppInterfaceComputeResources_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_getAvailableAppInterfaceComputeResources_presult__isset {
+  _Airavata_getAvailableAppInterfaceComputeResources_presult__isset() : success(false), ire(false), ace(false), ase(false) {}
+  bool success;
+  bool ire;
+  bool ace;
+  bool ase;
+} _Airavata_getAvailableAppInterfaceComputeResources_presult__isset;
+
+class Airavata_getAvailableAppInterfaceComputeResources_presult {
+ public:
+
+
+  virtual ~Airavata_getAvailableAppInterfaceComputeResources_presult() throw() {}
+
+  std::vector<std::string> * success;
+   ::airavata::api::error::InvalidRequestException ire;
+   ::airavata::api::error::AiravataClientException ace;
+   ::airavata::api::error::AiravataSystemException ase;
+
+  _Airavata_getAvailableAppInterfaceComputeResources_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
 class Airavata_registerComputeResource_args {
  public:
 
@@ -5788,6 +5929,130 @@ class Airavata_getComputeResource_presult {
 };
 
 
+class Airavata_getAllComputeResourceNames_args {
+ public:
+
+  Airavata_getAllComputeResourceNames_args() {
+  }
+
+  virtual ~Airavata_getAllComputeResourceNames_args() throw() {}
+
+
+  bool operator == (const Airavata_getAllComputeResourceNames_args & /* rhs */) const
+  {
+    return true;
+  }
+  bool operator != (const Airavata_getAllComputeResourceNames_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Airavata_getAllComputeResourceNames_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Airavata_getAllComputeResourceNames_pargs {
+ public:
+
+
+  virtual ~Airavata_getAllComputeResourceNames_pargs() throw() {}
+
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_getAllComputeResourceNames_result__isset {
+  _Airavata_getAllComputeResourceNames_result__isset() : success(false), ire(false), ace(false), ase(false) {}
+  bool success;
+  bool ire;
+  bool ace;
+  bool ase;
+} _Airavata_getAllComputeResourceNames_result__isset;
+
+class Airavata_getAllComputeResourceNames_result {
+ public:
+
+  Airavata_getAllComputeResourceNames_result() {
+  }
+
+  virtual ~Airavata_getAllComputeResourceNames_result() throw() {}
+
+  std::map<std::string, std::string>  success;
+   ::airavata::api::error::InvalidRequestException ire;
+   ::airavata::api::error::AiravataClientException ace;
+   ::airavata::api::error::AiravataSystemException ase;
+
+  _Airavata_getAllComputeResourceNames_result__isset __isset;
+
+  void __set_success(const std::map<std::string, std::string> & val) {
+    success = val;
+  }
+
+  void __set_ire(const  ::airavata::api::error::InvalidRequestException& val) {
+    ire = val;
+  }
+
+  void __set_ace(const  ::airavata::api::error::AiravataClientException& val) {
+    ace = val;
+  }
+
+  void __set_ase(const  ::airavata::api::error::AiravataSystemException& val) {
+    ase = val;
+  }
+
+  bool operator == (const Airavata_getAllComputeResourceNames_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_getAllComputeResourceNames_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Airavata_getAllComputeResourceNames_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_getAllComputeResourceNames_presult__isset {
+  _Airavata_getAllComputeResourceNames_presult__isset() : success(false), ire(false), ace(false), ase(false) {}
+  bool success;
+  bool ire;
+  bool ace;
+  bool ase;
+} _Airavata_getAllComputeResourceNames_presult__isset;
+
+class Airavata_getAllComputeResourceNames_presult {
+ public:
+
+
+  virtual ~Airavata_getAllComputeResourceNames_presult() throw() {}
+
+  std::map<std::string, std::string> * success;
+   ::airavata::api::error::InvalidRequestException ire;
+   ::airavata::api::error::AiravataClientException ace;
+   ::airavata::api::error::AiravataSystemException ase;
+
+  _Airavata_getAllComputeResourceNames_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
 class Airavata_updateComputeResource_args {
  public:
 
@@ -8363,19 +8628,19 @@ typedef struct _Airavata_registerGatewayResourceProfile_result__isset {
 class Airavata_registerGatewayResourceProfile_result {
  public:
 
-  Airavata_registerGatewayResourceProfile_result() : success() {
+  Airavata_registerGatewayResourceProfile_result() : success(0) {
   }
 
   virtual ~Airavata_registerGatewayResourceProfile_result() throw() {}
 
-  std::string success;
+  bool success;
    ::airavata::api::error::InvalidRequestException ire;
    ::airavata::api::error::AiravataClientException ace;
    ::airavata::api::error::AiravataSystemException ase;
 
   _Airavata_registerGatewayResourceProfile_result__isset __isset;
 
-  void __set_success(const std::string& val) {
+  void __set_success(const bool val) {
     success = val;
   }
 
@@ -8428,7 +8693,7 @@ class Airavata_registerGatewayResourceProfile_presult {
 
   virtual ~Airavata_registerGatewayResourceProfile_presult() throw() {}
 
-  std::string* success;
+  bool* success;
    ::airavata::api::error::InvalidRequestException ire;
    ::airavata::api::error::AiravataClientException ace;
    ::airavata::api::error::AiravataSystemException ase;
@@ -9688,12 +9953,18 @@ class AiravataClient : virtual public AiravataIf {
   void getApplicationOutputs(std::vector< ::OutputDataObjectType> & _return, const std::string& appInterfaceId);
   void send_getApplicationOutputs(const std::string& appInterfaceId);
   void recv_getApplicationOutputs(std::vector< ::OutputDataObjectType> & _return);
+  void getAvailableAppInterfaceComputeResources(std::vector<std::string> & _return, const std::string& appInterfaceId);
+  void send_getAvailableAppInterfaceComputeResources(const std::string& appInterfaceId);
+  void recv_getAvailableAppInterfaceComputeResources(std::vector<std::string> & _return);
   void registerComputeResource(std::string& _return, const  ::ComputeResourceDescription& computeResourceDescription);
   void send_registerComputeResource(const  ::ComputeResourceDescription& computeResourceDescription);
   void recv_registerComputeResource(std::string& _return);
   void getComputeResource( ::ComputeResourceDescription& _return, const std::string& computeResourceId);
   void send_getComputeResource(const std::string& computeResourceId);
   void recv_getComputeResource( ::ComputeResourceDescription& _return);
+  void getAllComputeResourceNames(std::map<std::string, std::string> & _return);
+  void send_getAllComputeResourceNames();
+  void recv_getAllComputeResourceNames(std::map<std::string, std::string> & _return);
   bool updateComputeResource(const std::string& computeResourceId, const  ::ComputeResourceDescription& computeResourceDescription);
   void send_updateComputeResource(const std::string& computeResourceId, const  ::ComputeResourceDescription& computeResourceDescription);
   bool recv_updateComputeResource();
@@ -9748,9 +10019,9 @@ class AiravataClient : virtual public AiravataIf {
   bool deleteDataMovementInterface(const std::string& dataMovementInterfaceId);
   void send_deleteDataMovementInterface(const std::string& dataMovementInterfaceId);
   bool recv_deleteDataMovementInterface();
-  void registerGatewayResourceProfile(std::string& _return, const  ::GatewayResourceProfile& gatewayResourceProfile);
+  bool registerGatewayResourceProfile(const  ::GatewayResourceProfile& gatewayResourceProfile);
   void send_registerGatewayResourceProfile(const  ::GatewayResourceProfile& gatewayResourceProfile);
-  void recv_registerGatewayResourceProfile(std::string& _return);
+  bool recv_registerGatewayResourceProfile();
   void getGatewayResourceProfile( ::GatewayResourceProfile& _return, const std::string& gatewayID);
   void send_getGatewayResourceProfile(const std::string& gatewayID);
   void recv_getGatewayResourceProfile( ::GatewayResourceProfile& _return);
@@ -9829,8 +10100,10 @@ class AiravataProcessor : public ::apache::thrift::TDispatchProcessor {
   void process_deleteApplicationInterface(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
   void process_getApplicationInputs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
   void process_getApplicationOutputs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_getAvailableAppInterfaceComputeResources(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
   void process_registerComputeResource(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
   void process_getComputeResource(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_getAllComputeResourceNames(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
   void process_updateComputeResource(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
   void process_deleteComputeResource(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
   void process_addLocalSubmissionDetails(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
@@ -9900,8 +10173,10 @@ class AiravataProcessor : public ::apache::thrift::TDispatchProcessor {
     processMap_["deleteApplicationInterface"] = &AiravataProcessor::process_deleteApplicationInterface;
     processMap_["getApplicationInputs"] = &AiravataProcessor::process_getApplicationInputs;
     processMap_["getApplicationOutputs"] = &AiravataProcessor::process_getApplicationOutputs;
+    processMap_["getAvailableAppInterfaceComputeResources"] = &AiravataProcessor::process_getAvailableAppInterfaceComputeResources;
     processMap_["registerComputeResource"] = &AiravataProcessor::process_registerComputeResource;
     processMap_["getComputeResource"] = &AiravataProcessor::process_getComputeResource;
+    processMap_["getAllComputeResourceNames"] = &AiravataProcessor::process_getAllComputeResourceNames;
     processMap_["updateComputeResource"] = &AiravataProcessor::process_updateComputeResource;
     processMap_["deleteComputeResource"] = &AiravataProcessor::process_deleteComputeResource;
     processMap_["addLocalSubmissionDetails"] = &AiravataProcessor::process_addLocalSubmissionDetails;
@@ -10334,6 +10609,16 @@ class AiravataMultiface : virtual public AiravataIf {
     return;
   }
 
+  void getAvailableAppInterfaceComputeResources(std::vector<std::string> & _return, const std::string& appInterfaceId) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->getAvailableAppInterfaceComputeResources(_return, appInterfaceId);
+    }
+    ifaces_[i]->getAvailableAppInterfaceComputeResources(_return, appInterfaceId);
+    return;
+  }
+
   void registerComputeResource(std::string& _return, const  ::ComputeResourceDescription& computeResourceDescription) {
     size_t sz = ifaces_.size();
     size_t i = 0;
@@ -10354,6 +10639,16 @@ class AiravataMultiface : virtual public AiravataIf {
     return;
   }
 
+  void getAllComputeResourceNames(std::map<std::string, std::string> & _return) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->getAllComputeResourceNames(_return);
+    }
+    ifaces_[i]->getAllComputeResourceNames(_return);
+    return;
+  }
+
   bool updateComputeResource(const std::string& computeResourceId, const  ::ComputeResourceDescription& computeResourceDescription) {
     size_t sz = ifaces_.size();
     size_t i = 0;
@@ -10516,14 +10811,13 @@ class AiravataMultiface : virtual public AiravataIf {
     return ifaces_[i]->deleteDataMovementInterface(dataMovementInterfaceId);
   }
 
-  void registerGatewayResourceProfile(std::string& _return, const  ::GatewayResourceProfile& gatewayResourceProfile) {
+  bool registerGatewayResourceProfile(const  ::GatewayResourceProfile& gatewayResourceProfile) {
     size_t sz = ifaces_.size();
     size_t i = 0;
     for (; i < (sz - 1); ++i) {
-      ifaces_[i]->registerGatewayResourceProfile(_return, gatewayResourceProfile);
+      ifaces_[i]->registerGatewayResourceProfile(gatewayResourceProfile);
     }
-    ifaces_[i]->registerGatewayResourceProfile(_return, gatewayResourceProfile);
-    return;
+    return ifaces_[i]->registerGatewayResourceProfile(gatewayResourceProfile);
   }
 
   void getGatewayResourceProfile( ::GatewayResourceProfile& _return, const std::string& gatewayID) {

http://git-wip-us.apache.org/repos/asf/airavata/blob/2d5d054b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/Airavata_server.skeleton.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/Airavata_server.skeleton.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/Airavata_server.skeleton.cpp
index 901402d..68b9e2a 100644
--- a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/Airavata_server.skeleton.cpp
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/Airavata_server.skeleton.cpp
@@ -217,6 +217,11 @@ class AiravataHandler : virtual public AiravataIf {
     printf("getApplicationOutputs\n");
   }
 
+  void getAvailableAppInterfaceComputeResources(std::vector<std::string> & _return, const std::string& appInterfaceId) {
+    // Your implementation goes here
+    printf("getAvailableAppInterfaceComputeResources\n");
+  }
+
   void registerComputeResource(std::string& _return, const  ::ComputeResourceDescription& computeResourceDescription) {
     // Your implementation goes here
     printf("registerComputeResource\n");
@@ -227,6 +232,11 @@ class AiravataHandler : virtual public AiravataIf {
     printf("getComputeResource\n");
   }
 
+  void getAllComputeResourceNames(std::map<std::string, std::string> & _return) {
+    // Your implementation goes here
+    printf("getAllComputeResourceNames\n");
+  }
+
   bool updateComputeResource(const std::string& computeResourceId, const  ::ComputeResourceDescription& computeResourceDescription) {
     // Your implementation goes here
     printf("updateComputeResource\n");
@@ -317,7 +327,7 @@ class AiravataHandler : virtual public AiravataIf {
     printf("deleteDataMovementInterface\n");
   }
 
-  void registerGatewayResourceProfile(std::string& _return, const  ::GatewayResourceProfile& gatewayResourceProfile) {
+  bool registerGatewayResourceProfile(const  ::GatewayResourceProfile& gatewayResourceProfile) {
     // Your implementation goes here
     printf("registerGatewayResourceProfile\n");
   }