airavata-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From scnakand...@apache.org
Subject [3/4] airavata git commit: fixing AIRAVATA-2185 : Add OWNER ResourcePermissionType to sharing API
Date Fri, 11 Nov 2016 17:24:13 GMT
http://git-wip-us.apache.org/repos/asf/airavata/blob/177a2484/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/Airavata.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/Airavata.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/Airavata.cpp
index 81134ea..b3eb101 100644
--- a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/Airavata.cpp
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/Airavata.cpp
@@ -11707,11 +11707,11 @@ uint32_t Airavata_getExperiment_presult::read(::apache::thrift::protocol::TProto
 }
 
 
-Airavata_getDetailedExperimentTree_args::~Airavata_getDetailedExperimentTree_args() throw() {
+Airavata_getExperimentByAdmin_args::~Airavata_getExperimentByAdmin_args() throw() {
 }
 
 
-uint32_t Airavata_getDetailedExperimentTree_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t Airavata_getExperimentByAdmin_args::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
@@ -11766,10 +11766,10 @@ uint32_t Airavata_getDetailedExperimentTree_args::read(::apache::thrift::protoco
   return xfer;
 }
 
-uint32_t Airavata_getDetailedExperimentTree_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t Airavata_getExperimentByAdmin_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
   apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("Airavata_getDetailedExperimentTree_args");
+  xfer += oprot->writeStructBegin("Airavata_getExperimentByAdmin_args");
 
   xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1);
   xfer += this->authzToken.write(oprot);
@@ -11785,14 +11785,14 @@ uint32_t Airavata_getDetailedExperimentTree_args::write(::apache::thrift::protoc
 }
 
 
-Airavata_getDetailedExperimentTree_pargs::~Airavata_getDetailedExperimentTree_pargs() throw() {
+Airavata_getExperimentByAdmin_pargs::~Airavata_getExperimentByAdmin_pargs() throw() {
 }
 
 
-uint32_t Airavata_getDetailedExperimentTree_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t Airavata_getExperimentByAdmin_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
   apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("Airavata_getDetailedExperimentTree_pargs");
+  xfer += oprot->writeStructBegin("Airavata_getExperimentByAdmin_pargs");
 
   xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1);
   xfer += (*(this->authzToken)).write(oprot);
@@ -11808,11 +11808,11 @@ uint32_t Airavata_getDetailedExperimentTree_pargs::write(::apache::thrift::proto
 }
 
 
