airavata-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sma...@apache.org
Subject [3/6] Updating the thrift files documenttaion - AIRAVATA-1228
Date Sun, 06 Jul 2014 03:04:23 GMT
http://git-wip-us.apache.org/repos/asf/airavata/blob/08245f25/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 05a61a8..9a056a0 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,18 +9277,1137 @@ uint32_t Airavata_getApplicationOutputs_presult::read(::apache::thrift::protocol
   return xfer;
 }
 
+uint32_t Airavata_registerComputeResource_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_computeResourceDescription = 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->computeResourceDescription.read(iprot);
+          isset_computeResourceDescription = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_computeResourceDescription)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t Airavata_registerComputeResource_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Airavata_registerComputeResource_args");
+
+  xfer += oprot->writeFieldBegin("computeResourceDescription", ::apache::thrift::protocol::T_STRUCT, 1);
+  xfer += this->computeResourceDescription.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Airavata_registerComputeResource_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Airavata_registerComputeResource_pargs");
+
+  xfer += oprot->writeFieldBegin("computeResourceDescription", ::apache::thrift::protocol::T_STRUCT, 1);
+  xfer += (*(this->computeResourceDescription)).write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Airavata_registerComputeResource_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_STRING) {
+          xfer += iprot->readString(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->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_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("Airavata_registerComputeResource_result");
+
+  if (this->__isset.success) {
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRING, 0);
+    xfer += oprot->writeString(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.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_registerComputeResource_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_STRING) {
+          xfer += iprot->readString((*(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->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_getComputeResource_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_computeResourceId = 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->computeResourceId);
+          isset_computeResourceId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_computeResourceId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t Airavata_getComputeResource_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Airavata_getComputeResource_args");
+
+  xfer += oprot->writeFieldBegin("computeResourceId", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->computeResourceId);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Airavata_getComputeResource_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Airavata_getComputeResource_pargs");
+
+  xfer += oprot->writeFieldBegin("computeResourceId", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString((*(this->computeResourceId)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Airavata_getComputeResource_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_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_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_updateComputeResource_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_computeResourceId = false;
+  bool isset_computeResourceDescription = 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->computeResourceId);
+          isset_computeResourceId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->computeResourceDescription.read(iprot);
+          isset_computeResourceDescription = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_computeResourceId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_computeResourceDescription)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t Airavata_updateComputeResource_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Airavata_updateComputeResource_args");
+
+  xfer += oprot->writeFieldBegin("computeResourceId", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->computeResourceId);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("computeResourceDescription", ::apache::thrift::protocol::T_STRUCT, 2);
+  xfer += this->computeResourceDescription.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Airavata_updateComputeResource_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Airavata_updateComputeResource_pargs");
+
+  xfer += oprot->writeFieldBegin("computeResourceId", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString((*(this->computeResourceId)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("computeResourceDescription", ::apache::thrift::protocol::T_STRUCT, 2);
+  xfer += (*(this->computeResourceDescription)).write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Airavata_updateComputeResource_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_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->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_updateComputeResource_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("Airavata_updateComputeResource_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.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_updateComputeResource_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_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->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_deleteComputeResource_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_computeResourceId = 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->computeResourceId);
+          isset_computeResourceId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_computeResourceId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t Airavata_deleteComputeResource_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Airavata_deleteComputeResource_args");
+
+  xfer += oprot->writeFieldBegin("computeResourceId", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->computeResourceId);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Airavata_deleteComputeResource_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("Airavata_deleteComputeResource_pargs");
+
+  xfer += oprot->writeFieldBegin("computeResourceId", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString((*(this->computeResourceId)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t Airavata_deleteComputeResource_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_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->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_deleteComputeResource_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("Airavata_deleteComputeResource_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.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_deleteComputeResource_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_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->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;
+}
+
 void AiravataClient::getAPIVersion(std::string& _return)
 {
-  send_getAPIVersion();
-  recv_getAPIVersion(_return);
+  send_getAPIVersion();
+  recv_getAPIVersion(_return);
+}
+
+void AiravataClient::send_getAPIVersion()
+{
+  int32_t cseqid = 0;
+  oprot_->writeMessageBegin("getAPIVersion", ::apache::thrift::protocol::T_CALL, cseqid);
+
+  Airavata_getAPIVersion_pargs args;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+}
+
+void AiravataClient::recv_getAPIVersion(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("getAPIVersion") != 0) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  Airavata_getAPIVersion_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, "getAPIVersion failed: unknown result");
+}
+
+void AiravataClient::createProject(std::string& _return, const  ::Project& project)
+{
+  send_createProject(project);
+  recv_createProject(_return);
+}
+
+void AiravataClient::send_createProject(const  ::Project& project)
+{
+  int32_t cseqid = 0;
+  oprot_->writeMessageBegin("createProject", ::apache::thrift::protocol::T_CALL, cseqid);
+
+  Airavata_createProject_pargs args;
+  args.project = &project;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+}
+
+void AiravataClient::recv_createProject(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("createProject") != 0) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  Airavata_createProject_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, "createProject failed: unknown result");
+}
+
+void AiravataClient::updateProject(const std::string& projectId, const  ::Project& updatedProject)
+{
+  send_updateProject(projectId, updatedProject);
+  recv_updateProject();
+}
+
+void AiravataClient::send_updateProject(const std::string& projectId, const  ::Project& updatedProject)
+{
+  int32_t cseqid = 0;
+  oprot_->writeMessageBegin("updateProject", ::apache::thrift::protocol::T_CALL, cseqid);
+
+  Airavata_updateProject_pargs args;
+  args.projectId = &projectId;
+  args.updatedProject = &updatedProject;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+}
+
+void AiravataClient::recv_updateProject()
+{
+
+  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("updateProject") != 0) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  Airavata_updateProject_presult result;
+  result.read(iprot_);
+  iprot_->readMessageEnd();
+  iprot_->getTransport()->readEnd();
+
+  if (result.__isset.ire) {
+    throw result.ire;
+  }
+  if (result.__isset.ace) {
+    throw result.ace;
+  }
+  if (result.__isset.ase) {
+    throw result.ase;
+  }
+  if (result.__isset.pnfe) {
+    throw result.pnfe;
+  }
+  return;
+}
+
+void AiravataClient::getProject( ::Project& _return, const std::string& projectId)
+{
+  send_getProject(projectId);
+  recv_getProject(_return);
 }
 
-void AiravataClient::send_getAPIVersion()
+void AiravataClient::send_getProject(const std::string& projectId)
 {
   int32_t cseqid = 0;
-  oprot_->writeMessageBegin("getAPIVersion", ::apache::thrift::protocol::T_CALL, cseqid);
+  oprot_->writeMessageBegin("getProject", ::apache::thrift::protocol::T_CALL, cseqid);
 
-  Airavata_getAPIVersion_pargs args;
+  Airavata_getProject_pargs args;
+  args.projectId = &projectId;
   args.write(oprot_);
 
   oprot_->writeMessageEnd();
@@ -9296,7 +10415,7 @@ void AiravataClient::send_getAPIVersion()
   oprot_->getTransport()->flush();
 }
 
-void AiravataClient::recv_getAPIVersion(std::string& _return)
+void AiravataClient::recv_getProject( ::Project& _return)
 {
 
   int32_t rseqid = 0;
@@ -9316,12 +10435,12 @@ void AiravataClient::recv_getAPIVersion(std::string& _return)
     iprot_->readMessageEnd();
     iprot_->getTransport()->readEnd();
   }
-  if (fname.compare("getAPIVersion") != 0) {
+  if (fname.compare("getProject") != 0) {
     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
     iprot_->readMessageEnd();
     iprot_->getTransport()->readEnd();
   }
-  Airavata_getAPIVersion_presult result;
+  Airavata_getProject_presult result;
   result.success = &_return;
   result.read(iprot_);
   iprot_->readMessageEnd();
@@ -9340,22 +10459,25 @@ void AiravataClient::recv_getAPIVersion(std::string& _return)
   if (result.__isset.ase) {
     throw result.ase;
   }
-  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getAPIVersion failed: unknown result");
+  if (result.__isset.pnfe) {
+    throw result.pnfe;
+  }
+  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getProject failed: unknown result");
 }
 
-void AiravataClient::createProject(std::string& _return, const  ::Project& project)
+void AiravataClient::getAllUserProjects(std::vector< ::Project> & _return, const std::string& userName)
 {
-  send_createProject(project);
-  recv_createProject(_return);
+  send_getAllUserProjects(userName);
+  recv_getAllUserProjects(_return);
 }
 
-void AiravataClient::send_createProject(const  ::Project& project)
+void AiravataClient::send_getAllUserProjects(const std::string& userName)
 {
   int32_t cseqid = 0;
-  oprot_->writeMessageBegin("createProject", ::apache::thrift::protocol::T_CALL, cseqid);
+  oprot_->writeMessageBegin("getAllUserProjects", ::apache::thrift::protocol::T_CALL, cseqid);
 
-  Airavata_createProject_pargs args;
-  args.project = &project;
+  Airavata_getAllUserProjects_pargs args;
+  args.userName = &userName;
   args.write(oprot_);
 
   oprot_->writeMessageEnd();
@@ -9363,7 +10485,7 @@ void AiravataClient::send_createProject(const  ::Project& project)
   oprot_->getTransport()->flush();
 }
 
-void AiravataClient::recv_createProject(std::string& _return)
+void AiravataClient::recv_getAllUserProjects(std::vector< ::Project> & _return)
 {
 
   int32_t rseqid = 0;
@@ -9383,12 +10505,12 @@ void AiravataClient::recv_createProject(std::string& _return)
     iprot_->readMessageEnd();
     iprot_->getTransport()->readEnd();
   }
-  if (fname.compare("createProject") != 0) {
+  if (fname.compare("getAllUserProjects") != 0) {
     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
     iprot_->readMessageEnd();
     iprot_->getTransport()->readEnd();
   }
-  Airavata_createProject_presult result;
+  Airavata_getAllUserProjects_presult result;
   result.success = &_return;
   result.read(iprot_);
   iprot_->readMessageEnd();
@@ -9407,23 +10529,23 @@ void AiravataClient::recv_createProject(std::string& _return)
   if (result.__isset.ase) {
     throw result.ase;
   }
-  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "createProject failed: unknown result");
+  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getAllUserProjects failed: unknown result");
 }
 
-void AiravataClient::updateProject(const std::string& projectId, const  ::Project& updatedProject)
+void AiravataClient::searchProjectsByProjectName(std::vector< ::Project> & _return, const std::string& userName, const std::string& projectName)
 {
-  send_updateProject(projectId, updatedProject);
-  recv_updateProject();
+  send_searchProjectsByProjectName(userName, projectName);
+  recv_searchProjectsByProjectName(_return);
 }
 
-void AiravataClient::send_updateProject(const std::string& projectId, const  ::Project& updatedProject)
+void AiravataClient::send_searchProjectsByProjectName(const std::string& userName, const std::string& projectName)
 {
   int32_t cseqid = 0;
-  oprot_->writeMessageBegin("updateProject", ::apache::thrift::protocol::T_CALL, cseqid);
+  oprot_->writeMessageBegin("searchProjectsByProjectName", ::apache::thrift::protocol::T_CALL, cseqid);
 
-  Airavata_updateProject_pargs args;
-  args.projectId = &projectId;
-  args.updatedProject = &updatedProject;
+  Airavata_searchProjectsByProjectName_pargs args;
+  args.userName = &userName;
+  args.projectName = &projectName;
   args.write(oprot_);
 
   oprot_->writeMessageEnd();
@@ -9431,7 +10553,7 @@ void AiravataClient::send_updateProject(const std::string& projectId, const  ::P
   oprot_->getTransport()->flush();
 }
 
-void AiravataClient::recv_updateProject()
+void AiravataClient::recv_searchProjectsByProjectName(std::vector< ::Project> & _return)
 {
 
   int32_t rseqid = 0;
@@ -9451,16 +10573,21 @@ void AiravataClient::recv_updateProject()
     iprot_->readMessageEnd();
     iprot_->getTransport()->readEnd();
   }
-  if (fname.compare("updateProject") != 0) {
+  if (fname.compare("searchProjectsByProjectName") != 0) {
     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
     iprot_->readMessageEnd();
     iprot_->getTransport()->readEnd();
   }
-  Airavata_updateProject_presult result;
+  Airavata_searchProjectsByProjectName_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;
   }
@@ -9470,25 +10597,23 @@ void AiravataClient::recv_updateProject()
   if (result.__isset.ase) {
     throw result.ase;
   }
-  if (result.__isset.pnfe) {
-    throw result.pnfe;
-  }
-  return;
+  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "searchProjectsByProjectName failed: unknown result");
 }
 
-void AiravataClient::getProject( ::Project& _return, const std::string& projectId)
+void AiravataClient::searchProjectsByProjectDesc(std::vector< ::Project> & _return, const std::string& userName, const std::string& description)
 {
-  send_getProject(projectId);
-  recv_getProject(_return);
+  send_searchProjectsByProjectDesc(userName, description);
+  recv_searchProjectsByProjectDesc(_return);
 }
 
-void AiravataClient::send_getProject(const std::string& projectId)
+void AiravataClient::send_searchProjectsByProjectDesc(const std::string& userName, const std::string& description)
 {
   int32_t cseqid = 0;
-  oprot_->writeMessageBegin("getProject", ::apache::thrift::protocol::T_CALL, cseqid);
+  oprot_->writeMessageBegin("searchProjectsByProjectDesc", ::apache::thrift::protocol::T_CALL, cseqid);
 
-  Airavata_getProject_pargs args;
-  args.projectId = &projectId;
+  Airavata_searchProjectsByProjectDesc_pargs args;
+  args.userName = &userName;
+  args.description = &description;
   args.write(oprot_);
 
   oprot_->writeMessageEnd();
@@ -9496,7 +10621,7 @@ void AiravataClient::send_getProject(const std::string& projectId)
   oprot_->getTransport()->flush();
 }
 
-void AiravataClient::recv_getProject( ::Project& _return)
+void AiravataClient::recv_searchProjectsByProjectDesc(std::vector< ::Project> & _return)
 {
 
   int32_t rseqid = 0;
@@ -9516,12 +10641,12 @@ void AiravataClient::recv_getProject( ::Project& _return)
     iprot_->readMessageEnd();
     iprot_->getTransport()->readEnd();
   }
-  if (fname.compare("getProject") != 0) {
+  if (fname.compare("searchProjectsByProjectDesc") != 0) {
     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
     iprot_->readMessageEnd();
     iprot_->getTransport()->readEnd();
   }
-  Airavata_getProject_presult result;
+  Airavata_searchProjectsByProjectDesc_presult result;
   result.success = &_return;
   result.read(iprot_);
   iprot_->readMessageEnd();
@@ -9540,25 +10665,23 @@ void AiravataClient::recv_getProject( ::Project& _return)
   if (result.__isset.ase) {
     throw result.ase;
   }
-  if (result.__isset.pnfe) {
-    throw result.pnfe;
-  }
-  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getProject failed: unknown result");
+  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "searchProjectsByProjectDesc failed: unknown result");
 }
 
-void AiravataClient::getAllUserProjects(std::vector< ::Project> & _return, const std::string& userName)
+void AiravataClient::searchExperimentsByName(std::vector< ::ExperimentSummary> & _return, const std::string& userName, const std::string& expName)
 {
-  send_getAllUserProjects(userName);
-  recv_getAllUserProjects(_return);
+  send_searchExperimentsByName(userName, expName);
+  recv_searchExperimentsByName(_return);
 }
 
-void AiravataClient::send_getAllUserProjects(const std::string& userName)
+void AiravataClient::send_searchExperimentsByName(const std::string& userName, const std::string& expName)
 {
   int32_t cseqid = 0;
-  oprot_->writeMessageBegin("getAllUserProjects", ::apache::thrift::protocol::T_CALL, cseqid);
+  oprot_->writeMessageBegin("searchExperimentsByName", ::apache::thrift::protocol::T_CALL, cseqid);
 
-  Airavata_getAllUserProjects_pargs args;
+  Airavata_searchExperimentsByName_pargs args;
   args.userName = &userName;
+  args.expName = &expName;
   args.write(oprot_);
 
   oprot_->writeMessageEnd();
@@ -9566,7 +10689,7 @@ void AiravataClient::send_getAllUserProjects(const std::string& userName)
   oprot_->getTransport()->flush();
 }
 
-void AiravataClient::recv_getAllUserProjects(std::vector< ::Project> & _return)
+void AiravataClient::recv_searchExperimentsByName(std::vector< ::ExperimentSummary> & _return)
 {
 
   int32_t rseqid = 0;
@@ -9586,12 +10709,12 @@ void AiravataClient::recv_getAllUserProjects(std::vector< ::Project> & _return)
     iprot_->readMessageEnd();
     iprot_->getTransport()->readEnd();
   }
-  if (fname.compare("getAllUserProjects") != 0) {
+  if (fname.compare("searchExperimentsByName") != 0) {
     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
     iprot_->readMessageEnd();
     iprot_->getTransport()->readEnd();
   }
-  Airavata_getAllUserProjects_presult result;
+  Airavata_searchExperimentsByName_presult result;
   result.success = &_return;
   result.read(iprot_);
   iprot_->readMessageEnd();
@@ -9610,23 +10733,23 @@ void AiravataClient::recv_getAllUserProjects(std::vector< ::Project> & _return)
   if (result.__isset.ase) {
     throw result.ase;
   }
-  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getAllUserProjects failed: unknown result");
+  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "searchExperimentsByName failed: unknown result");
 }
 
-void AiravataClient::searchProjectsByProjectName(std::vector< ::Project> & _return, const std::string& userName, const std::string& projectName)
+void AiravataClient::searchExperimentsByDesc(std::vector< ::ExperimentSummary> & _return, const std::string& userName, const std::string& description)
 {
-  send_searchProjectsByProjectName(userName, projectName);
-  recv_searchProjectsByProjectName(_return);
+  send_searchExperimentsByDesc(userName, description);
+  recv_searchExperimentsByDesc(_return);
 }
 
-void AiravataClient::send_searchProjectsByProjectName(const std::string& userName, const std::string& projectName)
+void AiravataClient::send_searchExperimentsByDesc(const std::string& userName, const std::string& description)
 {
   int32_t cseqid = 0;
-  oprot_->writeMessageBegin("searchProjectsByProjectName", ::apache::thrift::protocol::T_CALL, cseqid);
+  oprot_->writeMessageBegin("searchExperimentsByDesc", ::apache::thrift::protocol::T_CALL, cseqid);
 
-  Airavata_searchProjectsByProjectName_pargs args;
+  Airavata_searchExperimentsByDesc_pargs args;
   args.userName = &userName;
-  args.projectName = &projectName;
+  args.description = &description;
   args.write(oprot_);
 
   oprot_->writeMessageEnd();
@@ -9634,7 +10757,7 @@ void AiravataClient::send_searchProjectsByProjectName(const std::string& userNam
   oprot_->getTransport()->flush();
 }
 
-void AiravataClient::recv_searchProjectsByProjectName(std::vector< ::Project> & _return)
+void AiravataClient::recv_searchExperimentsByDesc(std::vector< ::ExperimentSummary> & _return)
 {
 
   int32_t rseqid = 0;
@@ -9654,12 +10777,12 @@ void AiravataClient::recv_searchProjectsByProjectName(std::vector< ::Project> &
     iprot_->readMessageEnd();
     iprot_->getTransport()->readEnd();
   }
-  if (fname.compare("searchProjectsByProjectName") != 0) {
+  if (fname.compare("searchExperimentsByDesc") != 0) {
     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
     iprot_->readMessageEnd();
     iprot_->getTransport()->readEnd();
   }
-  Airavata_searchProjectsByProjectName_presult result;
+  Airavata_searchExperimentsByDesc_presult result;
   result.success = &_return;
   result.read(iprot_);
   iprot_->readMessageEnd();
@@ -9678,23 +10801,23 @@ void AiravataClient::recv_searchProjectsByProjectName(std::vector< ::Project> &
   if (result.__isset.ase) {
     throw result.ase;
   }
-  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "searchProjectsByProjectName failed: unknown result");
+  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "searchExperimentsByDesc failed: unknown result");
 }
 
-void AiravataClient::searchProjectsByProjectDesc(std::vector< ::Project> & _return, const std::string& userName, const std::string& description)
+void AiravataClient::searchExperimentsByApplication(std::vector< ::ExperimentSummary> & _return, const std::string& userName, const std::string& applicationId)
 {
-  send_searchProjectsByProjectDesc(userName, description);
-  recv_searchProjectsByProjectDesc(_return);
+  send_searchExperimentsByApplication(userName, applicationId);
+  recv_searchExperimentsByApplication(_return);
 }
 
-void AiravataClient::send_searchProjectsByProjectDesc(const std::string& userName, const std::string& description)
+void AiravataClient::send_searchExperimentsByApplication(const std::string& userName, const std::string& applicationId)
 {
   int32_t cseqid = 0;
-  oprot_->writeMessageBegin("searchProjectsByProjectDesc", ::apache::thrift::protocol::T_CALL, cseqid);
+  oprot_->writeMessageBegin("searchExperimentsByApplication", ::apache::thrift::protocol::T_CALL, cseqid);
 
-  Airavata_searchProjectsByProjectDesc_pargs args;
+  Airavata_searchExperimentsByApplication_pargs args;
   args.userName = &userName;
-  args.description = &description;
+  args.applicationId = &applicationId;
   args.write(oprot_);
 
   oprot_->writeMessageEnd();
@@ -9702,7 +10825,7 @@ void AiravataClient::send_searchProjectsByProjectDesc(const std::string& userNam
   oprot_->getTransport()->flush();
 }
 
-void AiravataClient::recv_searchProjectsByProjectDesc(std::vector< ::Project> & _return)
+void AiravataClient::recv_searchExperimentsByApplication(std::vector< ::ExperimentSummary> & _return)
 {
 
   int32_t rseqid = 0;
@@ -9722,12 +10845,12 @@ void AiravataClient::recv_searchProjectsByProjectDesc(std::vector< ::Project> &
     iprot_->readMessageEnd();
     iprot_->getTransport()->readEnd();
   }
-  if (fname.compare("searchProjectsByProjectDesc") != 0) {
+  if (fname.compare("searchExperimentsByApplication") != 0) {
     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
     iprot_->readMessageEnd();
     iprot_->getTransport()->readEnd();
   }
-  Airavata_searchProjectsByProjectDesc_presult result;
+  Airavata_searchExperimentsByApplication_presult result;
   result.success = &_return;
   result.read(iprot_);
   iprot_->readMessageEnd();
@@ -9746,23 +10869,92 @@ void AiravataClient::recv_searchProjectsByProjectDesc(std::vector< ::Project> &
   if (result.__isset.ase) {
     throw result.ase;
   }
-  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "searchProjectsByProjectDesc failed: unknown result");
+  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "searchExperimentsByApplication failed: unknown result");
 }
 
-void AiravataClient::searchExperimentsByName(std::vector< ::ExperimentSummary> & _return, const std::string& userName, const std::string& expName)
+void AiravataClient::getAllExperimentsInProject(std::vector< ::Experiment> & _return, const std::string& projectId)
 {
-  send_searchExperimentsByName(userName, expName);
-  recv_searchExperimentsByName(_return);
+  send_getAllExperimentsInProject(projectId);
+  recv_getAllExperimentsInProject(_return);
 }
 
-void AiravataClient::send_searchExperimentsByName(const std::string& userName, const std::string& expName)
+void AiravataClient::send_getAllExperimentsInProject(const std::string& projectId)
+{
+  int32_t cseqid = 0;
+  oprot_->writeMessageBegin("getAllExperimentsInProject", ::apache::thrift::protocol::T_CALL, cseqid);
+
+  Airavata_getAllExperimentsInProject_pargs args;
+  args.projectId = &projectId;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+}
+
+void AiravataClient::recv_getAllExperimentsInProject(std::vector< ::Experiment> & _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("getAllExperimentsInProject") != 0) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  Airavata_getAllExperimentsInProject_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;
+  }
+  if (result.__isset.pnfe) {
+    throw result.pnfe;
+  }
+  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getAllExperimentsInProject failed: unknown result");
+}
+
+void AiravataClient::getAllUserExperiments(std::vector< ::Experiment> & _return, const std::string& userName)
+{
+  send_getAllUserExperiments(userName);
+  recv_getAllUserExperiments(_return);
+}
+
+void AiravataClient::send_getAllUserExperiments(const std::string& userName)
 {
   int32_t cseqid = 0;
-  oprot_->writeMessageBegin("searchExperimentsByName", ::apache::thrift::protocol::T_CALL, cseqid);
+  oprot_->writeMessageBegin("getAllUserExperiments", ::apache::thrift::protocol::T_CALL, cseqid);
 
-  Airavata_searchExperimentsByName_pargs args;
+  Airavata_getAllUserExperiments_pargs args;
   args.userName = &userName;
-  args.expName = &expName;
   args.write(oprot_);
 
   oprot_->writeMessageEnd();
@@ -9770,7 +10962,7 @@ void AiravataClient::send_searchExperimentsByName(const std::string& userName, c
   oprot_->getTransport()->flush();
 }
 
-void AiravataClient::recv_searchExperimentsByName(std::vector< ::ExperimentSummary> & _return)
+void AiravataClient::recv_getAllUserExperiments(std::vector< ::Experiment> & _return)
 {
 
   int32_t rseqid = 0;
@@ -9790,12 +10982,12 @@ void AiravataClient::recv_searchExperimentsByName(std::vector< ::ExperimentSumma
     iprot_->readMessageEnd();
     iprot_->getTransport()->readEnd();
   }
-  if (fname.compare("searchExperimentsByName") != 0) {
+  if (fname.compare("getAllUserExperiments") != 0) {
     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
     iprot_->readMessageEnd();
     iprot_->getTransport()->readEnd();
   }
-  Airavata_searchExperimentsByName_presult result;
+  Airavata_getAllUserExperiments_presult result;
   result.success = &_return;
   result.read(iprot_);
   iprot_->readMessageEnd();
@@ -9814,23 +11006,22 @@ void AiravataClient::recv_searchExperimentsByName(std::vector< ::ExperimentSumma
   if (result.__isset.ase) {
     throw result.ase;
   }
-  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "searchExperimentsByName failed: unknown result");
+  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getAllUserExperiments failed: unknown result");
 }
 
-void AiravataClient::searchExperimentsByDesc(std::vector< ::ExperimentSummary> & _return, const std::string& userName, const std::string& description)
+void AiravataClient::createExperiment(std::string& _return, const  ::Experiment& experiment)
 {
-  send_searchExperimentsByDesc(userName, description);
-  recv_searchExperimentsByDesc(_return);
+  send_createExperiment(experiment);
+  recv_createExperiment(_return);
 }
 
-void AiravataClient::send_searchExperimentsByDesc(const std::string& userName, const std::string& description)
+void AiravataClient::send_createExperiment(const  ::Experiment& experiment)
 {
   int32_t cseqid = 0;
-  oprot_->writeMessageBegin("searchExperimentsByDesc", ::apache::thrift::protocol::T_CALL, cseqid);
+  oprot_->writeMessageBegin("createExperiment", ::apache::thrift::protocol::T_CALL, cseqid);
 
-  Airavata_searchExperimentsByDesc_pargs args;
-  args.userName = &userName;
-  args.description = &description;
+  Airavata_createExperiment_pargs args;
+  args.experiment = &experiment;
   args.write(oprot_);
 
   oprot_->writeMessageEnd();
@@ -9838,7 +11029,7 @@ void AiravataClient::send_searchExperimentsByDesc(const std::string& userName, c
   oprot_->getTransport()->flush();
 }
 
-void AiravataClient::recv_searchExperimentsByDesc(std::vector< ::ExperimentSummary> & _return)
+void AiravataClient::recv_createExperiment(std::string& _return)
 {
 
   int32_t rseqid = 0;
@@ -9858,12 +11049,12 @@ void AiravataClient::recv_searchExperimentsByDesc(std::vector< ::ExperimentSumma
     iprot_->readMessageEnd();
     iprot_->getTransport()->readEnd();
   }
-  if (fname.compare("searchExperimentsByDesc") != 0) {
+  if (fname.compare("createExperiment") != 0) {
     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
     iprot_->readMessageEnd();
     iprot_->getTransport()->readEnd();
   }
-  Airavata_searchExperimentsByDesc_presult result;
+  Airavata_createExperiment_presult result;
   result.success = &_return;
   result.read(iprot_);
   iprot_->readMessageEnd();
@@ -9882,23 +11073,22 @@ void AiravataClient::recv_searchExperimentsByDesc(std::vector< ::ExperimentSumma
   if (result.__isset.ase) {
     throw result.ase;
   }
-  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "searchExperimentsByDesc failed: unknown result");
+  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "createExperiment failed: unknown result");
 }
 
-void AiravataClient::searchExperimentsByApplication(std::vector< ::ExperimentSummary> & _return, const std::string& userName, const std::string& applicationId)
+void AiravataClient::getExperiment( ::Experiment& _return, const std::string& airavataExperimentId)
 {
-  send_searchExperimentsByApplication(userName, applicationId);
-  recv_searchExperimentsByApplication(_return);
+  send_getExperiment(airavataExperimentId);
+  recv_getExperiment(_return);
 }
 
-void AiravataClient::send_searchExperimentsByApplication(const std::string& userName, const std::string& applicationId)
+void AiravataClient::send_getExperiment(const std::string& airavataExperimentId)
 {
   int32_t cseqid = 0;
-  oprot_->writeMessageBegin("searchExperimentsByApplication", ::apache::thrift::protocol::T_CALL, cseqid);
+  oprot_->writeMessageBegin("getExperiment", ::apache::thrift::protocol::T_CALL, cseqid);
 
-  Airavata_searchExperimentsByApplication_pargs args;
-  args.userName = &userName;
-  args.applicationId = &applicationId;
+  Airavata_getExperiment_pargs args;
+  args.airavataExperimentId = &airavataExperimentId;
   args.write(oprot_);
 
   oprot_->writeMessageEnd();
@@ -9906,7 +11096,7 @@ void AiravataClient::send_searchExperimentsByApplication(const std::string& user
   oprot_->getTransport()->flush();
 }
 
-void AiravataClient::recv_searchExperimentsByApplication(std::vector< ::ExperimentSummary> & _return)
+void AiravataClient::recv_getExperiment( ::Experiment& _return)
 {
 
   int32_t rseqid = 0;
@@ -9926,12 +11116,12 @@ void AiravataClient::recv_searchExperimentsByApplication(std::vector< ::Experime
     iprot_->readMessageEnd();
     iprot_->getTransport()->readEnd();
   }
-  if (fname.compare("searchExperimentsByApplication") != 0) {
+  if (fname.compare("getExperiment") != 0) {
     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
     iprot_->readMessageEnd();
     iprot_->getTransport()->readEnd();
   }
-  Airavata_searchExperimentsByApplication_presult result;
+  Airavata_getExperiment_presult result;
   result.success = &_return;
   result.read(iprot_);
   iprot_->readMessageEnd();
@@ -9944,28 +11134,32 @@ void AiravataClient::recv_searchExperimentsByApplication(std::vector< ::Experime
   if (result.__isset.ire) {
     throw result.ire;
   }
+  if (result.__isset.enf) {
+    throw result.enf;
+  }
   if (result.__isset.ace) {
     throw result.ace;
   }
   if (result.__isset.ase) {
     throw result.ase;
   }
-  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "searchExperimentsByApplication failed: unknown result");
+  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getExperiment failed: unknown result");
 }
 
-void AiravataClient::getAllExperimentsInProject(std::vector< ::Experiment> & _return, const std::string& projectId)
+void AiravataClient::updateExperiment(const std::string& airavataExperimentId, const  ::Experiment& experiment)
 {
-  send_getAllExperimentsInProject(projectId);
-  recv_getAllExperimentsInProject(_return);
+  send_updateExperiment(airavataExperimentId, experiment);
+  recv_updateExperiment();
 }
 
-void AiravataClient::send_getAllExperimentsInProject(const std::string& projectId)
+void AiravataClient::send_updateExperiment(const std::string& airavataExperimentId, const  ::Experiment& experiment)
 {
   int32_t cseqid = 0;
-  oprot_->writeMessageBegin("getAllExperimentsInProject", ::apache::thrift::protocol::T_CALL, cseqid);
+  oprot_->writeMessageBegin("updateExperiment", ::apache::thrift::protocol::T_CALL, cseqid);
 
-  Airavata_getAllExperimentsInProject_pargs args;
-  args.projectId = &projectId;
+  Airavata_updateExperiment_pargs args;
+  args.airavataExperimentId = &airavataExperimentId;
+  args.experiment = &experiment;
   args.write(oprot_);
 
   oprot_->writeMessageEnd();
@@ -9973,7 +11167,7 @@ void AiravataClient::send_getAllExperimentsInProject(const std::string& projectI
   oprot_->getTransport()->flush();
 }
 
-void AiravataClient::recv_getAllExperimentsInProject(std::vector< ::Experiment> & _return)
+void AiravataClient::recv_updateExperiment()
 {
 
   int32_t rseqid = 0;
@@ -9993,49 +11187,45 @@ void AiravataClient::recv_getAllExperimentsInProject(std::vector< ::Experiment>
     iprot_->readMessageEnd();
     iprot_->getTransport()->readEnd();
   }
-  if (fname.compare("getAllExperimentsInProject") != 0) {
+  if (fname.compare("updateExperiment") != 0) {
     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
     iprot_->readMessageEnd();
     iprot_->getTransport()->readEnd();
   }
-  Airavata_getAllExperimentsInProject_presult result;
-  result.success = &_return;
+  Airavata_updateExperiment_presult result;
   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.enf) {
+    throw result.enf;
+  }
   if (result.__isset.ace) {
     throw result.ace;
   }
   if (result.__isset.ase) {
     throw result.ase;
   }
-  if (result.__isset.pnfe) {
-    throw result.pnfe;
-  }
-  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getAllExperimentsInProject failed: unknown result");
+  return;
 }
 
-void AiravataClient::getAllUserExperiments(std::vector< ::Experiment> & _return, const std::string& userName)
+void AiravataClient::updateExperimentConfiguration(const std::string& airavataExperimentId, const  ::UserConfigurationData& userConfiguration)
 {
-  send_getAllUserExperiments(userName);
-  recv_getAllUserExperiments(_return);
+  send_updateExperimentConfiguration(airavataExperimentId, userConfiguration);
+  recv_updateExperimentConfiguration();
 }
 
-void AiravataClient::send_getAllUserExperiments(const std::string& userName)
+void AiravataClient::send_updateExperimentConfiguration(const std::string& airavataExperimentId, const  ::UserConfigurationData& userConfiguration)
 {
   int32_t cseqid = 0;
-  oprot_->writeMessageBegin("getAllUserExperiments", ::apache::thrift::protocol::T_CALL, cseqid);
+  oprot_->writeMessageBegin("updateExperimentConfiguration", ::apache::thrift::protocol::T_CALL, cseqid);
 
-  Airavata_getAllUserExperiments_pargs args;
-  args.userName = &userName;
+  Airavata_updateExperimentConfiguration_pargs args;
+  args.airavataExperimentId = &airavataExperimentId;
+  args.userConfiguration = &userConfiguration;
   args.write(oprot_);
 
   oprot_->writeMessageEnd();
@@ -10043,7 +11233,7 @@ void AiravataClient::send_getAllUserExperiments(const std::string& userName)
   oprot_->getTransport()->flush();
 }
 
-void AiravataClient::recv_getAllUserExperiments(std::vector< ::Experiment> & _return)
+void AiravataClient::recv_updateExperimentConfiguration()
 {
 
   int32_t rseqid = 0;
@@ -10063,46 +11253,33 @@ void AiravataClient::recv_getAllUserExperiments(std::vector< ::Experiment> & _re
     iprot_->readMessageEnd();
     iprot_->getTransport()->readEnd();
   }
-  if (fname.compare("getAllUserExperiments") != 0) {
+  if (fname.compare("updateExperimentConfiguration") != 0) {
     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
     iprot_->readMessageEnd();
     iprot_->getTransport()->readEnd();
   }
-  Airavata_getAllUserExperiments_presult result;
-  result.success = &_return;
+  Airavata_updateExperimentConfiguration_presult result;
   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, "getAllUserExperiments failed: unknown result");
+  return;
 }
 
-void AiravataClient::createExperiment(std::string& _return, const  ::Experiment& experiment)
+void AiravataClient::updateResourceScheduleing(const std::string& airavataExperimentId, const  ::ComputationalResourceScheduling& resourceScheduling)
 {
-  send_createExperiment(experiment);
-  recv_createExperiment(_return);
+  send_updateResourceScheduleing(airavataExperimentId, resourceScheduling);
+  recv_updateResourceScheduleing();
 }
 
-void AiravataClient::send_createExperiment(const  ::Experiment& experiment)
+void AiravataClient::send_updateResourceScheduleing(const std::string& airavataExperimentId, const  ::ComputationalResourceScheduling& resourceScheduling)
 {
   int32_t cseqid = 0;
-  oprot_->writeMessageBegin("createExperiment", ::apache::thrift::protocol::T_CALL, cseqid);
+  oprot_->writeMessageBegin("updateResourceScheduleing", ::apache::thrift::protocol::T_CALL, cseqid);
 
-  Airavata_createExperiment_pargs args;
-  args.experiment = &experiment;
+  Airavata_updateResourceScheduleing_pargs args;
+  args.airavataExperimentId = &airavataExperimentId;
+  args.resourceScheduling = &resourceScheduling;
   args.write(oprot_);
 
   oprot_->writeMessageEnd();
@@ -10110,7 +11287,7 @@ void AiravataClient::send_createExperiment(const  ::Experiment& experiment)
   oprot_->getTransport()->flush();
 }
 
-void AiravataClient::recv_createExperiment(std::string& _return)
+void AiravataClient::recv_updateResourceScheduleing()
 {
 
   int32_t rseqid = 0;
@@ -10130,45 +11307,31 @@ void AiravataClient::recv_createExperiment(std::string& _return)
     iprot_->readMessageEnd();
     iprot_->getTransport()->readEnd();
   }
-  if (fname.compare("createExperiment") != 0) {
+  if (fname.compare("updateResourceScheduleing") != 0) {
     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
     iprot_->readMessageEnd();
     iprot_->getTransport()->readEnd();
   }
-  Airavata_createExperiment_presult result;
-  result.success = &_return;
+  Airavata_updateResourceScheduleing_presult result;
   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, "createExperiment failed: unknown result");
+  return;
 }
 
-void AiravataClient::getExperiment( ::Experiment& _return, const std::string& airavataExperimentId)
+bool AiravataClient::validateExperiment(const std::string& airavataExperimentId)
 {
-  send_getExperiment(airavataExperimentId);
-  recv_getExperiment(_return);
+  send_validateExperiment(airavataExperimentId);
+  return recv_validateExperiment();
 }
 
-void AiravataClient::send_getExperiment(const std::string& airavataExperimentId)
+void AiravataClient::send_validateExperiment(const std::string& airavataExperimentId)
 {
   int32_t cseqid = 0;
-  oprot_->writeMessageBegin("getExperiment", ::apache::thrift::protocol::T_CALL, cseqid);
+  oprot_->writeMessageBegin("validateExperiment", ::apache::thrift::protocol::T_CALL, cseqid);
 
-  Airavata_getExperiment_pargs args;
+  Airavata_validateExperiment_pargs args;
   args.airavataExperimentId = &airavataExperimentId;
   args.write(oprot_);
 
@@ -10177,7 +11340,7 @@ void AiravataClient::send_getExperiment(const std::string& airavataExperimentId)
   oprot_->getTransport()->flush();
 }
 
-void AiravataClient::recv_getExperiment( ::Experiment& _return)
+bool AiravataClient::recv_validateExperiment()
 {
 
   int32_t rseqid = 0;
@@ -10197,20 +11360,20 @@ void AiravataClient::recv_getExperiment( ::Experiment& _return)
     iprot_->readMessageEnd();
     iprot_->getTransport()->readEnd();
   }
-  if (fname.compare("getExperiment") != 0) {
+  if (fname.compare("validateExperiment") != 0) {
     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
     iprot_->readMessageEnd();
     iprot_->getTransport()->readEnd();
   }
-  Airavata_getExperiment_presult result;
+  bool _return;
+  Airavata_validateExperiment_presult result;
   result.success = &_return;
   result.read(iprot_);
   iprot_->readMessageEnd();
   iprot_->getTransport()->readEnd();
 
   if (result.__isset.success) {
-    // _return pointer has now been filled
-    return;
+    return _return;
   }
   if (result.__isset.ire) {
     throw result.ire;
@@ -10224,23 +11387,23 @@ void AiravataClient::recv_getExperiment( ::Experiment& _return)
   if (result.__isset.ase) {
     throw result.ase;
   }
-  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getExperiment failed: unknown result");
+  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "validateExperiment failed: unknown result");
 }
 
-void AiravataClient::updateExperiment(const std::string& airavataExperimentId, const  ::Experiment& experiment)
+void AiravataClient::launchExperiment(const std::string& airavataExperimentId, const std::string& airavataCredStoreToken)
 {
-  send_updateExperiment(airavataExperimentId, experiment);
-  recv_updateExperiment();
+  send_launchExperiment(airavataExperimentId, airavataCredStoreToken);
+  recv_launchExperiment();
 }
 
-void AiravataClient::send_updateExperiment(const std::string& airavataExperimentId, const  ::Experiment& experiment)
+void AiravataClient::send_launchExperiment(const std::string& airavataExperimentId, const std::string& airavataCredStoreToken)
 {
   int32_t cseqid = 0;
-  oprot_->writeMessageBegin("updateExperiment", ::apache::thrift::protocol::T_CALL, cseqid);
+  oprot_->writeMessageBegin("launchExperiment", ::apache::thrift::protocol::T_CALL, cseqid);
 
-  Airavata_updateExperiment_pargs args;
+  Airavata_launchExperiment_pargs args;
   args.airavataExperimentId = &airavataExperimentId;
-  args.experiment = &experiment;
+  args.airavataCredStoreToken = &airavataCredStoreToken;
   args.write(oprot_);
 
   oprot_->writeMessageEnd();
@@ -10248,7 +11411,7 @@ void AiravataClient::send_updateExperiment(const std::string& airavataExperiment
   oprot_->getTransport()->flush();
 }
 
-void AiravataClient::recv_updateExperiment()
+void AiravataClient::recv_launchExperiment()
 {
 
   int32_t rseqid = 0;
@@ -10268,12 +11431,12 @@ void AiravataClient::recv_updateExperiment()
     iprot_->readMessageEnd();
     iprot_->getTransport()->readEnd();
   }
-  if (fname.compare("updateExperiment") != 0) {
+  if (fname.compare("launchExperiment") != 0) {
     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
     iprot_->readMessageEnd();
     iprot_->getTransport()->readEnd();
   }
-  Airavata_updateExperiment_presult result;
+  Airavata_launchExperiment_presult result;
   result.read(iprot_);
   iprot_->readMessageEnd();
   iprot_->getTransport()->readEnd();
@@ -10290,23 +11453,25 @@ void AiravataClient::recv_updateExperiment()
   if (result.__isset.ase) {
     throw result.ase;
   }
+  if (result.__isset.lve) {
+    throw result.lve;
+  }
   return;
 }
 
-void AiravataClient::updateExperimentConfiguration(const std::string& airavataExperimentId, const  ::UserConfigurationData& userConfiguration)
+void AiravataClient::getExperimentStatus( ::ExperimentStatus& _return, const std::string& airavataExperimentId)
 {
-  send_updateExperimentConfiguration(airavataExperimentId, userConfiguration);
-  recv_updateExperimentConfiguration();
+  send_getExperimentStatus(airavataExperimentId);
+  recv_getExperimentStatus(_return);
 }
 
-void AiravataClient::send_updateExperimentConfiguration(const std::string& airavataExperimentId, const  ::UserConfigurationData& userConfiguration)
+void AiravataClient::send_getExperimentStatus(const std::string& airavataExperimentId)
 {
   int32_t cseqid = 0;
-  oprot_->writeMessageBegin("updateExperimentConfiguration", ::apache::thrift::protocol::T_CALL, cseqid);
+  oprot_->writeMessageBegin("getExperimentStatus", ::apache::thrift::protocol::T_CALL, cseqid);
 
-  Airavata_updateExperimentConfiguration_pargs args;
+  Airavata_getExperimentStatus_pargs args;
   args.airavataExperimentId = &airavataExperimentId;
-  args.userConfiguration = &userConfiguration;
   args.write(oprot_);
 
   oprot_->writeMessageEnd();
@@ -10314,7 +11479,7 @@ void AiravataClient::send_updateExperimentConfiguration(const std::string& airav
   oprot_->getTransport()->flush();
 }
 
-void AiravataClient::recv_updateExperimentConfiguration()
+void AiravataClient::recv_getExperimentStatus( ::ExperimentStatus& _return)
 {
 
   int32_t rseqid = 0;
@@ -10334,33 +11499,49 @@ void AiravataClient::recv_updateExperimentConfiguration()
     iprot_->readMessageEnd();
     iprot_->getTransport()->readEnd();
   }
-  if (fname.compare("updateExperimentConfiguration") != 0) {
-    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
-    iprot_->readMessageEnd();
-    iprot_->getTransport()->readEnd();
+  if (fname.compare("getExperimentStatus") != 0) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  Airavata_getExperimentStatus_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.enf) {
+    throw result.enf;
+  }
+  if (result.__isset.ace) {
+    throw result.ace;
+  }
+  if (result.__isset.ase) {
+    throw result.ase;
   }
-  Airavata_updateExperimentConfiguration_presult result;
-  result.read(iprot_);
-  iprot_->readMessageEnd();
-  iprot_->getTransport()->readEnd();
-
-  return;
+  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getExperimentStatus failed: unknown result");
 }
 
-void AiravataClient::updateResourceScheduleing(const std::string& airavataExperimentId, const  ::ComputationalResourceScheduling& resourceScheduling)
+void AiravataClient::getExperimentOutputs(std::vector< ::DataObjectType> & _return, const std::string& airavataExperimentId)
 {
-  send_updateResourceScheduleing(airavataExperimentId, resourceScheduling);
-  recv_updateResourceScheduleing();
+  send_getExperimentOutputs(airavataExperimentId);
+  recv_getExperimentOutputs(_return);
 }
 
-void AiravataClient::send_updateResourceScheduleing(const std::string& airavataExperimentId, const  ::ComputationalResourceScheduling& resourceScheduling)
+void AiravataClient::send_getExperimentOutputs(const std::string& airavataExperimentId)
 {
   int32_t cseqid = 0;
-  oprot_->writeMessageBegin("updateResourceScheduleing", ::apache::thrift::protocol::T_CALL, cseqid);
+  oprot_->writeMessageBegin("getExperimentOutputs", ::apache::thrift::protocol::T_CALL, cseqid);
 
-  Airavata_updateResourceScheduleing_pargs args;
+  Airavata_getExperimentOutputs_pargs args;
   args.airavataExperimentId = &airavataExperimentId;
-  args.resourceScheduling = &resourceScheduling;
   args.write(oprot_);
 
   oprot_->writeMessageEnd();
@@ -10368,7 +11549,7 @@ void AiravataClient::send_updateResourceScheduleing(const std::string& airavataE
   oprot_->getTransport()->flush();
 }
 
-void AiravataClient::recv_updateResourceScheduleing()
+void AiravataClient::recv_getExperimentOutputs(std::vector< ::DataObjectType> & _return)
 {
 
   int32_t rseqid = 0;
@@ -10388,31 +11569,36 @@ void AiravataClient::recv_updateResourceScheduleing()
     iprot_->readMessageEnd();
     iprot_->getTransport()->readEnd();
   }
-  if (fname.compare("updateResourceScheduleing") != 0) {
+  if (fname.compare("getExperimentOutputs") != 0) {
     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
     iprot_->readMessageEnd();
     iprot_->getTransport()->readEnd();
   }
-  Airavata_updateResourceScheduleing_presult result;
+  Airavata_getExperimentOutputs_presult result;
+  result.success = &_return;
   result.read(iprot_);
   iprot_->readMessageEnd();
   iprot_->getTransport()->readEnd();
 
-  return;
+  if (result.__isset.success) {
+    // _return pointer has now been filled
+    return;
+  }
+  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getExperimentOutputs failed: unknown result");
 }
 
-bool AiravataClient::validateExperiment(const std::string& airavataExperimentId)
+void AiravataClient::getJobStatuses(std::map<std::string,  ::JobStatus> & _return, const std::string& airavataExperimentId)
 {
-  send_validateExperiment(airavataExperimentId);
-  return recv_validateExperiment();
+  send_getJobStatuses(airavataExperimentId);
+  recv_getJobStatuses(_return);
 }
 
-void AiravataClient::send_validateExperiment(const std::string& airavataExperimentId)
+void AiravataClient::send_getJobStatuses(const std::string& airavataExperimentId)
 {
   int32_t cseqid = 0;
-  oprot_->writeMessageBegin("validateExperiment", ::apache::thrift::protocol::T_CALL, cseqid);
+  oprot_->writeMessageBegin("getJobStatuses", ::apache::thrift::protocol::T_CALL, cseqid);
 
-  Airavata_validateExperiment_pargs args;
+  Airavata_getJobStatuses_pargs args;
   args.airavataExperimentId = &airavataExperimentId;
   args.write(oprot_);
 
@@ -10421,7 +11607,7 @@ void AiravataClient::send_validateExperiment(const std::string& airavataExperime
   oprot_->getTransport()->flush();
 }
 
-bool AiravataClient::recv_validateExperiment()
+void AiravataClient::recv_getJobStatuses(std::map<std::string,  ::JobStatus> & _return)
 {
 
   int32_t rseqid = 0;
@@ -10441,50 +11627,38 @@ bool AiravataClient::recv_validateExperiment()
     iprot_->readMessageEnd();
     iprot_->getTransport()->readEnd();
   }
-  if (fname.compare("validateExperiment") != 0) {
+  if (fname.compare("getJobStatuses") != 0) {
     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
     iprot_->readMessageEnd();
     iprot_->getTransport()->readEnd();
   }
-  bool _return;
-  Airavata_validateExperiment_presult result;
+  Airavata_getJobStatuses_presult result;
   result.success = &_return;
   result.read(iprot_);
   iprot_->readMessageEnd();
   iprot_->getTransport()->readEnd();
 
   if (result.__isset.success) {
-    return _return;
-  }
-  if (result.__isset.ire) {
-    throw result.ire;
-  }
-  if (result.__isset.enf) {
-    throw result.enf;
-  }
-  if (result.__isset.ace) {
-    throw result.ace;
-  }
-  if (result.__isset.ase) {
-    throw result.ase;
+    // _return pointer has now been filled
+    return;
   }
-  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "validateExperiment failed: unknown result");
+  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getJobStatuses failed: unknown result");
 }
 
-void AiravataClient::launchExperiment(const std::string& airavataExperimentId, const std::string& airavataCredStoreToken)
+void AiravataClient::cloneExperiment(std::string& _return, const std::string& existingExperimentID, const std::string& newExperimentName)
 {
-  send_launchExperiment(airavataExperimentId, airavataCredStoreToken);
-  recv_launchExperiment();
+  send_cloneExperiment(existingExperimentID, newExperimentName);
+  recv_cloneExperiment(_return);
 }
 
-void AiravataClient::send_launchExperiment(const std::string& airavataExperimentId, const std::string& airavataCredStoreToken)
+void AiravataClient::send_cloneExperiment(const std::string& existingExperimentID, const std::string& newExperimentName)
 {
   int32_t cseqid = 0;
-  oprot_->writeMessageBegin("launchExperiment", ::apache::thrift::protocol::T_CALL, cseqid);
+  oprot_->writeMessageBegin("cloneExperiment", ::apache::thrift::protocol::T_CALL, cseqid);
 
-  Airavata_launchExperiment_pargs args;
-  args.airavataExperimentId = &airavataExperimentId;
-  args.airavataCredStoreToken = &airavataCredStoreToken;
+  Airavata_cloneExperiment_pargs args;
+  args.existingExperimentID = &existingExperimentID;
+  args.newExperimentName = &newExperimentName;
   args.write(oprot_);
 
   oprot_->writeMessageEnd();
@@ -10492,7 +11666,7 @@ void AiravataClient::send_launchExperiment(const std::string& airavataExperiment
   oprot_->getTransport()->flush();
 }
 
-void AiravataClient::recv_launchExperiment()
+void AiravataClient::recv_cloneExperiment(std::string& _return)
 {
 
   int32_t rseqid = 0;
@@ -10512,16 +11686,21 @@ void AiravataClient::recv_launchExperiment()
     iprot_->readMessageEnd();
     iprot_->getTransport()->readEnd();
   }
-  if (fname.compare("launchExperiment") != 0) {
+  if (fname.compare("cloneExperiment") != 0) {
     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
     iprot_->readMessageEnd();
     iprot_->getTransport()->readEnd();
   }
-  Airavata_launchExperiment_presult result;
+  Airavata_cloneExperiment_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;
   }
@@ -10534,24 +11713,21 @@ void AiravataClient::recv_launchExperiment()
   if (result.__isset.ase) {
     throw result.ase;
   }
-  if (result.__isset.lve) {
-    throw result.lve;
-  }
-  return;
+  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "cloneExperiment failed: unknown result");
 }
 
-void AiravataClient::getExperimentStatus( ::ExperimentStatus& _return, const std::string& airavataExperimentId)
+void AiravataClient::terminateExperiment(const std::string& airavataExperimentId)
 {
-  send_getExperimentStatus(airavataExperimentId);
-  recv_getExperimentStatus(_return);
+  send_terminateExperiment(airavataExperimentId);
+  recv_terminateExperiment();
 }
 
-void AiravataClient::send_getExperimentStatus(const std::string& airavataExperimentId)
+void AiravataClient::send_terminateExperiment(const std::string& airavataExperimentId)
 {
   int32_t cseqid = 0;
-  oprot_->writeMessageBegin("getExperimentStatus", ::apache::thrift::protocol::T_CALL, cseqid);
+  oprot_->writeMessageBegin("terminateExperiment", ::apache::thrift::protocol::T_CALL, cseqid);
 
-  Airavata_getExperimentStatus_pargs args;
+  Airavata_terminateExperiment_pargs args;
   args.airavataExperimentId = &airavataExperimentId;
   args.write(oprot_);
 
@@ -10560,7 +11736,7 @@ void AiravataClient::send_getExperimentStatus(const std::string& airavataExperim
   oprot_->getTransport()->flush();
 }
 
-void AiravataClient::recv_getExperimentStatus( ::ExperimentStatus& _return)
+void AiravataClient::recv_terminateExperiment()
 {
 
   int32_t rseqid = 0;
@@ -10580,21 +11756,16 @@ void AiravataClient::recv_getExperimentStatus( ::ExperimentStatus& _return)
     iprot_->readMessageEnd();
     iprot_->getTransport()->readEnd();
   }
-  if (fname.compare("getExperimentStatus") != 0) {
+  if (fname.compare("terminateExperiment") != 0) {
     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
     iprot_->readMessageEnd();
     iprot_->getTransport()->readEnd();
   }
-  Airavata_getExperimentStatus_presult result;
-  result.success = &_return;
+  Airavata_terminateExperiment_presult result;
   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;
   }
@@ -10607,22 +11778,22 @@ void AiravataClient::recv_getExperimentStatus( ::ExperimentStatus& _return)
   if (result.__isset.ase) {
     throw result.ase;
   }
-  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getExperimentStatus failed: unknown result");
+  return;
 }
 
-void AiravataClient::getExperimentOutputs(std::vector< ::DataObjectType> & _return, const std::string& airavataExperimentId)
+void AiravataClient::registerApplicationModule(std::string& _return, const  ::ApplicationModule& applicationModule)
 {
-  send_getExperimentOutputs(airavataExperimentId);
-  recv_getExperimentOutputs(_return);
+  send_registerApplicationModule(applicationModule);
+  recv_registerApplicationModule(_return);
 }
 
-void AiravataClient::send_getExperimentOutputs(const std::string& airavataExperimentId)
+void AiravataClient::send_registerApplicationModule(const  ::ApplicationModule& applicationModule)
 {
   int32_t cseqid = 0;
-  oprot_->writeMessageBegin("getExperimentOutputs", ::apache::thrift::protocol::T_CALL, cseqid);
+  oprot_->writeMessageBegin("registerApplicationModule", ::apache::thrift::protocol::T_CALL, cseqid);
 
-  Airavata_getExperimentOutputs_pargs args;
-  args.airavataExperimentId = &airavataExperimentId;
+  Airavata_registerApplicationModule_pargs args;
+  args.applicationModule = &applicationModule;
   args.write(oprot_);
 
   oprot_->writeMessageEnd();
@@ -10630,7 +11801,7 @@ void AiravataClient::send_getExperimentOutputs(const std::string& airavataExperi
   oprot_->getTransport()->flush();
 }
 
-void AiravataClient::recv_getExperimentOutputs(std::vector< ::DataObjectType> & _return)
+void AiravataClient::recv_registerApplicationModule(std::string& _return)
 {
 
   int32_t rseqid = 0;
@@ -10650,12 +11821,12 @@ void AiravataClient::recv_getExperimentOutputs(std::vector< ::DataObjectType> &
     iprot_->readMessageEnd();
     iprot_->getTransport()->readEnd();
   }
-  if (fname.compare("getExperimentOutputs") != 0) {
+  if (fname.compare("registerApplicationModule") != 0) {
     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
     iprot_->readMessageEnd();
     iprot_->getTransport()->readEnd();
   }
-  Airavata_getExperimentOutputs_presult result;
+  Airavata_registerApplicationModule_presult result;
   result.success = &_return;
   result.read(iprot_);
   iprot_->readMessageEnd();
@@ -10665,22 +11836,31 @@ void AiravataClient::recv_getExperimentOutputs(std::vector< ::DataObjectType> &
     // _return pointer has now been filled
     return;
   }
-  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getExperimentOutputs failed: unknown result");
+  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, "registerApplicationModule failed: unknown result");
 }
 
-void AiravataClient::getJobStatuses(std::map<std::string,  ::JobStatus> & _return, const std::string& airavataExperimentId)
+void AiravataClient::getApplicationModule( ::ApplicationModule& _return, const std::string& appModuleId)
 {
-  send_getJobStatuses(airavataExperimentId);
-  recv_getJobStatuses(_return);
+  send_getApplicationModule(appModuleId);
+  recv_getApplicationModule(_return);
 }
 
-void AiravataClient::send_getJobStatuses(const std::string& airavataExperimentId)
+void AiravataClient::send_getApplicationModule(const std::string& appModuleId)
 {
   int32_t cseqid = 0;
-  oprot_->writeMessageBegin("getJobStatuses", ::apache::thrift::protocol::T_CALL, cseqid);
+  oprot_->writeMessageBegin("getApplicationModule", ::apache::thrift::protocol::T_CALL, cseqid);
 
-  Airavata_getJobStatuses_pargs args;
-  args.airavataExperimentId = &airavataExperimentId;
+  Airavata_getApplicationModule_pargs args;
+  args.appModuleId = &appModuleId;
   args.write(oprot_);
 
   oprot_->writeMessageEnd();
@@ -10688,7 +11868,7 @@ void AiravataClient::send_getJobStatuses(const std::string& airavataExperimentId
   oprot_->getTransport()->flush();
 }
 
-void AiravataClient::recv_getJobStatuses(std::map<std::string,  ::JobStatus> & _return)
+void AiravataClient::recv_getApplicationModule( ::ApplicationModule& _return)
 {
 
   int32_t rseqid = 0;
@@ -10708,12 +11888,12 @@ void AiravataClient::recv_getJobStatuses(std::map<std::string,  ::JobStatus> & _
     iprot

<TRUNCATED>

Mime
View raw message