-Airavata_getDetailedExperimentTree_result::~Airavata_getDetailedExperimentTree_result() throw() {
+Airavata_getExperimentByAdmin_result::~Airavata_getExperimentByAdmin_result() throw() {
 }
 
 
-uint32_t Airavata_getDetailedExperimentTree_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t Airavata_getExperimentByAdmin_result::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
@@ -11893,11 +11893,11 @@ uint32_t Airavata_getDetailedExperimentTree_result::read(::apache::thrift::proto
   return xfer;
 }
 
-uint32_t Airavata_getDetailedExperimentTree_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t Airavata_getExperimentByAdmin_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
 
   uint32_t xfer = 0;
 
-  xfer += oprot->writeStructBegin("Airavata_getDetailedExperimentTree_result");
+  xfer += oprot->writeStructBegin("Airavata_getExperimentByAdmin_result");
 
   if (this->__isset.success) {
     xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0);
@@ -11930,11 +11930,11 @@ uint32_t Airavata_getDetailedExperimentTree_result::write(::apache::thrift::prot
 }
 
 
-Airavata_getDetailedExperimentTree_presult::~Airavata_getDetailedExperimentTree_presult() throw() {
+Airavata_getExperimentByAdmin_presult::~Airavata_getExperimentByAdmin_presult() throw() {
 }
 
 
-uint32_t Airavata_getDetailedExperimentTree_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t Airavata_getExperimentByAdmin_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
@@ -12016,11 +12016,11 @@ uint32_t Airavata_getDetailedExperimentTree_presult::read(::apache::thrift::prot
 }
 
 
-Airavata_updateExperiment_args::~Airavata_updateExperiment_args() throw() {
+Airavata_getDetailedExperimentTree_args::~Airavata_getDetailedExperimentTree_args() throw() {
 }
 
 
-uint32_t Airavata_updateExperiment_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t Airavata_getDetailedExperimentTree_args::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
@@ -12034,7 +12034,6 @@ uint32_t Airavata_updateExperiment_args::read(::apache::thrift::protocol::TProto
 
   bool isset_authzToken = false;
   bool isset_airavataExperimentId = false;
-  bool isset_experiment = false;
 
   while (true)
   {
@@ -12060,14 +12059,6 @@ uint32_t Airavata_updateExperiment_args::read(::apache::thrift::protocol::TProto
           xfer += iprot->skip(ftype);
         }
         break;
-      case 3:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->experiment.read(iprot);
-          isset_experiment = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
       default:
         xfer += iprot->skip(ftype);
         break;
@@ -12081,15 +12072,13 @@ uint32_t Airavata_updateExperiment_args::read(::apache::thrift::protocol::TProto
     throw TProtocolException(TProtocolException::INVALID_DATA);
   if (!isset_airavataExperimentId)
     throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_experiment)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
   return xfer;
 }
 
-uint32_t Airavata_updateExperiment_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t Airavata_getDetailedExperimentTree_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
   apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("Airavata_updateExperiment_args");
+  xfer += oprot->writeStructBegin("Airavata_getDetailedExperimentTree_args");
 
   xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1);
   xfer += this->authzToken.write(oprot);
@@ -12099,24 +12088,20 @@ uint32_t Airavata_updateExperiment_args::write(::apache::thrift::protocol::TProt
   xfer += oprot->writeString(this->airavataExperimentId);
   xfer += oprot->writeFieldEnd();
 
-  xfer += oprot->writeFieldBegin("experiment", ::apache::thrift::protocol::T_STRUCT, 3);
-  xfer += this->experiment.write(oprot);
-  xfer += oprot->writeFieldEnd();
-
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
   return xfer;
 }
 
 
-Airavata_updateExperiment_pargs::~Airavata_updateExperiment_pargs() throw() {
+Airavata_getDetailedExperimentTree_pargs::~Airavata_getDetailedExperimentTree_pargs() throw() {
 }
 
 
-uint32_t Airavata_updateExperiment_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t Airavata_getDetailedExperimentTree_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
   apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("Airavata_updateExperiment_pargs");
+  xfer += oprot->writeStructBegin("Airavata_getDetailedExperimentTree_pargs");
 
   xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1);
   xfer += (*(this->authzToken)).write(oprot);
@@ -12126,21 +12111,17 @@ uint32_t Airavata_updateExperiment_pargs::write(::apache::thrift::protocol::TPro
   xfer += oprot->writeString((*(this->airavataExperimentId)));
   xfer += oprot->writeFieldEnd();
 
-  xfer += oprot->writeFieldBegin("experiment", ::apache::thrift::protocol::T_STRUCT, 3);
-  xfer += (*(this->experiment)).write(oprot);
-  xfer += oprot->writeFieldEnd();
-
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
   return xfer;
 }
 
 
-Airavata_updateExperiment_result::~Airavata_updateExperiment_result() throw() {
+Airavata_getDetailedExperimentTree_result::~Airavata_getDetailedExperimentTree_result() throw() {
 }
 
 
-uint32_t Airavata_updateExperiment_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t Airavata_getDetailedExperimentTree_result::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
@@ -12161,6 +12142,14 @@ uint32_t Airavata_updateExperiment_result::read(::apache::thrift::protocol::TPro
     }
     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);
@@ -12213,13 +12202,17 @@ uint32_t Airavata_updateExperiment_result::read(::apache::thrift::protocol::TPro
   return xfer;
 }
 
-uint32_t Airavata_updateExperiment_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t Airavata_getDetailedExperimentTree_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
 
   uint32_t xfer = 0;
 
-  xfer += oprot->writeStructBegin("Airavata_updateExperiment_result");
+  xfer += oprot->writeStructBegin("Airavata_getDetailedExperimentTree_result");
 
-  if (this->__isset.ire) {
+  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();
@@ -12246,209 +12239,525 @@ uint32_t Airavata_updateExperiment_result::write(::apache::thrift::protocol::TPr
 }
 
 
-Airavata_updateExperiment_presult::~Airavata_updateExperiment_presult() throw() {
-}
-
-
-uint32_t Airavata_updateExperiment_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  apache::thrift::protocol::TInputRecursionTracker tracker(*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 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->enf.read(iprot);
-          this->__isset.enf = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 3:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->ace.read(iprot);
-          this->__isset.ace = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 4:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->ase.read(iprot);
-          this->__isset.ase = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 5:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->ae.read(iprot);
-          this->__isset.ae = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      default:
-        xfer += iprot->skip(ftype);
-        break;
-    }
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  return xfer;
-}
-
-
-Airavata_updateExperimentConfiguration_args::~Airavata_updateExperimentConfiguration_args() throw() {
-}
-
-
-uint32_t Airavata_updateExperimentConfiguration_args::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  apache::thrift::protocol::TInputRecursionTracker tracker(*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_authzToken = false;
-  bool isset_airavataExperimentId = false;
-  bool isset_userConfiguration = 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_STRUCT) {
-          xfer += this->authzToken.read(iprot);
-          isset_authzToken = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 2:
-        if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readString(this->airavataExperimentId);
-          isset_airavataExperimentId = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 3:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->userConfiguration.read(iprot);
-          isset_userConfiguration = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      default:
-        xfer += iprot->skip(ftype);
-        break;
-    }
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  if (!isset_authzToken)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_airavataExperimentId)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_userConfiguration)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  return xfer;
-}
-
-uint32_t Airavata_updateExperimentConfiguration_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("Airavata_updateExperimentConfiguration_args");
-
-  xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1);
-  xfer += this->authzToken.write(oprot);
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("airavataExperimentId", ::apache::thrift::protocol::T_STRING, 2);
-  xfer += oprot->writeString(this->airavataExperimentId);
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("userConfiguration", ::apache::thrift::protocol::T_STRUCT, 3);
-  xfer += this->userConfiguration.write(oprot);
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-
-Airavata_updateExperimentConfiguration_pargs::~Airavata_updateExperimentConfiguration_pargs() throw() {
-}
-
-
-uint32_t Airavata_updateExperimentConfiguration_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
-  uint32_t xfer = 0;
-  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("Airavata_updateExperimentConfiguration_pargs");
-
-  xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1);
-  xfer += (*(this->authzToken)).write(oprot);
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("airavataExperimentId", ::apache::thrift::protocol::T_STRING, 2);
-  xfer += oprot->writeString((*(this->airavataExperimentId)));
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("userConfiguration", ::apache::thrift::protocol::T_STRUCT, 3);
-  xfer += (*(this->userConfiguration)).write(oprot);
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-
-Airavata_updateExperimentConfiguration_result::~Airavata_updateExperimentConfiguration_result() throw() {
+Airavata_getDetailedExperimentTree_presult::~Airavata_getDetailedExperimentTree_presult() throw() {
 }
 
 
-uint32_t Airavata_updateExperimentConfiguration_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t Airavata_getDetailedExperimentTree_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  apache::thrift::protocol::TInputRecursionTracker tracker(*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->enf.read(iprot);
+          this->__isset.enf = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ace.read(iprot);
+          this->__isset.ace = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ase.read(iprot);
+          this->__isset.ase = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 5:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ae.read(iprot);
+          this->__isset.ae = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+
+Airavata_updateExperiment_args::~Airavata_updateExperiment_args() throw() {
+}
+
+
+uint32_t Airavata_updateExperiment_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  apache::thrift::protocol::TInputRecursionTracker tracker(*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_authzToken = false;
+  bool isset_airavataExperimentId = false;
+  bool isset_experiment = 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_STRUCT) {
+          xfer += this->authzToken.read(iprot);
+          isset_authzToken = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->airavataExperimentId);
+          isset_airavataExperimentId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->experiment.read(iprot);
+          isset_experiment = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_authzToken)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_airavataExperimentId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_experiment)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t Airavata_updateExperiment_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("Airavata_updateExperiment_args");
+
+  xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1);
+  xfer += this->authzToken.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("airavataExperimentId", ::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeString(this->airavataExperimentId);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("experiment", ::apache::thrift::protocol::T_STRUCT, 3);
+  xfer += this->experiment.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+
+Airavata_updateExperiment_pargs::~Airavata_updateExperiment_pargs() throw() {
+}
+
+
+uint32_t Airavata_updateExperiment_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("Airavata_updateExperiment_pargs");
+
+  xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1);
+  xfer += (*(this->authzToken)).write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("airavataExperimentId", ::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeString((*(this->airavataExperimentId)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("experiment", ::apache::thrift::protocol::T_STRUCT, 3);
+  xfer += (*(this->experiment)).write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+
+Airavata_updateExperiment_result::~Airavata_updateExperiment_result() throw() {
+}
+
+
+uint32_t Airavata_updateExperiment_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  apache::thrift::protocol::TInputRecursionTracker tracker(*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 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->enf.read(iprot);
+          this->__isset.enf = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ace.read(iprot);
+          this->__isset.ace = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ase.read(iprot);
+          this->__isset.ase = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 5:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ae.read(iprot);
+          this->__isset.ae = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Airavata_updateExperiment_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("Airavata_updateExperiment_result");
+
+  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.enf) {
+    xfer += oprot->writeFieldBegin("enf", ::apache::thrift::protocol::T_STRUCT, 2);
+    xfer += this->enf.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ace) {
+    xfer += oprot->writeFieldBegin("ace", ::apache::thrift::protocol::T_STRUCT, 3);
+    xfer += this->ace.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ase) {
+    xfer += oprot->writeFieldBegin("ase", ::apache::thrift::protocol::T_STRUCT, 4);
+    xfer += this->ase.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ae) {
+    xfer += oprot->writeFieldBegin("ae", ::apache::thrift::protocol::T_STRUCT, 5);
+    xfer += this->ae.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+
+Airavata_updateExperiment_presult::~Airavata_updateExperiment_presult() throw() {
+}
+
+
+uint32_t Airavata_updateExperiment_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  apache::thrift::protocol::TInputRecursionTracker tracker(*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 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->enf.read(iprot);
+          this->__isset.enf = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ace.read(iprot);
+          this->__isset.ace = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ase.read(iprot);
+          this->__isset.ase = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 5:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ae.read(iprot);
+          this->__isset.ae = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+
+Airavata_updateExperimentConfiguration_args::~Airavata_updateExperimentConfiguration_args() throw() {
+}
+
+
+uint32_t Airavata_updateExperimentConfiguration_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  apache::thrift::protocol::TInputRecursionTracker tracker(*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_authzToken = false;
+  bool isset_airavataExperimentId = false;
+  bool isset_userConfiguration = 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_STRUCT) {
+          xfer += this->authzToken.read(iprot);
+          isset_authzToken = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->airavataExperimentId);
+          isset_airavataExperimentId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->userConfiguration.read(iprot);
+          isset_userConfiguration = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_authzToken)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_airavataExperimentId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_userConfiguration)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t Airavata_updateExperimentConfiguration_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("Airavata_updateExperimentConfiguration_args");
+
+  xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1);
+  xfer += this->authzToken.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("airavataExperimentId", ::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeString(this->airavataExperimentId);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("userConfiguration", ::apache::thrift::protocol::T_STRUCT, 3);
+  xfer += this->userConfiguration.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+
+Airavata_updateExperimentConfiguration_pargs::~Airavata_updateExperimentConfiguration_pargs() throw() {
+}
+
+
+uint32_t Airavata_updateExperimentConfiguration_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("Airavata_updateExperimentConfiguration_pargs");
+
+  xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1);
+  xfer += (*(this->authzToken)).write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("airavataExperimentId", ::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeString((*(this->airavataExperimentId)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("userConfiguration", ::apache::thrift::protocol::T_STRUCT, 3);
+  xfer += (*(this->userConfiguration)).write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+
+Airavata_updateExperimentConfiguration_result::~Airavata_updateExperimentConfiguration_result() throw() {
+}
+
+
+uint32_t Airavata_updateExperimentConfiguration_result::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
@@ -12699,67 +13008,376 @@ uint32_t Airavata_updateResourceScheduleing_result::read(::apache::thrift::proto
     {
       case 1:
         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->ae.read(iprot);
-          this->__isset.ae = true;
+          xfer += this->ae.read(iprot);
+          this->__isset.ae = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Airavata_updateResourceScheduleing_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("Airavata_updateResourceScheduleing_result");
+
+  if (this->__isset.ae) {
+    xfer += oprot->writeFieldBegin("ae", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->ae.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+
+Airavata_updateResourceScheduleing_presult::~Airavata_updateResourceScheduleing_presult() throw() {
+}
+
+
+uint32_t Airavata_updateResourceScheduleing_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  apache::thrift::protocol::TInputRecursionTracker tracker(*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 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ae.read(iprot);
+          this->__isset.ae = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+
+Airavata_validateExperiment_args::~Airavata_validateExperiment_args() throw() {
+}
+
+
+uint32_t Airavata_validateExperiment_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  apache::thrift::protocol::TInputRecursionTracker tracker(*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_authzToken = false;
+  bool isset_airavataExperimentId = 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_STRUCT) {
+          xfer += this->authzToken.read(iprot);
+          isset_authzToken = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->airavataExperimentId);
+          isset_airavataExperimentId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_authzToken)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_airavataExperimentId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t Airavata_validateExperiment_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("Airavata_validateExperiment_args");
+
+  xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1);
+  xfer += this->authzToken.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("airavataExperimentId", ::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeString(this->airavataExperimentId);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+
+Airavata_validateExperiment_pargs::~Airavata_validateExperiment_pargs() throw() {
+}
+
+
+uint32_t Airavata_validateExperiment_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("Airavata_validateExperiment_pargs");
+
+  xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1);
+  xfer += (*(this->authzToken)).write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("airavataExperimentId", ::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeString((*(this->airavataExperimentId)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+
+Airavata_validateExperiment_result::~Airavata_validateExperiment_result() throw() {
+}
+
+
+uint32_t Airavata_validateExperiment_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  apache::thrift::protocol::TInputRecursionTracker tracker(*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_BOOL) {
+          xfer += iprot->readBool(this->success);
+          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->enf.read(iprot);
+          this->__isset.enf = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ace.read(iprot);
+          this->__isset.ace = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ase.read(iprot);
+          this->__isset.ase = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 5:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ae.read(iprot);
+          this->__isset.ae = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Airavata_validateExperiment_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("Airavata_validateExperiment_result");
+
+  if (this->__isset.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);
+    xfer += this->ire.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.enf) {
+    xfer += oprot->writeFieldBegin("enf", ::apache::thrift::protocol::T_STRUCT, 2);
+    xfer += this->enf.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ace) {
+    xfer += oprot->writeFieldBegin("ace", ::apache::thrift::protocol::T_STRUCT, 3);
+    xfer += this->ace.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ase) {
+    xfer += oprot->writeFieldBegin("ase", ::apache::thrift::protocol::T_STRUCT, 4);
+    xfer += this->ase.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.ae) {
+    xfer += oprot->writeFieldBegin("ae", ::apache::thrift::protocol::T_STRUCT, 5);
+    xfer += this->ae.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+
+Airavata_validateExperiment_presult::~Airavata_validateExperiment_presult() throw() {
+}
+
+
+uint32_t Airavata_validateExperiment_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  apache::thrift::protocol::TInputRecursionTracker tracker(*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_BOOL) {
+          xfer += iprot->readBool((*(this->success)));
+          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;
-      default:
-        xfer += iprot->skip(ftype);
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->enf.read(iprot);
+          this->__isset.enf = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
         break;
-    }
-    xfer += iprot->readFieldEnd();
-  }
-
-  xfer += iprot->readStructEnd();
-
-  return xfer;
-}
-
-uint32_t Airavata_updateResourceScheduleing_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
-
-  uint32_t xfer = 0;
-
-  xfer += oprot->writeStructBegin("Airavata_updateResourceScheduleing_result");
-
-  if (this->__isset.ae) {
-    xfer += oprot->writeFieldBegin("ae", ::apache::thrift::protocol::T_STRUCT, 1);
-    xfer += this->ae.write(oprot);
-    xfer += oprot->writeFieldEnd();
-  }
-  xfer += oprot->writeFieldStop();
-  xfer += oprot->writeStructEnd();
-  return xfer;
-}
-
-
-Airavata_updateResourceScheduleing_presult::~Airavata_updateResourceScheduleing_presult() throw() {
-}
-
-
-uint32_t Airavata_updateResourceScheduleing_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
-
-  apache::thrift::protocol::TInputRecursionTracker tracker(*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 1:
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ace.read(iprot);
+          this->__isset.ace = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->ase.read(iprot);
+          this->__isset.ase = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 5:
         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
           xfer += this->ae.read(iprot);
           this->__isset.ae = true;
@@ -12780,11 +13398,11 @@ uint32_t Airavata_updateResourceScheduleing_presult::read(::apache::thrift::prot
 }
 
 
-Airavata_validateExperiment_args::~Airavata_validateExperiment_args() throw() {
+Airavata_launchExperiment_args::~Airavata_launchExperiment_args() throw() {
 }
 
 
-uint32_t Airavata_validateExperiment_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t Airavata_launchExperiment_args::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
@@ -12798,6 +13416,7 @@ uint32_t Airavata_validateExperiment_args::read(::apache::thrift::protocol::TPro
 
   bool isset_authzToken = false;
   bool isset_airavataExperimentId = false;
+  bool isset_gatewayId = false;
 
   while (true)
   {
@@ -12823,6 +13442,14 @@ uint32_t Airavata_validateExperiment_args::read(::apache::thrift::protocol::TPro
           xfer += iprot->skip(ftype);
         }
         break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->gatewayId);
+          isset_gatewayId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
       default:
         xfer += iprot->skip(ftype);
         break;
@@ -12836,13 +13463,15 @@ uint32_t Airavata_validateExperiment_args::read(::apache::thrift::protocol::TPro
     throw TProtocolException(TProtocolException::INVALID_DATA);
   if (!isset_airavataExperimentId)
     throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_gatewayId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
   return xfer;
 }
 
-uint32_t Airavata_validateExperiment_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t Airavata_launchExperiment_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
   apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("Airavata_validateExperiment_args");
+  xfer += oprot->writeStructBegin("Airavata_launchExperiment_args");
 
   xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1);
   xfer += this->authzToken.write(oprot);
@@ -12852,20 +13481,24 @@ uint32_t Airavata_validateExperiment_args::write(::apache::thrift::protocol::TPr
   xfer += oprot->writeString(this->airavataExperimentId);
   xfer += oprot->writeFieldEnd();
 
+  xfer += oprot->writeFieldBegin("gatewayId", ::apache::thrift::protocol::T_STRING, 3);
+  xfer += oprot->writeString(this->gatewayId);
+  xfer += oprot->writeFieldEnd();
+
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
   return xfer;
 }
 
 
-Airavata_validateExperiment_pargs::~Airavata_validateExperiment_pargs() throw() {
+Airavata_launchExperiment_pargs::~Airavata_launchExperiment_pargs() throw() {
 }
 
 
-uint32_t Airavata_validateExperiment_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t Airavata_launchExperiment_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
   apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("Airavata_validateExperiment_pargs");
+  xfer += oprot->writeStructBegin("Airavata_launchExperiment_pargs");
 
   xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1);
   xfer += (*(this->authzToken)).write(oprot);
@@ -12875,17 +13508,21 @@ uint32_t Airavata_validateExperiment_pargs::write(::apache::thrift::protocol::TP
   xfer += oprot->writeString((*(this->airavataExperimentId)));
   xfer += oprot->writeFieldEnd();
 
+  xfer += oprot->writeFieldBegin("gatewayId", ::apache::thrift::protocol::T_STRING, 3);
+  xfer += oprot->writeString((*(this->gatewayId)));
+  xfer += oprot->writeFieldEnd();
+
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
   return xfer;
 }
 
 
-Airavata_validateExperiment_result::~Airavata_validateExperiment_result() throw() {
+Airavata_launchExperiment_result::~Airavata_launchExperiment_result() throw() {
 }
 
 
-uint32_t Airavata_validateExperiment_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t Airavata_launchExperiment_result::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
@@ -12906,14 +13543,6 @@ uint32_t Airavata_validateExperiment_result::read(::apache::thrift::protocol::TP
     }
     switch (fid)
     {
-      case 0:
-        if (ftype == ::apache::thrift::protocol::T_BOOL) {
-          xfer += iprot->readBool(this->success);
-          this->__isset.success = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
       case 1:
         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
           xfer += this->ire.read(iprot);
@@ -12966,17 +13595,13 @@ uint32_t Airavata_validateExperiment_result::read(::apache::thrift::protocol::TP
   return xfer;
 }
 
-uint32_t Airavata_validateExperiment_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t Airavata_launchExperiment_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
 
   uint32_t xfer = 0;
 
-  xfer += oprot->writeStructBegin("Airavata_validateExperiment_result");
+  xfer += oprot->writeStructBegin("Airavata_launchExperiment_result");
 
-  if (this->__isset.success) {
-    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0);
-    xfer += oprot->writeBool(this->success);
-    xfer += oprot->writeFieldEnd();
-  } else if (this->__isset.ire) {
+  if (this->__isset.ire) {
     xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
     xfer += this->ire.write(oprot);
     xfer += oprot->writeFieldEnd();
@@ -13003,11 +13628,11 @@ uint32_t Airavata_validateExperiment_result::write(::apache::thrift::protocol::T
 }
 
 
-Airavata_validateExperiment_presult::~Airavata_validateExperiment_presult() throw() {
+Airavata_launchExperiment_presult::~Airavata_launchExperiment_presult() throw() {
 }
 
 
-uint32_t Airavata_validateExperiment_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t Airavata_launchExperiment_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
@@ -13028,14 +13653,6 @@ uint32_t Airavata_validateExperiment_presult::read(::apache::thrift::protocol::T
     }
     switch (fid)
     {
-      case 0:
-        if (ftype == ::apache::thrift::protocol::T_BOOL) {
-          xfer += iprot->readBool((*(this->success)));
-          this->__isset.success = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
       case 1:
         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
           xfer += this->ire.read(iprot);
@@ -13089,11 +13706,11 @@ uint32_t Airavata_validateExperiment_presult::read(::apache::thrift::protocol::T
 }
 
 
-Airavata_launchExperiment_args::~Airavata_launchExperiment_args() throw() {
+Airavata_getExperimentStatus_args::~Airavata_getExperimentStatus_args() throw() {
 }
 
 
-uint32_t Airavata_launchExperiment_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t Airavata_getExperimentStatus_args::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
@@ -13107,7 +13724,6 @@ uint32_t Airavata_launchExperiment_args::read(::apache::thrift::protocol::TProto
 
   bool isset_authzToken = false;
   bool isset_airavataExperimentId = false;
-  bool isset_gatewayId = false;
 
   while (true)
   {
@@ -13133,14 +13749,6 @@ uint32_t Airavata_launchExperiment_args::read(::apache::thrift::protocol::TProto
           xfer += iprot->skip(ftype);
         }
         break;
-      case 3:
-        if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readString(this->gatewayId);
-          isset_gatewayId = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
       default:
         xfer += iprot->skip(ftype);
         break;
@@ -13154,15 +13762,13 @@ uint32_t Airavata_launchExperiment_args::read(::apache::thrift::protocol::TProto
     throw TProtocolException(TProtocolException::INVALID_DATA);
   if (!isset_airavataExperimentId)
     throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_gatewayId)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
   return xfer;
 }
 
-uint32_t Airavata_launchExperiment_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t Airavata_getExperimentStatus_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
   apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("Airavata_launchExperiment_args");
+  xfer += oprot->writeStructBegin("Airavata_getExperimentStatus_args");
 
   xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1);
   xfer += this->authzToken.write(oprot);
@@ -13172,24 +13778,20 @@ uint32_t Airavata_launchExperiment_args::write(::apache::thrift::protocol::TProt
   xfer += oprot->writeString(this->airavataExperimentId);
   xfer += oprot->writeFieldEnd();
 
-  xfer += oprot->writeFieldBegin("gatewayId", ::apache::thrift::protocol::T_STRING, 3);
-  xfer += oprot->writeString(this->gatewayId);
-  xfer += oprot->writeFieldEnd();
-
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
   return xfer;
 }
 
 
-Airavata_launchExperiment_pargs::~Airavata_launchExperiment_pargs() throw() {
+Airavata_getExperimentStatus_pargs::~Airavata_getExperimentStatus_pargs() throw() {
 }
 
 
-uint32_t Airavata_launchExperiment_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t Airavata_getExperimentStatus_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
   apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("Airavata_launchExperiment_pargs");
+  xfer += oprot->writeStructBegin("Airavata_getExperimentStatus_pargs");
 
   xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1);
   xfer += (*(this->authzToken)).write(oprot);
@@ -13199,21 +13801,17 @@ uint32_t Airavata_launchExperiment_pargs::write(::apache::thrift::protocol::TPro
   xfer += oprot->writeString((*(this->airavataExperimentId)));
   xfer += oprot->writeFieldEnd();
 
-  xfer += oprot->writeFieldBegin("gatewayId", ::apache::thrift::protocol::T_STRING, 3);
-  xfer += oprot->writeString((*(this->gatewayId)));
-  xfer += oprot->writeFieldEnd();
-
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
   return xfer;
 }
 
 
-Airavata_launchExperiment_result::~Airavata_launchExperiment_result() throw() {
+Airavata_getExperimentStatus_result::~Airavata_getExperimentStatus_result() throw() {
 }
 
 
-uint32_t Airavata_launchExperiment_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t Airavata_getExperimentStatus_result::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
@@ -13234,6 +13832,14 @@ uint32_t Airavata_launchExperiment_result::read(::apache::thrift::protocol::TPro
     }
     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);
@@ -13286,13 +13892,17 @@ uint32_t Airavata_launchExperiment_result::read(::apache::thrift::protocol::TPro
   return xfer;
 }
 
-uint32_t Airavata_launchExperiment_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t Airavata_getExperimentStatus_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
 
   uint32_t xfer = 0;
 
-  xfer += oprot->writeStructBegin("Airavata_launchExperiment_result");
+  xfer += oprot->writeStructBegin("Airavata_getExperimentStatus_result");
 
-  if (this->__isset.ire) {
+  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();
@@ -13319,11 +13929,11 @@ uint32_t Airavata_launchExperiment_result::write(::apache::thrift::protocol::TPr
 }
 
 
-Airavata_launchExperiment_presult::~Airavata_launchExperiment_presult() throw() {
+Airavata_getExperimentStatus_presult::~Airavata_getExperimentStatus_presult() throw() {
 }
 
 
-uint32_t Airavata_launchExperiment_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t Airavata_getExperimentStatus_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
@@ -13344,6 +13954,14 @@ uint32_t Airavata_launchExperiment_presult::read(::apache::thrift::protocol::TPr
     }
     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);
@@ -13397,11 +14015,11 @@ uint32_t Airavata_launchExperiment_presult::read(::apache::thrift::protocol::TPr
 }
 
 
-Airavata_getExperimentStatus_args::~Airavata_getExperimentStatus_args() throw() {
+Airavata_getExperimentOutputs_args::~Airavata_getExperimentOutputs_args() throw() {
 }
 
 
-uint32_t Airavata_getExperimentStatus_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t Airavata_getExperimentOutputs_args::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
@@ -13456,10 +14074,10 @@ uint32_t Airavata_getExperimentStatus_args::read(::apache::thrift::protocol::TPr
   return xfer;
 }
 
-uint32_t Airavata_getExperimentStatus_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t Airavata_getExperimentOutputs_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
   apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("Airavata_getExperimentStatus_args");
+  xfer += oprot->writeStructBegin("Airavata_getExperimentOutputs_args");
 
   xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1);
   xfer += this->authzToken.write(oprot);
@@ -13475,14 +14093,14 @@ uint32_t Airavata_getExperimentStatus_args::write(::apache::thrift::protocol::TP
 }
 
 
-Airavata_getExperimentStatus_pargs::~Airavata_getExperimentStatus_pargs() throw() {
+Airavata_getExperimentOutputs_pargs::~Airavata_getExperimentOutputs_pargs() throw() {
 }
 
 
-uint32_t Airavata_getExperimentStatus_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t Airavata_getExperimentOutputs_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
   apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("Airavata_getExperimentStatus_pargs");
+  xfer += oprot->writeStructBegin("Airavata_getExperimentOutputs_pargs");
 
   xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1);
   xfer += (*(this->authzToken)).write(oprot);
@@ -13498,11 +14116,11 @@ uint32_t Airavata_getExperimentStatus_pargs::write(::apache::thrift::protocol::T
 }
 
 
-Airavata_getExperimentStatus_result::~Airavata_getExperimentStatus_result() throw() {
+Airavata_getExperimentOutputs_result::~Airavata_getExperimentOutputs_result() throw() {
 }
 
 
-uint32_t Airavata_getExperimentStatus_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t Airavata_getExperimentOutputs_result::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
@@ -13524,8 +14142,20 @@ uint32_t Airavata_getExperimentStatus_result::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_LIST) {
+          {
+            this->success.clear();
+            uint32_t _size160;
+            ::apache::thrift::protocol::TType _etype163;
+            xfer += iprot->readListBegin(_etype163, _size160);
+            this->success.resize(_size160);
+            uint32_t _i164;
+            for (_i164 = 0; _i164 < _size160; ++_i164)
+            {
+              xfer += this->success[_i164].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
           this->__isset.success = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -13583,15 +14213,23 @@ uint32_t Airavata_getExperimentStatus_result::read(::apache::thrift::protocol::T
   return xfer;
 }
 
-uint32_t Airavata_getExperimentStatus_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t Airavata_getExperimentOutputs_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
 
   uint32_t xfer = 0;
 
-  xfer += oprot->writeStructBegin("Airavata_getExperimentStatus_result");
+  xfer += oprot->writeStructBegin("Airavata_getExperimentOutputs_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_LIST, 0);
+    {
+      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
+      std::vector< ::apache::airavata::model::application::io::OutputDataObjectType> ::const_iterator _iter165;
+      for (_iter165 = this->success.begin(); _iter165 != this->success.end(); ++_iter165)
+      {
+        xfer += (*_iter165).write(oprot);
+      }
+      xfer += oprot->writeListEnd();
+    }
     xfer += oprot->writeFieldEnd();
   } else if (this->__isset.ire) {
     xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
@@ -13620,11 +14258,11 @@ uint32_t Airavata_getExperimentStatus_result::write(::apache::thrift::protocol::
 }
 
 
-Airavata_getExperimentStatus_presult::~Airavata_getExperimentStatus_presult() throw() {
+Airavata_getExperimentOutputs_presult::~Airavata_getExperimentOutputs_presult() throw() {
 }
 
 
-uint32_t Airavata_getExperimentStatus_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t Airavata_getExperimentOutputs_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
@@ -13646,8 +14284,20 @@ uint32_t Airavata_getExperimentStatus_presult::read(::apache::thrift::protocol::
     switch (fid)
     {
       case 0:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += (*(this->success)).read(iprot);
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            (*(this->success)).clear();
+            uint32_t _size166;
+            ::apache::thrift::protocol::TType _etype169;
+            xfer += iprot->readListBegin(_etype169, _size166);
+            (*(this->success)).resize(_size166);
+            uint32_t _i170;
+            for (_i170 = 0; _i170 < _size166; ++_i170)
+            {
+              xfer += (*(this->success))[_i170].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
           this->__isset.success = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -13706,11 +14356,11 @@ uint32_t Airavata_getExperimentStatus_presult::read(::apache::thrift::protocol::
 }
 
 
-Airavata_getExperimentOutputs_args::~Airavata_getExperimentOutputs_args() throw() {
+Airavata_getIntermediateOutputs_args::~Airavata_getIntermediateOutputs_args() throw() {
 }
 
 
-uint32_t Airavata_getExperimentOutputs_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t Airavata_getIntermediateOutputs_args::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
@@ -13765,10 +14415,10 @@ uint32_t Airavata_getExperimentOutputs_args::read(::apache::thrift::protocol::TP
   return xfer;
 }
 
-uint32_t Airavata_getExperimentOutputs_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t Airavata_getIntermediateOutputs_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
   apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("Airavata_getExperimentOutputs_args");
+  xfer += oprot->writeStructBegin("Airavata_getIntermediateOutputs_args");
 
   xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1);
   xfer += this->authzToken.write(oprot);
@@ -13784,14 +14434,14 @@ uint32_t Airavata_getExperimentOutputs_args::write(::apache::thrift::protocol::T
 }
 
 
-Airavata_getExperimentOutputs_pargs::~Airavata_getExperimentOutputs_pargs() throw() {
+Airavata_getIntermediateOutputs_pargs::~Airavata_getIntermediateOutputs_pargs() throw() {
 }
 
 
-uint32_t Airavata_getExperimentOutputs_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t Airavata_getIntermediateOutputs_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
   apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("Airavata_getExperimentOutputs_pargs");
+  xfer += oprot->writeStructBegin("Airavata_getIntermediateOutputs_pargs");
 
   xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1);
   xfer += (*(this->authzToken)).write(oprot);
@@ -13807,11 +14457,11 @@ uint32_t Airavata_getExperimentOutputs_pargs::write(::apache::thrift::protocol::
 }
 
 
-Airavata_getExperimentOutputs_result::~Airavata_getExperimentOutputs_result() throw() {
+Airavata_getIntermediateOutputs_result::~Airavata_getIntermediateOutputs_result() throw() {
 }
 
 
-uint32_t Airavata_getExperimentOutputs_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t Airavata_getIntermediateOutputs_result::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
@@ -13836,14 +14486,14 @@ uint32_t Airavata_getExperimentOutputs_result::read(::apache::thrift::protocol::
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->success.clear();
-            uint32_t _size160;
-            ::apache::thrift::protocol::TType _etype163;
-            xfer += iprot->readListBegin(_etype163, _size160);
-            this->success.resize(_size160);
-            uint32_t _i164;
-            for (_i164 = 0; _i164 < _size160; ++_i164)
+            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)
             {
-              xfer += this->success[_i164].read(iprot);
+              xfer += this->success[_i175].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -13904,20 +14554,20 @@ uint32_t Airavata_getExperimentOutputs_result::read(::apache::thrift::protocol::
   return xfer;
 }
 
-uint32_t Airavata_getExperimentOutputs_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t Airavata_getIntermediateOutputs_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
 
   uint32_t xfer = 0;
 
-  xfer += oprot->writeStructBegin("Airavata_getExperimentOutputs_result");
+  xfer += oprot->writeStructBegin("Airavata_getIntermediateOutputs_result");
 
   if (this->__isset.success) {
     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< ::apache::airavata::model::application::io::OutputDataObjectType> ::const_iterator _iter165;
-      for (_iter165 = this->success.begin(); _iter165 != this->success.end(); ++_iter165)
+      std::vector< ::apache::airavata::model::application::io::OutputDataObjectType> ::const_iterator _iter176;
+      for (_iter176 = this->success.begin(); _iter176 != this->success.end(); ++_iter176)
       {
-        xfer += (*_iter165).write(oprot);
+        xfer += (*_iter176).write(oprot);
       }
       xfer += oprot->writeListEnd();
     }
@@ -13949,11 +14599,11 @@ uint32_t Airavata_getExperimentOutputs_result::write(::apache::thrift::protocol:
 }
 
 
-Airavata_getExperimentOutputs_presult::~Airavata_getExperimentOutputs_presult() throw() {
+Airavata_getIntermediateOutputs_presult::~Airavata_getIntermediateOutputs_presult() throw() {
 }
 
 
-uint32_t Airavata_getExperimentOutputs_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t Airavata_getIntermediateOutputs_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
@@ -13978,14 +14628,14 @@ uint32_t Airavata_getExperimentOutputs_presult::read(::apache::thrift::protocol:
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             (*(this->success)).clear();
-            uint32_t _size166;
-            ::apache::thrift::protocol::TType _etype169;
-            xfer += iprot->readListBegin(_etype169, _size166);
-            (*(this->success)).resize(_size166);
-            uint32_t _i170;
-            for (_i170 = 0; _i170 < _size166; ++_i170)
+            uint32_t _size177;
+            ::apache::thrift::protocol::TType _etype180;
+            xfer += iprot->readListBegin(_etype180, _size177);
+            (*(this->success)).resize(_size177);
+            uint32_t _i181;
+            for (_i181 = 0; _i181 < _size177; ++_i181)
             {
-              xfer += (*(this->success))[_i170].read(iprot);
+              xfer += (*(this->success))[_i181].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -14047,11 +14697,11 @@ uint32_t Airavata_getExperimentOutputs_presult::read(::apache::thrift::protocol:
 }
 
 
-Airavata_getIntermediateOutputs_args::~Airavata_getIntermediateOutputs_args() throw() {
+Airavata_getJobStatuses_args::~Airavata_getJobStatuses_args() throw() {
 }
 
 
-uint32_t Airavata_getIntermediateOutputs_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t Airavata_getJobStatuses_args::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
@@ -14106,10 +14756,10 @@ uint32_t Airavata_getIntermediateOutputs_args::read(::apache::thrift::protocol::
   return xfer;
 }
 
-uint32_t Airavata_getIntermediateOutputs_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t Airavata_getJobStatuses_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
   apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("Airavata_getIntermediateOutputs_args");
+  xfer += oprot->writeStructBegin("Airavata_getJobStatuses_args");
 
   xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1);
   xfer += this->authzToken.write(oprot);
@@ -14125,14 +14775,14 @@ uint32_t Airavata_getIntermediateOutputs_args::write(::apache::thrift::protocol:
 }
 
 
-Airavata_getIntermediateOutputs_pargs::~Airavata_getIntermediateOutputs_pargs() throw() {
+Airavata_getJobStatuses_pargs::~Airavata_getJobStatuses_pargs() throw() {
 }
 
 
-uint32_t Airavata_getIntermediateOutputs_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t Airavata_getJobStatuses_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
   apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("Airavata_getIntermediateOutputs_pargs");
+  xfer += oprot->writeStructBegin("Airavata_getJobStatuses_pargs");
 
   xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1);
   xfer += (*(this->authzToken)).write(oprot);
@@ -14148,11 +14798,11 @@ uint32_t Airavata_getIntermediateOutputs_pargs::write(::apache::thrift::protocol
 }
 
 
-Airavata_getIntermediateOutputs_result::~Airavata_getIntermediateOutputs_result() throw() {
+Airavata_getJobStatuses_result::~Airavata_getJobStatuses_result() throw() {
 }
 
 
-uint32_t Airavata_getIntermediateOutputs_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t Airavata_getJobStatuses_result::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
@@ -14174,19 +14824,22 @@ uint32_t Airavata_getIntermediateOutputs_result::read(::apache::thrift::protocol
     switch (fid)
     {
       case 0:
-        if (ftype == ::apache::thrift::protocol::T_LIST) {
+        if (ftype == ::apache::thrift::protocol::T_MAP) {
           {
             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 _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)
             {
-              xfer += this->success[_i175].read(iprot);
+              std::string _key187;
+              xfer += iprot->readString(_key187);
+               ::apache::airavata::model::status::JobStatus& _val188 = this->success[_key187];
+              xfer += _val188.read(iprot);
             }
-            xfer += iprot->readListEnd();
+            xfer += iprot->readMapEnd();
           }
           this->__isset.success = true;
         } else {
@@ -14245,22 +14898,23 @@ uint32_t Airavata_getIntermediateOutputs_result::read(::apache::thrift::protocol
   return xfer;
 }
 
-uint32_t Airavata_getIntermediateOutputs_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t Airavata_getJobStatuses_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
 
   uint32_t xfer = 0;
 
-  xfer += oprot->writeStructBegin("Airavata_getIntermediateOutputs_result");
+  xfer += oprot->writeStructBegin("Airavata_getJobStatuses_result");
 
   if (this->__isset.success) {
-    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_MAP, 0);
     {
-      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
-      std::vector< ::apache::airavata::model::application::io::OutputDataObjectType> ::const_iterator _iter176;
-      for (_iter176 = this->success.begin(); _iter176 != this->success.end(); ++_iter176)
+      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
+      std::map<std::string,  ::apache::airavata::model::status::JobStatus> ::const_iterator _iter189;
+      for (_iter189 = this->success.begin(); _iter189 != this->success.end(); ++_iter189)
       {
-        xfer += (*_iter176).write(oprot);
+        xfer += oprot->writeString(_iter189->first);
+        xfer += _iter189->second.write(oprot);
       }
-      xfer += oprot->writeListEnd();
+      xfer += oprot->writeMapEnd();
     }
     xfer += oprot->writeFieldEnd();
   } else if (this->__isset.ire) {
@@ -14290,11 +14944,11 @@ uint32_t Airavata_getIntermediateOutputs_result::write(::apache::thrift::protoco
 }
 
 
-Airavata_getIntermediateOutputs_presult::~Airavata_getIntermediateOutputs_presult() throw() {
+Airavata_getJobStatuses_presult::~Airavata_getJobStatuses_presult() throw() {
 }
 
 
-uint32_t Airavata_getIntermediateOutputs_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t Airavata_getJobStatuses_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
@@ -14316,19 +14970,22 @@ uint32_t Airavata_getIntermediateOutputs_presult::read(::apache::thrift::protoco
     switch (fid)
     {
       case 0:
-        if (ftype == ::apache::thrift::protocol::T_LIST) {
+        if (ftype == ::apache::thrift::protocol::T_MAP) {
           {
             (*(this->success)).clear();
-            uint32_t _size177;
-            ::apache::thrift::protocol::TType _etype180;
-            xfer += iprot->readListBegin(_etype180, _size177);
-            (*(this->success)).resize(_size177);
-            uint32_t _i181;
-            for (_i181 = 0; _i181 < _size177; ++_i181)
+            uint32_t _size190;
+            ::apache::thrift::protocol::TType _ktype191;
+            ::apache::thrift::protocol::TType _vtype192;
+            xfer += iprot->readMapBegin(_ktype191, _vtype192, _size190);
+            uint32_t _i194;
+            for (_i194 = 0; _i194 < _size190; ++_i194)
             {
-              xfer += (*(this->success))[_i181].read(iprot);
+              std::string _key195;
+              xfer += iprot->readString(_key195);
+               ::apache::airavata::model::status::JobStatus& _val196 = (*(this->success))[_key195];
+              xfer += _val196.read(iprot);
             }
-            xfer += iprot->readListEnd();
+            xfer += iprot->readMapEnd();
           }
           this->__isset.success = true;
         } else {
@@ -14388,11 +15045,11 @@ uint32_t Airavata_getIntermediateOutputs_presult::read(::apache::thrift::protoco
 }
 
 
-Airavata_getJobStatuses_args::~Airavata_getJobStatuses_args() throw() {
+Airavata_getJobDetails_args::~Airavata_getJobDetails_args() throw() {
 }
 
 
-uint32_t Airavata_getJobStatuses_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t Airavata_getJobDetails_args::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
@@ -14447,10 +15104,10 @@ uint32_t Airavata_getJobStatuses_args::read(::apache::thrift::protocol::TProtoco
   return xfer;
 }
 
-uint32_t Airavata_getJobStatuses_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t Airavata_getJobDetails_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
   apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("Airavata_getJobStatuses_args");
+  xfer += oprot->writeStructBegin("Airavata_getJobDetails_args");
 
   xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1);
   xfer += this->authzToken.write(oprot);
@@ -14466,14 +15123,14 @@ uint32_t Airavata_getJobStatuses_args::write(::apache::thrift::protocol::TProtoc
 }
 
 
-Airavata_getJobStatuses_pargs::~Airavata_getJobStatuses_pargs() throw() {
+Airavata_getJobDetails_pargs::~Airavata_getJobDetails_pargs() throw() {
 }
 
 
-uint32_t Airavata_getJobStatuses_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t Airavata_getJobDetails_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
   apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("Airavata_getJobStatuses_pargs");
+  xfer += oprot->writeStructBegin("Airavata_getJobDetails_pargs");
 
   xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1);
   xfer += (*(this->authzToken)).write(oprot);
@@ -14489,11 +15146,11 @@ uint32_t Airavata_getJobStatuses_pargs::write(::apache::thrift::protocol::TProto
 }
 
 
-Airavata_getJobStatuses_result::~Airavata_getJobStatuses_result() throw() {
+Airavata_getJobDetails_result::~Airavata_getJobDetails_result() throw() {
 }
 
 
-uint32_t Airavata_getJobStatuses_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t Airavata_getJobDetails_result::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
@@ -14515,22 +15172,19 @@ uint32_t Airavata_getJobStatuses_result::read(::apache::thrift::protocol::TProto
     switch (fid)
     {
       case 0:
-        if (ftype == ::apache::thrift::protocol::T_MAP) {
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->success.clear();
-            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)
+            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)
             {
-              std::string _key187;
-              xfer += iprot->readString(_key187);
-               ::apache::airavata::model::status::JobStatus& _val188 = this->success[_key187];
-              xfer += _val188.read(iprot);
+              xfer += this->success[_i201].read(iprot);
             }
-            xfer += iprot->readMapEnd();
+            xfer += iprot->readListEnd();
           }
           this->__isset.success = true;
         } else {
@@ -14589,23 +15243,22 @@ uint32_t Airavata_getJobStatuses_result::read(::apache::thrift::protocol::TProto
   return xfer;
 }
 
-uint32_t Airavata_getJobStatuses_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t Airavata_getJobDetails_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
 
   uint32_t xfer = 0;
 
-  xfer += oprot->writeStructBegin("Airavata_getJobStatuses_result");
+  xfer += oprot->writeStructBegin("Airavata_getJobDetails_result");
 
   if (this->__isset.success) {
-    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_MAP, 0);
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
     {
-      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
-      std::map<std::string,  ::apache::airavata::model::status::JobStatus> ::const_iterator _iter189;
-      for (_iter189 = this->success.begin(); _iter189 != this->success.end(); ++_iter189)
+      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
+      std::vector< ::apache::airavata::model::job::JobModel> ::const_iterator _iter202;
+      for (_iter202 = this->success.begin(); _iter202 != this->success.end(); ++_iter202)
       {
-        xfer += oprot->writeString(_iter189->first);
-        xfer += _iter189->second.write(oprot);
+        xfer += (*_iter202).write(oprot);
       }
-      xfer += oprot->writeMapEnd();
+      xfer += oprot->writeListEnd();
     }
     xfer += oprot->writeFieldEnd();
   } else if (this->__isset.ire) {
@@ -14635,11 +15288,11 @@ uint32_t Airavata_getJobStatuses_result::write(::apache::thrift::protocol::TProt
 }
 
 
-Airavata_getJobStatuses_presult::~Airavata_getJobStatuses_presult() throw() {
+Airavata_getJobDetails_presult::~Airavata_getJobDetails_presult() throw() {
 }
 
 
-uint32_t Airavata_getJobStatuses_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t Airavata_getJobDetails_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
@@ -14661,22 +15314,19 @@ uint32_t Airavata_getJobStatuses_presult::read(::apache::thrift::protocol::TProt
     switch (fid)
     {
       case 0:
-        if (ftype == ::apache::thrift::protocol::T_MAP) {
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             (*(this->success)).clear();
-            uint32_t _size190;
-            ::apache::thrift::protocol::TType _ktype191;
-            ::apache::thrift::protocol::TType _vtype192;
-            xfer += iprot->readMapBegin(_ktype191, _vtype192, _size190);
-            uint32_t _i194;
-            for (_i194 = 0; _i194 < _size190; ++_i194)
+            uint32_t _size203;
+            ::apache::thrift::protocol::TType _etype206;
+            xfer += iprot->readListBegin(_etype206, _size203);
+            (*(this->success)).resize(_size203);
+            uint32_t _i207;
+            for (_i207 = 0; _i207 < _size203; ++_i207)
             {
-              std::string _key195;
-              xfer += iprot->readString(_key195);
-               ::apache::airavata::model::status::JobStatus& _val196 = (*(this->success))[_key195];
-              xfer += _val196.read(iprot);
+              xfer += (*(this->success))[_i207].read(iprot);
             }
-            xfer += iprot->readMapEnd();
+            xfer += iprot->readListEnd();
           }
           this->__isset.success = true;
         } else {
@@ -14736,11 +15386,11 @@ uint32_t Airavata_getJobStatuses_presult::read(::apache::thrift::protocol::TProt
 }
 
 
-Airavata_getJobDetails_args::~Airavata_getJobDetails_args() throw() {
+Airavata_cloneExperiment_args::~Airavata_cloneExperiment_args() throw() {
 }
 
 
-uint32_t Airavata_getJobDetails_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t Airavata_cloneExperiment_args::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
@@ -14753,7 +15403,6 @@ uint32_t Airavata_getJobDetails_args::read(::apache::thrift::protocol::TProtocol
   using ::apache::thrift::protocol::TProtocolException;
 
   bool isset_authzToken = false;
-  bool isset_airavataExperimentId = false;
 
   while (true)
   {
@@ -14773,8 +15422,24 @@ uint32_t Airavata_getJobDetails_args::read(::apache::thrift::protocol::TProtocol
         break;
       case 2:
         if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readString(this->airavataExperimentId);
-          isset_airavataExperimentId = true;
+          xfer += iprot->readString(this->existingExperimentID);
+          this->__isset.existingExperimentID = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftyp

<TRUNCATED>

Mime
View raw message