[08/44] airavata git commit: changing few API methods to adhere to security solution.

[sm...@apache.org]

http://git-wip-us.apache.org/repos/asf/airavata/blob/dc524490/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/messaging_events_types.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/messaging_events_types.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/messaging_events_types.cpp
new file mode 100644
index 0000000..b32a987
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/messaging_events_types.cpp
@@ -0,0 +1,1964 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Autogenerated by Thrift Compiler (0.9.2)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+#include "messaging_events_types.h"
+
+#include <algorithm>
+#include <ostream>
+
+#include <thrift/TToString.h>
+
+namespace apache { namespace airavata { namespace model { namespace messaging { namespace event {
+
+int _kMessageLevelValues[] = {
+  MessageLevel::INFO,
+  MessageLevel::DEBUG,
+  MessageLevel::ERROR,
+  MessageLevel::ACK
+};
+const char* _kMessageLevelNames[] = {
+  "INFO",
+  "DEBUG",
+  "ERROR",
+  "ACK"
+};
+const std::map<int, const char*> _MessageLevel_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(4, _kMessageLevelValues, _kMessageLevelNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
+
+int _kMessageTypeValues[] = {
+  MessageType::EXPERIMENT,
+  MessageType::TASK,
+  MessageType::PROCESS,
+  MessageType::JOB,
+  MessageType::LAUNCHPROCESS,
+  MessageType::TERMINATEPROCESS,
+  MessageType::PROCESSOUTPUT
+};
+const char* _kMessageTypeNames[] = {
+  "EXPERIMENT",
+  "TASK",
+  "PROCESS",
+  "JOB",
+  "LAUNCHPROCESS",
+  "TERMINATEPROCESS",
+  "PROCESSOUTPUT"
+};
+const std::map<int, const char*> _MessageType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(7, _kMessageTypeValues, _kMessageTypeNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
+
+
+ExperimentStatusChangeEvent::~ExperimentStatusChangeEvent() throw() {
+}
+
+
+void ExperimentStatusChangeEvent::__set_state(const  ::apache::airavata::model::status::ExperimentState::type val) {
+  this->state = val;
+}
+
+void ExperimentStatusChangeEvent::__set_experimentId(const std::string& val) {
+  this->experimentId = val;
+}
+
+void ExperimentStatusChangeEvent::__set_gatewayId(const std::string& val) {
+  this->gatewayId = val;
+}
+
+const char* ExperimentStatusChangeEvent::ascii_fingerprint = "38C252E94E93B69D04EB3A6EE2F9EDFB";
+const uint8_t ExperimentStatusChangeEvent::binary_fingerprint[16] = {0x38,0xC2,0x52,0xE9,0x4E,0x93,0xB6,0x9D,0x04,0xEB,0x3A,0x6E,0xE2,0xF9,0xED,0xFB};
+
+uint32_t ExperimentStatusChangeEvent::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_state = false;
+  bool isset_experimentId = false;
+  bool isset_gatewayId = 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_I32) {
+          int32_t ecast0;
+          xfer += iprot->readI32(ecast0);
+          this->state = ( ::apache::airavata::model::status::ExperimentState::type)ecast0;
+          isset_state = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->experimentId);
+          isset_experimentId = true;
+        } else {
+          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;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_state)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_experimentId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_gatewayId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t ExperimentStatusChangeEvent::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
+  xfer += oprot->writeStructBegin("ExperimentStatusChangeEvent");
+
+  xfer += oprot->writeFieldBegin("state", ::apache::thrift::protocol::T_I32, 1);
+  xfer += oprot->writeI32((int32_t)this->state);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("experimentId", ::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeString(this->experimentId);
+  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();
+  oprot->decrementRecursionDepth();
+  return xfer;
+}
+
+void swap(ExperimentStatusChangeEvent &a, ExperimentStatusChangeEvent &b) {
+  using ::std::swap;
+  swap(a.state, b.state);
+  swap(a.experimentId, b.experimentId);
+  swap(a.gatewayId, b.gatewayId);
+}
+
+ExperimentStatusChangeEvent::ExperimentStatusChangeEvent(const ExperimentStatusChangeEvent& other1) {
+  state = other1.state;
+  experimentId = other1.experimentId;
+  gatewayId = other1.gatewayId;
+}
+ExperimentStatusChangeEvent& ExperimentStatusChangeEvent::operator=(const ExperimentStatusChangeEvent& other2) {
+  state = other2.state;
+  experimentId = other2.experimentId;
+  gatewayId = other2.gatewayId;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const ExperimentStatusChangeEvent& obj) {
+  using apache::thrift::to_string;
+  out << "ExperimentStatusChangeEvent(";
+  out << "state=" << to_string(obj.state);
+  out << ", " << "experimentId=" << to_string(obj.experimentId);
+  out << ", " << "gatewayId=" << to_string(obj.gatewayId);
+  out << ")";
+  return out;
+}
+
+
+ProcessIdentifier::~ProcessIdentifier() throw() {
+}
+
+
+void ProcessIdentifier::__set_processId(const std::string& val) {
+  this->processId = val;
+}
+
+void ProcessIdentifier::__set_experimentId(const std::string& val) {
+  this->experimentId = val;
+}
+
+void ProcessIdentifier::__set_gatewayId(const std::string& val) {
+  this->gatewayId = val;
+}
+
+const char* ProcessIdentifier::ascii_fingerprint = "AB879940BD15B6B25691265F7384B271";
+const uint8_t ProcessIdentifier::binary_fingerprint[16] = {0xAB,0x87,0x99,0x40,0xBD,0x15,0xB6,0xB2,0x56,0x91,0x26,0x5F,0x73,0x84,0xB2,0x71};
+
+uint32_t ProcessIdentifier::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_processId = false;
+  bool isset_experimentId = false;
+  bool isset_gatewayId = 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->processId);
+          isset_processId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->experimentId);
+          isset_experimentId = true;
+        } else {
+          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;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_processId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_experimentId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_gatewayId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t ProcessIdentifier::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
+  xfer += oprot->writeStructBegin("ProcessIdentifier");
+
+  xfer += oprot->writeFieldBegin("processId", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->processId);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("experimentId", ::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeString(this->experimentId);
+  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();
+  oprot->decrementRecursionDepth();
+  return xfer;
+}
+
+void swap(ProcessIdentifier &a, ProcessIdentifier &b) {
+  using ::std::swap;
+  swap(a.processId, b.processId);
+  swap(a.experimentId, b.experimentId);
+  swap(a.gatewayId, b.gatewayId);
+}
+
+ProcessIdentifier::ProcessIdentifier(const ProcessIdentifier& other3) {
+  processId = other3.processId;
+  experimentId = other3.experimentId;
+  gatewayId = other3.gatewayId;
+}
+ProcessIdentifier& ProcessIdentifier::operator=(const ProcessIdentifier& other4) {
+  processId = other4.processId;
+  experimentId = other4.experimentId;
+  gatewayId = other4.gatewayId;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const ProcessIdentifier& obj) {
+  using apache::thrift::to_string;
+  out << "ProcessIdentifier(";
+  out << "processId=" << to_string(obj.processId);
+  out << ", " << "experimentId=" << to_string(obj.experimentId);
+  out << ", " << "gatewayId=" << to_string(obj.gatewayId);
+  out << ")";
+  return out;
+}
+
+
+TaskIdentifier::~TaskIdentifier() throw() {
+}
+
+
+void TaskIdentifier::__set_taskId(const std::string& val) {
+  this->taskId = val;
+}
+
+void TaskIdentifier::__set_processId(const std::string& val) {
+  this->processId = val;
+}
+
+void TaskIdentifier::__set_experimentId(const std::string& val) {
+  this->experimentId = val;
+}
+
+void TaskIdentifier::__set_gatewayId(const std::string& val) {
+  this->gatewayId = val;
+}
+
+const char* TaskIdentifier::ascii_fingerprint = "C93D890311F28844166CF6E571EB3AC2";
+const uint8_t TaskIdentifier::binary_fingerprint[16] = {0xC9,0x3D,0x89,0x03,0x11,0xF2,0x88,0x44,0x16,0x6C,0xF6,0xE5,0x71,0xEB,0x3A,0xC2};
+
+uint32_t TaskIdentifier::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_taskId = false;
+  bool isset_processId = false;
+  bool isset_experimentId = false;
+  bool isset_gatewayId = 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->taskId);
+          isset_taskId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->processId);
+          isset_processId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->experimentId);
+          isset_experimentId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        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;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_taskId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_processId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_experimentId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_gatewayId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t TaskIdentifier::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
+  xfer += oprot->writeStructBegin("TaskIdentifier");
+
+  xfer += oprot->writeFieldBegin("taskId", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->taskId);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("processId", ::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeString(this->processId);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("experimentId", ::apache::thrift::protocol::T_STRING, 3);
+  xfer += oprot->writeString(this->experimentId);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("gatewayId", ::apache::thrift::protocol::T_STRING, 4);
+  xfer += oprot->writeString(this->gatewayId);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
+  return xfer;
+}
+
+void swap(TaskIdentifier &a, TaskIdentifier &b) {
+  using ::std::swap;
+  swap(a.taskId, b.taskId);
+  swap(a.processId, b.processId);
+  swap(a.experimentId, b.experimentId);
+  swap(a.gatewayId, b.gatewayId);
+}
+
+TaskIdentifier::TaskIdentifier(const TaskIdentifier& other5) {
+  taskId = other5.taskId;
+  processId = other5.processId;
+  experimentId = other5.experimentId;
+  gatewayId = other5.gatewayId;
+}
+TaskIdentifier& TaskIdentifier::operator=(const TaskIdentifier& other6) {
+  taskId = other6.taskId;
+  processId = other6.processId;
+  experimentId = other6.experimentId;
+  gatewayId = other6.gatewayId;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const TaskIdentifier& obj) {
+  using apache::thrift::to_string;
+  out << "TaskIdentifier(";
+  out << "taskId=" << to_string(obj.taskId);
+  out << ", " << "processId=" << to_string(obj.processId);
+  out << ", " << "experimentId=" << to_string(obj.experimentId);
+  out << ", " << "gatewayId=" << to_string(obj.gatewayId);
+  out << ")";
+  return out;
+}
+
+
+TaskStatusChangeEvent::~TaskStatusChangeEvent() throw() {
+}
+
+
+void TaskStatusChangeEvent::__set_state(const  ::apache::airavata::model::status::TaskState::type val) {
+  this->state = val;
+}
+
+void TaskStatusChangeEvent::__set_taskIdentity(const TaskIdentifier& val) {
+  this->taskIdentity = val;
+}
+
+const char* TaskStatusChangeEvent::ascii_fingerprint = "8D18A3CD1822DBC67D7BD8CB98E7B4F1";
+const uint8_t TaskStatusChangeEvent::binary_fingerprint[16] = {0x8D,0x18,0xA3,0xCD,0x18,0x22,0xDB,0xC6,0x7D,0x7B,0xD8,0xCB,0x98,0xE7,0xB4,0xF1};
+
+uint32_t TaskStatusChangeEvent::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_state = false;
+  bool isset_taskIdentity = 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_I32) {
+          int32_t ecast7;
+          xfer += iprot->readI32(ecast7);
+          this->state = ( ::apache::airavata::model::status::TaskState::type)ecast7;
+          isset_state = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->taskIdentity.read(iprot);
+          isset_taskIdentity = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_state)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_taskIdentity)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t TaskStatusChangeEvent::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
+  xfer += oprot->writeStructBegin("TaskStatusChangeEvent");
+
+  xfer += oprot->writeFieldBegin("state", ::apache::thrift::protocol::T_I32, 1);
+  xfer += oprot->writeI32((int32_t)this->state);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("taskIdentity", ::apache::thrift::protocol::T_STRUCT, 2);
+  xfer += this->taskIdentity.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
+  return xfer;
+}
+
+void swap(TaskStatusChangeEvent &a, TaskStatusChangeEvent &b) {
+  using ::std::swap;
+  swap(a.state, b.state);
+  swap(a.taskIdentity, b.taskIdentity);
+}
+
+TaskStatusChangeEvent::TaskStatusChangeEvent(const TaskStatusChangeEvent& other8) {
+  state = other8.state;
+  taskIdentity = other8.taskIdentity;
+}
+TaskStatusChangeEvent& TaskStatusChangeEvent::operator=(const TaskStatusChangeEvent& other9) {
+  state = other9.state;
+  taskIdentity = other9.taskIdentity;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const TaskStatusChangeEvent& obj) {
+  using apache::thrift::to_string;
+  out << "TaskStatusChangeEvent(";
+  out << "state=" << to_string(obj.state);
+  out << ", " << "taskIdentity=" << to_string(obj.taskIdentity);
+  out << ")";
+  return out;
+}
+
+
+TaskStatusChangeRequestEvent::~TaskStatusChangeRequestEvent() throw() {
+}
+
+
+void TaskStatusChangeRequestEvent::__set_state(const  ::apache::airavata::model::status::TaskState::type val) {
+  this->state = val;
+}
+
+void TaskStatusChangeRequestEvent::__set_taskIdentity(const TaskIdentifier& val) {
+  this->taskIdentity = val;
+}
+
+const char* TaskStatusChangeRequestEvent::ascii_fingerprint = "8D18A3CD1822DBC67D7BD8CB98E7B4F1";
+const uint8_t TaskStatusChangeRequestEvent::binary_fingerprint[16] = {0x8D,0x18,0xA3,0xCD,0x18,0x22,0xDB,0xC6,0x7D,0x7B,0xD8,0xCB,0x98,0xE7,0xB4,0xF1};
+
+uint32_t TaskStatusChangeRequestEvent::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_state = false;
+  bool isset_taskIdentity = 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_I32) {
+          int32_t ecast10;
+          xfer += iprot->readI32(ecast10);
+          this->state = ( ::apache::airavata::model::status::TaskState::type)ecast10;
+          isset_state = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->taskIdentity.read(iprot);
+          isset_taskIdentity = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_state)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_taskIdentity)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t TaskStatusChangeRequestEvent::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
+  xfer += oprot->writeStructBegin("TaskStatusChangeRequestEvent");
+
+  xfer += oprot->writeFieldBegin("state", ::apache::thrift::protocol::T_I32, 1);
+  xfer += oprot->writeI32((int32_t)this->state);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("taskIdentity", ::apache::thrift::protocol::T_STRUCT, 2);
+  xfer += this->taskIdentity.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
+  return xfer;
+}
+
+void swap(TaskStatusChangeRequestEvent &a, TaskStatusChangeRequestEvent &b) {
+  using ::std::swap;
+  swap(a.state, b.state);
+  swap(a.taskIdentity, b.taskIdentity);
+}
+
+TaskStatusChangeRequestEvent::TaskStatusChangeRequestEvent(const TaskStatusChangeRequestEvent& other11) {
+  state = other11.state;
+  taskIdentity = other11.taskIdentity;
+}
+TaskStatusChangeRequestEvent& TaskStatusChangeRequestEvent::operator=(const TaskStatusChangeRequestEvent& other12) {
+  state = other12.state;
+  taskIdentity = other12.taskIdentity;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const TaskStatusChangeRequestEvent& obj) {
+  using apache::thrift::to_string;
+  out << "TaskStatusChangeRequestEvent(";
+  out << "state=" << to_string(obj.state);
+  out << ", " << "taskIdentity=" << to_string(obj.taskIdentity);
+  out << ")";
+  return out;
+}
+
+
+ProcessStatusChangeEvent::~ProcessStatusChangeEvent() throw() {
+}
+
+
+void ProcessStatusChangeEvent::__set_state(const  ::apache::airavata::model::status::ProcessState::type val) {
+  this->state = val;
+}
+
+void ProcessStatusChangeEvent::__set_processIdentity(const ProcessIdentifier& val) {
+  this->processIdentity = val;
+}
+
+const char* ProcessStatusChangeEvent::ascii_fingerprint = "9686679C94D43D75F2B35A0BED2E4003";
+const uint8_t ProcessStatusChangeEvent::binary_fingerprint[16] = {0x96,0x86,0x67,0x9C,0x94,0xD4,0x3D,0x75,0xF2,0xB3,0x5A,0x0B,0xED,0x2E,0x40,0x03};
+
+uint32_t ProcessStatusChangeEvent::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_state = false;
+  bool isset_processIdentity = 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_I32) {
+          int32_t ecast13;
+          xfer += iprot->readI32(ecast13);
+          this->state = ( ::apache::airavata::model::status::ProcessState::type)ecast13;
+          isset_state = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->processIdentity.read(iprot);
+          isset_processIdentity = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_state)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_processIdentity)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t ProcessStatusChangeEvent::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
+  xfer += oprot->writeStructBegin("ProcessStatusChangeEvent");
+
+  xfer += oprot->writeFieldBegin("state", ::apache::thrift::protocol::T_I32, 1);
+  xfer += oprot->writeI32((int32_t)this->state);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("processIdentity", ::apache::thrift::protocol::T_STRUCT, 2);
+  xfer += this->processIdentity.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
+  return xfer;
+}
+
+void swap(ProcessStatusChangeEvent &a, ProcessStatusChangeEvent &b) {
+  using ::std::swap;
+  swap(a.state, b.state);
+  swap(a.processIdentity, b.processIdentity);
+}
+
+ProcessStatusChangeEvent::ProcessStatusChangeEvent(const ProcessStatusChangeEvent& other14) {
+  state = other14.state;
+  processIdentity = other14.processIdentity;
+}
+ProcessStatusChangeEvent& ProcessStatusChangeEvent::operator=(const ProcessStatusChangeEvent& other15) {
+  state = other15.state;
+  processIdentity = other15.processIdentity;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const ProcessStatusChangeEvent& obj) {
+  using apache::thrift::to_string;
+  out << "ProcessStatusChangeEvent(";
+  out << "state=" << to_string(obj.state);
+  out << ", " << "processIdentity=" << to_string(obj.processIdentity);
+  out << ")";
+  return out;
+}
+
+
+ProcessStatusChangeRequestEvent::~ProcessStatusChangeRequestEvent() throw() {
+}
+
+
+void ProcessStatusChangeRequestEvent::__set_state(const  ::apache::airavata::model::status::ProcessState::type val) {
+  this->state = val;
+}
+
+void ProcessStatusChangeRequestEvent::__set_processIdentity(const ProcessIdentifier& val) {
+  this->processIdentity = val;
+}
+
+const char* ProcessStatusChangeRequestEvent::ascii_fingerprint = "9686679C94D43D75F2B35A0BED2E4003";
+const uint8_t ProcessStatusChangeRequestEvent::binary_fingerprint[16] = {0x96,0x86,0x67,0x9C,0x94,0xD4,0x3D,0x75,0xF2,0xB3,0x5A,0x0B,0xED,0x2E,0x40,0x03};
+
+uint32_t ProcessStatusChangeRequestEvent::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_state = false;
+  bool isset_processIdentity = 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_I32) {
+          int32_t ecast16;
+          xfer += iprot->readI32(ecast16);
+          this->state = ( ::apache::airavata::model::status::ProcessState::type)ecast16;
+          isset_state = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->processIdentity.read(iprot);
+          isset_processIdentity = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_state)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_processIdentity)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t ProcessStatusChangeRequestEvent::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
+  xfer += oprot->writeStructBegin("ProcessStatusChangeRequestEvent");
+
+  xfer += oprot->writeFieldBegin("state", ::apache::thrift::protocol::T_I32, 1);
+  xfer += oprot->writeI32((int32_t)this->state);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("processIdentity", ::apache::thrift::protocol::T_STRUCT, 2);
+  xfer += this->processIdentity.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
+  return xfer;
+}
+
+void swap(ProcessStatusChangeRequestEvent &a, ProcessStatusChangeRequestEvent &b) {
+  using ::std::swap;
+  swap(a.state, b.state);
+  swap(a.processIdentity, b.processIdentity);
+}
+
+ProcessStatusChangeRequestEvent::ProcessStatusChangeRequestEvent(const ProcessStatusChangeRequestEvent& other17) {
+  state = other17.state;
+  processIdentity = other17.processIdentity;
+}
+ProcessStatusChangeRequestEvent& ProcessStatusChangeRequestEvent::operator=(const ProcessStatusChangeRequestEvent& other18) {
+  state = other18.state;
+  processIdentity = other18.processIdentity;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const ProcessStatusChangeRequestEvent& obj) {
+  using apache::thrift::to_string;
+  out << "ProcessStatusChangeRequestEvent(";
+  out << "state=" << to_string(obj.state);
+  out << ", " << "processIdentity=" << to_string(obj.processIdentity);
+  out << ")";
+  return out;
+}
+
+
+TaskOutputChangeEvent::~TaskOutputChangeEvent() throw() {
+}
+
+
+void TaskOutputChangeEvent::__set_output(const std::vector< ::apache::airavata::model::application::io::OutputDataObjectType> & val) {
+  this->output = val;
+}
+
+void TaskOutputChangeEvent::__set_taskIdentity(const TaskIdentifier& val) {
+  this->taskIdentity = val;
+}
+
+const char* TaskOutputChangeEvent::ascii_fingerprint = "C7C71D05D69F7D8C4A11C9E432FF5A51";
+const uint8_t TaskOutputChangeEvent::binary_fingerprint[16] = {0xC7,0xC7,0x1D,0x05,0xD6,0x9F,0x7D,0x8C,0x4A,0x11,0xC9,0xE4,0x32,0xFF,0x5A,0x51};
+
+uint32_t TaskOutputChangeEvent::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_output = false;
+  bool isset_taskIdentity = 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_LIST) {
+          {
+            this->output.clear();
+            uint32_t _size19;
+            ::apache::thrift::protocol::TType _etype22;
+            xfer += iprot->readListBegin(_etype22, _size19);
+            this->output.resize(_size19);
+            uint32_t _i23;
+            for (_i23 = 0; _i23 < _size19; ++_i23)
+            {
+              xfer += this->output[_i23].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          isset_output = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->taskIdentity.read(iprot);
+          isset_taskIdentity = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_output)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_taskIdentity)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t TaskOutputChangeEvent::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
+  xfer += oprot->writeStructBegin("TaskOutputChangeEvent");
+
+  xfer += oprot->writeFieldBegin("output", ::apache::thrift::protocol::T_LIST, 1);
+  {
+    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->output.size()));
+    std::vector< ::apache::airavata::model::application::io::OutputDataObjectType> ::const_iterator _iter24;
+    for (_iter24 = this->output.begin(); _iter24 != this->output.end(); ++_iter24)
+    {
+      xfer += (*_iter24).write(oprot);
+    }
+    xfer += oprot->writeListEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("taskIdentity", ::apache::thrift::protocol::T_STRUCT, 2);
+  xfer += this->taskIdentity.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
+  return xfer;
+}
+
+void swap(TaskOutputChangeEvent &a, TaskOutputChangeEvent &b) {
+  using ::std::swap;
+  swap(a.output, b.output);
+  swap(a.taskIdentity, b.taskIdentity);
+}
+
+TaskOutputChangeEvent::TaskOutputChangeEvent(const TaskOutputChangeEvent& other25) {
+  output = other25.output;
+  taskIdentity = other25.taskIdentity;
+}
+TaskOutputChangeEvent& TaskOutputChangeEvent::operator=(const TaskOutputChangeEvent& other26) {
+  output = other26.output;
+  taskIdentity = other26.taskIdentity;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const TaskOutputChangeEvent& obj) {
+  using apache::thrift::to_string;
+  out << "TaskOutputChangeEvent(";
+  out << "output=" << to_string(obj.output);
+  out << ", " << "taskIdentity=" << to_string(obj.taskIdentity);
+  out << ")";
+  return out;
+}
+
+
+JobIdentifier::~JobIdentifier() throw() {
+}
+
+
+void JobIdentifier::__set_jobId(const std::string& val) {
+  this->jobId = val;
+}
+
+void JobIdentifier::__set_taskId(const std::string& val) {
+  this->taskId = val;
+}
+
+void JobIdentifier::__set_processId(const std::string& val) {
+  this->processId = val;
+}
+
+void JobIdentifier::__set_experimentId(const std::string& val) {
+  this->experimentId = val;
+}
+
+void JobIdentifier::__set_gatewayId(const std::string& val) {
+  this->gatewayId = val;
+}
+
+const char* JobIdentifier::ascii_fingerprint = "BFF0E21728CB005F9AA5774A41542B8D";
+const uint8_t JobIdentifier::binary_fingerprint[16] = {0xBF,0xF0,0xE2,0x17,0x28,0xCB,0x00,0x5F,0x9A,0xA5,0x77,0x4A,0x41,0x54,0x2B,0x8D};
+
+uint32_t JobIdentifier::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_jobId = false;
+  bool isset_taskId = false;
+  bool isset_processId = false;
+  bool isset_experimentId = false;
+  bool isset_gatewayId = 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->jobId);
+          isset_jobId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->taskId);
+          isset_taskId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->processId);
+          isset_processId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->experimentId);
+          isset_experimentId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 5:
+        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;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_jobId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_taskId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_processId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_experimentId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_gatewayId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t JobIdentifier::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
+  xfer += oprot->writeStructBegin("JobIdentifier");
+
+  xfer += oprot->writeFieldBegin("jobId", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->jobId);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("taskId", ::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeString(this->taskId);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("processId", ::apache::thrift::protocol::T_STRING, 3);
+  xfer += oprot->writeString(this->processId);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("experimentId", ::apache::thrift::protocol::T_STRING, 4);
+  xfer += oprot->writeString(this->experimentId);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("gatewayId", ::apache::thrift::protocol::T_STRING, 5);
+  xfer += oprot->writeString(this->gatewayId);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
+  return xfer;
+}
+
+void swap(JobIdentifier &a, JobIdentifier &b) {
+  using ::std::swap;
+  swap(a.jobId, b.jobId);
+  swap(a.taskId, b.taskId);
+  swap(a.processId, b.processId);
+  swap(a.experimentId, b.experimentId);
+  swap(a.gatewayId, b.gatewayId);
+}
+
+JobIdentifier::JobIdentifier(const JobIdentifier& other27) {
+  jobId = other27.jobId;
+  taskId = other27.taskId;
+  processId = other27.processId;
+  experimentId = other27.experimentId;
+  gatewayId = other27.gatewayId;
+}
+JobIdentifier& JobIdentifier::operator=(const JobIdentifier& other28) {
+  jobId = other28.jobId;
+  taskId = other28.taskId;
+  processId = other28.processId;
+  experimentId = other28.experimentId;
+  gatewayId = other28.gatewayId;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const JobIdentifier& obj) {
+  using apache::thrift::to_string;
+  out << "JobIdentifier(";
+  out << "jobId=" << to_string(obj.jobId);
+  out << ", " << "taskId=" << to_string(obj.taskId);
+  out << ", " << "processId=" << to_string(obj.processId);
+  out << ", " << "experimentId=" << to_string(obj.experimentId);
+  out << ", " << "gatewayId=" << to_string(obj.gatewayId);
+  out << ")";
+  return out;
+}
+
+
+ProcessSubmitEvent::~ProcessSubmitEvent() throw() {
+}
+
+
+void ProcessSubmitEvent::__set_processId(const std::string& val) {
+  this->processId = val;
+}
+
+void ProcessSubmitEvent::__set_gatewayId(const std::string& val) {
+  this->gatewayId = val;
+}
+
+void ProcessSubmitEvent::__set_tokenId(const std::string& val) {
+  this->tokenId = val;
+}
+
+const char* ProcessSubmitEvent::ascii_fingerprint = "AB879940BD15B6B25691265F7384B271";
+const uint8_t ProcessSubmitEvent::binary_fingerprint[16] = {0xAB,0x87,0x99,0x40,0xBD,0x15,0xB6,0xB2,0x56,0x91,0x26,0x5F,0x73,0x84,0xB2,0x71};
+
+uint32_t ProcessSubmitEvent::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_processId = false;
+  bool isset_gatewayId = false;
+  bool isset_tokenId = 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->processId);
+          isset_processId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->gatewayId);
+          isset_gatewayId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->tokenId);
+          isset_tokenId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_processId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_gatewayId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_tokenId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t ProcessSubmitEvent::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
+  xfer += oprot->writeStructBegin("ProcessSubmitEvent");
+
+  xfer += oprot->writeFieldBegin("processId", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->processId);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("gatewayId", ::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeString(this->gatewayId);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("tokenId", ::apache::thrift::protocol::T_STRING, 3);
+  xfer += oprot->writeString(this->tokenId);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
+  return xfer;
+}
+
+void swap(ProcessSubmitEvent &a, ProcessSubmitEvent &b) {
+  using ::std::swap;
+  swap(a.processId, b.processId);
+  swap(a.gatewayId, b.gatewayId);
+  swap(a.tokenId, b.tokenId);
+}
+
+ProcessSubmitEvent::ProcessSubmitEvent(const ProcessSubmitEvent& other29) {
+  processId = other29.processId;
+  gatewayId = other29.gatewayId;
+  tokenId = other29.tokenId;
+}
+ProcessSubmitEvent& ProcessSubmitEvent::operator=(const ProcessSubmitEvent& other30) {
+  processId = other30.processId;
+  gatewayId = other30.gatewayId;
+  tokenId = other30.tokenId;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const ProcessSubmitEvent& obj) {
+  using apache::thrift::to_string;
+  out << "ProcessSubmitEvent(";
+  out << "processId=" << to_string(obj.processId);
+  out << ", " << "gatewayId=" << to_string(obj.gatewayId);
+  out << ", " << "tokenId=" << to_string(obj.tokenId);
+  out << ")";
+  return out;
+}
+
+
+ProcessTerminateEvent::~ProcessTerminateEvent() throw() {
+}
+
+
+void ProcessTerminateEvent::__set_processId(const std::string& val) {
+  this->processId = val;
+}
+
+void ProcessTerminateEvent::__set_gatewayId(const std::string& val) {
+  this->gatewayId = val;
+}
+
+void ProcessTerminateEvent::__set_tokenId(const std::string& val) {
+  this->tokenId = val;
+}
+
+const char* ProcessTerminateEvent::ascii_fingerprint = "AB879940BD15B6B25691265F7384B271";
+const uint8_t ProcessTerminateEvent::binary_fingerprint[16] = {0xAB,0x87,0x99,0x40,0xBD,0x15,0xB6,0xB2,0x56,0x91,0x26,0x5F,0x73,0x84,0xB2,0x71};
+
+uint32_t ProcessTerminateEvent::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_processId = false;
+  bool isset_gatewayId = false;
+  bool isset_tokenId = 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->processId);
+          isset_processId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->gatewayId);
+          isset_gatewayId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->tokenId);
+          isset_tokenId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_processId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_gatewayId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_tokenId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t ProcessTerminateEvent::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
+  xfer += oprot->writeStructBegin("ProcessTerminateEvent");
+
+  xfer += oprot->writeFieldBegin("processId", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->processId);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("gatewayId", ::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeString(this->gatewayId);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("tokenId", ::apache::thrift::protocol::T_STRING, 3);
+  xfer += oprot->writeString(this->tokenId);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
+  return xfer;
+}
+
+void swap(ProcessTerminateEvent &a, ProcessTerminateEvent &b) {
+  using ::std::swap;
+  swap(a.processId, b.processId);
+  swap(a.gatewayId, b.gatewayId);
+  swap(a.tokenId, b.tokenId);
+}
+
+ProcessTerminateEvent::ProcessTerminateEvent(const ProcessTerminateEvent& other31) {
+  processId = other31.processId;
+  gatewayId = other31.gatewayId;
+  tokenId = other31.tokenId;
+}
+ProcessTerminateEvent& ProcessTerminateEvent::operator=(const ProcessTerminateEvent& other32) {
+  processId = other32.processId;
+  gatewayId = other32.gatewayId;
+  tokenId = other32.tokenId;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const ProcessTerminateEvent& obj) {
+  using apache::thrift::to_string;
+  out << "ProcessTerminateEvent(";
+  out << "processId=" << to_string(obj.processId);
+  out << ", " << "gatewayId=" << to_string(obj.gatewayId);
+  out << ", " << "tokenId=" << to_string(obj.tokenId);
+  out << ")";
+  return out;
+}
+
+
+JobStatusChangeEvent::~JobStatusChangeEvent() throw() {
+}
+
+
+void JobStatusChangeEvent::__set_state(const  ::apache::airavata::model::status::JobState::type val) {
+  this->state = val;
+}
+
+void JobStatusChangeEvent::__set_jobIdentity(const JobIdentifier& val) {
+  this->jobIdentity = val;
+}
+
+const char* JobStatusChangeEvent::ascii_fingerprint = "062775D589B60D1687103FD465B0F5E8";
+const uint8_t JobStatusChangeEvent::binary_fingerprint[16] = {0x06,0x27,0x75,0xD5,0x89,0xB6,0x0D,0x16,0x87,0x10,0x3F,0xD4,0x65,0xB0,0xF5,0xE8};
+
+uint32_t JobStatusChangeEvent::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_state = false;
+  bool isset_jobIdentity = 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_I32) {
+          int32_t ecast33;
+          xfer += iprot->readI32(ecast33);
+          this->state = ( ::apache::airavata::model::status::JobState::type)ecast33;
+          isset_state = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->jobIdentity.read(iprot);
+          isset_jobIdentity = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_state)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_jobIdentity)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t JobStatusChangeEvent::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
+  xfer += oprot->writeStructBegin("JobStatusChangeEvent");
+
+  xfer += oprot->writeFieldBegin("state", ::apache::thrift::protocol::T_I32, 1);
+  xfer += oprot->writeI32((int32_t)this->state);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("jobIdentity", ::apache::thrift::protocol::T_STRUCT, 2);
+  xfer += this->jobIdentity.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
+  return xfer;
+}
+
+void swap(JobStatusChangeEvent &a, JobStatusChangeEvent &b) {
+  using ::std::swap;
+  swap(a.state, b.state);
+  swap(a.jobIdentity, b.jobIdentity);
+}
+
+JobStatusChangeEvent::JobStatusChangeEvent(const JobStatusChangeEvent& other34) {
+  state = other34.state;
+  jobIdentity = other34.jobIdentity;
+}
+JobStatusChangeEvent& JobStatusChangeEvent::operator=(const JobStatusChangeEvent& other35) {
+  state = other35.state;
+  jobIdentity = other35.jobIdentity;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const JobStatusChangeEvent& obj) {
+  using apache::thrift::to_string;
+  out << "JobStatusChangeEvent(";
+  out << "state=" << to_string(obj.state);
+  out << ", " << "jobIdentity=" << to_string(obj.jobIdentity);
+  out << ")";
+  return out;
+}
+
+
+JobStatusChangeRequestEvent::~JobStatusChangeRequestEvent() throw() {
+}
+
+
+void JobStatusChangeRequestEvent::__set_state(const  ::apache::airavata::model::status::JobState::type val) {
+  this->state = val;
+}
+
+void JobStatusChangeRequestEvent::__set_jobIdentity(const JobIdentifier& val) {
+  this->jobIdentity = val;
+}
+
+const char* JobStatusChangeRequestEvent::ascii_fingerprint = "062775D589B60D1687103FD465B0F5E8";
+const uint8_t JobStatusChangeRequestEvent::binary_fingerprint[16] = {0x06,0x27,0x75,0xD5,0x89,0xB6,0x0D,0x16,0x87,0x10,0x3F,0xD4,0x65,0xB0,0xF5,0xE8};
+
+uint32_t JobStatusChangeRequestEvent::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_state = false;
+  bool isset_jobIdentity = 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_I32) {
+          int32_t ecast36;
+          xfer += iprot->readI32(ecast36);
+          this->state = ( ::apache::airavata::model::status::JobState::type)ecast36;
+          isset_state = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->jobIdentity.read(iprot);
+          isset_jobIdentity = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_state)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_jobIdentity)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t JobStatusChangeRequestEvent::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
+  xfer += oprot->writeStructBegin("JobStatusChangeRequestEvent");
+
+  xfer += oprot->writeFieldBegin("state", ::apache::thrift::protocol::T_I32, 1);
+  xfer += oprot->writeI32((int32_t)this->state);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("jobIdentity", ::apache::thrift::protocol::T_STRUCT, 2);
+  xfer += this->jobIdentity.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
+  return xfer;
+}
+
+void swap(JobStatusChangeRequestEvent &a, JobStatusChangeRequestEvent &b) {
+  using ::std::swap;
+  swap(a.state, b.state);
+  swap(a.jobIdentity, b.jobIdentity);
+}
+
+JobStatusChangeRequestEvent::JobStatusChangeRequestEvent(const JobStatusChangeRequestEvent& other37) {
+  state = other37.state;
+  jobIdentity = other37.jobIdentity;
+}
+JobStatusChangeRequestEvent& JobStatusChangeRequestEvent::operator=(const JobStatusChangeRequestEvent& other38) {
+  state = other38.state;
+  jobIdentity = other38.jobIdentity;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const JobStatusChangeRequestEvent& obj) {
+  using apache::thrift::to_string;
+  out << "JobStatusChangeRequestEvent(";
+  out << "state=" << to_string(obj.state);
+  out << ", " << "jobIdentity=" << to_string(obj.jobIdentity);
+  out << ")";
+  return out;
+}
+
+
+Message::~Message() throw() {
+}
+
+
+void Message::__set_event(const std::string& val) {
+  this->event = val;
+}
+
+void Message::__set_messageId(const std::string& val) {
+  this->messageId = val;
+}
+
+void Message::__set_messageType(const MessageType::type val) {
+  this->messageType = val;
+}
+
+void Message::__set_updatedTime(const int64_t val) {
+  this->updatedTime = val;
+__isset.updatedTime = true;
+}
+
+void Message::__set_messageLevel(const MessageLevel::type val) {
+  this->messageLevel = val;
+__isset.messageLevel = true;
+}
+
+const char* Message::ascii_fingerprint = "6904C391426E568AF9DEAF69860C076A";
+const uint8_t Message::binary_fingerprint[16] = {0x69,0x04,0xC3,0x91,0x42,0x6E,0x56,0x8A,0xF9,0xDE,0xAF,0x69,0x86,0x0C,0x07,0x6A};
+
+uint32_t Message::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_event = false;
+  bool isset_messageId = false;
+  bool isset_messageType = 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->readBinary(this->event);
+          isset_event = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->messageId);
+          isset_messageId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          int32_t ecast39;
+          xfer += iprot->readI32(ecast39);
+          this->messageType = (MessageType::type)ecast39;
+          isset_messageType = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_I64) {
+          xfer += iprot->readI64(this->updatedTime);
+          this->__isset.updatedTime = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 5:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          int32_t ecast40;
+          xfer += iprot->readI32(ecast40);
+          this->messageLevel = (MessageLevel::type)ecast40;
+          this->__isset.messageLevel = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_event)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_messageId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_messageType)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t Message::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
+  xfer += oprot->writeStructBegin("Message");
+
+  xfer += oprot->writeFieldBegin("event", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeBinary(this->event);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("messageId", ::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeString(this->messageId);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("messageType", ::apache::thrift::protocol::T_I32, 3);
+  xfer += oprot->writeI32((int32_t)this->messageType);
+  xfer += oprot->writeFieldEnd();
+
+  if (this->__isset.updatedTime) {
+    xfer += oprot->writeFieldBegin("updatedTime", ::apache::thrift::protocol::T_I64, 4);
+    xfer += oprot->writeI64(this->updatedTime);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.messageLevel) {
+    xfer += oprot->writeFieldBegin("messageLevel", ::apache::thrift::protocol::T_I32, 5);
+    xfer += oprot->writeI32((int32_t)this->messageLevel);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
+  return xfer;
+}
+
+void swap(Message &a, Message &b) {
+  using ::std::swap;
+  swap(a.event, b.event);
+  swap(a.messageId, b.messageId);
+  swap(a.messageType, b.messageType);
+  swap(a.updatedTime, b.updatedTime);
+  swap(a.messageLevel, b.messageLevel);
+  swap(a.__isset, b.__isset);
+}
+
+Message::Message(const Message& other41) {
+  event = other41.event;
+  messageId = other41.messageId;
+  messageType = other41.messageType;
+  updatedTime = other41.updatedTime;
+  messageLevel = other41.messageLevel;
+  __isset = other41.__isset;
+}
+Message& Message::operator=(const Message& other42) {
+  event = other42.event;
+  messageId = other42.messageId;
+  messageType = other42.messageType;
+  updatedTime = other42.updatedTime;
+  messageLevel = other42.messageLevel;
+  __isset = other42.__isset;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const Message& obj) {
+  using apache::thrift::to_string;
+  out << "Message(";
+  out << "event=" << to_string(obj.event);
+  out << ", " << "messageId=" << to_string(obj.messageId);
+  out << ", " << "messageType=" << to_string(obj.messageType);
+  out << ", " << "updatedTime="; (obj.__isset.updatedTime ? (out << to_string(obj.updatedTime)) : (out << "<null>"));
+  out << ", " << "messageLevel="; (obj.__isset.messageLevel ? (out << to_string(obj.messageLevel)) : (out << "<null>"));
+  out << ")";
+  return out;
+}
+
+}}}}} // namespace

http://git-wip-us.apache.org/repos/asf/airavata/blob/dc524490/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/messaging_events_types.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/messaging_events_types.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/messaging_events_types.h
new file mode 100644
index 0000000..33071ac
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/messaging_events_types.h
@@ -0,0 +1,756 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Autogenerated by Thrift Compiler (0.9.2)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+#ifndef messaging_events_TYPES_H
+#define messaging_events_TYPES_H
+
+#include <iosfwd>
+
+#include <thrift/Thrift.h>
+#include <thrift/TApplicationException.h>
+#include <thrift/protocol/TProtocol.h>
+#include <thrift/transport/TTransport.h>
+
+#include <thrift/cxxfunctional.h>
+#include "status_models_types.h"
+#include "application_io_models_types.h"
+#include "airavata_commons_types.h"
+
+
+namespace apache { namespace airavata { namespace model { namespace messaging { namespace event {
+
+struct MessageLevel {
+  enum type {
+    INFO = 0,
+    DEBUG = 1,
+    ERROR = 2,
+    ACK = 3
+  };
+};
+
+extern const std::map<int, const char*> _MessageLevel_VALUES_TO_NAMES;
+
+struct MessageType {
+  enum type {
+    EXPERIMENT = 0,
+    TASK = 1,
+    PROCESS = 2,
+    JOB = 3,
+    LAUNCHPROCESS = 4,
+    TERMINATEPROCESS = 5,
+    PROCESSOUTPUT = 6
+  };
+};
+
+extern const std::map<int, const char*> _MessageType_VALUES_TO_NAMES;
+
+class ExperimentStatusChangeEvent;
+
+class ProcessIdentifier;
+
+class TaskIdentifier;
+
+class TaskStatusChangeEvent;
+
+class TaskStatusChangeRequestEvent;
+
+class ProcessStatusChangeEvent;
+
+class ProcessStatusChangeRequestEvent;
+
+class TaskOutputChangeEvent;
+
+class JobIdentifier;
+
+class ProcessSubmitEvent;
+
+class ProcessTerminateEvent;
+
+class JobStatusChangeEvent;
+
+class JobStatusChangeRequestEvent;
+
+class Message;
+
+
+class ExperimentStatusChangeEvent {
+ public:
+
+  static const char* ascii_fingerprint; // = "38C252E94E93B69D04EB3A6EE2F9EDFB";
+  static const uint8_t binary_fingerprint[16]; // = {0x38,0xC2,0x52,0xE9,0x4E,0x93,0xB6,0x9D,0x04,0xEB,0x3A,0x6E,0xE2,0xF9,0xED,0xFB};
+
+  ExperimentStatusChangeEvent(const ExperimentStatusChangeEvent&);
+  ExperimentStatusChangeEvent& operator=(const ExperimentStatusChangeEvent&);
+  ExperimentStatusChangeEvent() : state(( ::apache::airavata::model::status::ExperimentState::type)0), experimentId(), gatewayId() {
+  }
+
+  virtual ~ExperimentStatusChangeEvent() throw();
+   ::apache::airavata::model::status::ExperimentState::type state;
+  std::string experimentId;
+  std::string gatewayId;
+
+  void __set_state(const  ::apache::airavata::model::status::ExperimentState::type val);
+
+  void __set_experimentId(const std::string& val);
+
+  void __set_gatewayId(const std::string& val);
+
+  bool operator == (const ExperimentStatusChangeEvent & rhs) const
+  {
+    if (!(state == rhs.state))
+      return false;
+    if (!(experimentId == rhs.experimentId))
+      return false;
+    if (!(gatewayId == rhs.gatewayId))
+      return false;
+    return true;
+  }
+  bool operator != (const ExperimentStatusChangeEvent &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ExperimentStatusChangeEvent & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  friend std::ostream& operator<<(std::ostream& out, const ExperimentStatusChangeEvent& obj);
+};
+
+void swap(ExperimentStatusChangeEvent &a, ExperimentStatusChangeEvent &b);
+
+
+class ProcessIdentifier {
+ public:
+
+  static const char* ascii_fingerprint; // = "AB879940BD15B6B25691265F7384B271";
+  static const uint8_t binary_fingerprint[16]; // = {0xAB,0x87,0x99,0x40,0xBD,0x15,0xB6,0xB2,0x56,0x91,0x26,0x5F,0x73,0x84,0xB2,0x71};
+
+  ProcessIdentifier(const ProcessIdentifier&);
+  ProcessIdentifier& operator=(const ProcessIdentifier&);
+  ProcessIdentifier() : processId(), experimentId(), gatewayId() {
+  }
+
+  virtual ~ProcessIdentifier() throw();
+  std::string processId;
+  std::string experimentId;
+  std::string gatewayId;
+
+  void __set_processId(const std::string& val);
+
+  void __set_experimentId(const std::string& val);
+
+  void __set_gatewayId(const std::string& val);
+
+  bool operator == (const ProcessIdentifier & rhs) const
+  {
+    if (!(processId == rhs.processId))
+      return false;
+    if (!(experimentId == rhs.experimentId))
+      return false;
+    if (!(gatewayId == rhs.gatewayId))
+      return false;
+    return true;
+  }
+  bool operator != (const ProcessIdentifier &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ProcessIdentifier & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  friend std::ostream& operator<<(std::ostream& out, const ProcessIdentifier& obj);
+};
+
+void swap(ProcessIdentifier &a, ProcessIdentifier &b);
+
+
+class TaskIdentifier {
+ public:
+
+  static const char* ascii_fingerprint; // = "C93D890311F28844166CF6E571EB3AC2";
+  static const uint8_t binary_fingerprint[16]; // = {0xC9,0x3D,0x89,0x03,0x11,0xF2,0x88,0x44,0x16,0x6C,0xF6,0xE5,0x71,0xEB,0x3A,0xC2};
+
+  TaskIdentifier(const TaskIdentifier&);
+  TaskIdentifier& operator=(const TaskIdentifier&);
+  TaskIdentifier() : taskId(), processId(), experimentId(), gatewayId() {
+  }
+
+  virtual ~TaskIdentifier() throw();
+  std::string taskId;
+  std::string processId;
+  std::string experimentId;
+  std::string gatewayId;
+
+  void __set_taskId(const std::string& val);
+
+  void __set_processId(const std::string& val);
+
+  void __set_experimentId(const std::string& val);
+
+  void __set_gatewayId(const std::string& val);
+
+  bool operator == (const TaskIdentifier & rhs) const
+  {
+    if (!(taskId == rhs.taskId))
+      return false;
+    if (!(processId == rhs.processId))
+      return false;
+    if (!(experimentId == rhs.experimentId))
+      return false;
+    if (!(gatewayId == rhs.gatewayId))
+      return false;
+    return true;
+  }
+  bool operator != (const TaskIdentifier &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const TaskIdentifier & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  friend std::ostream& operator<<(std::ostream& out, const TaskIdentifier& obj);
+};
+
+void swap(TaskIdentifier &a, TaskIdentifier &b);
+
+
+class TaskStatusChangeEvent {
+ public:
+
+  static const char* ascii_fingerprint; // = "8D18A3CD1822DBC67D7BD8CB98E7B4F1";
+  static const uint8_t binary_fingerprint[16]; // = {0x8D,0x18,0xA3,0xCD,0x18,0x22,0xDB,0xC6,0x7D,0x7B,0xD8,0xCB,0x98,0xE7,0xB4,0xF1};
+
+  TaskStatusChangeEvent(const TaskStatusChangeEvent&);
+  TaskStatusChangeEvent& operator=(const TaskStatusChangeEvent&);
+  TaskStatusChangeEvent() : state(( ::apache::airavata::model::status::TaskState::type)0) {
+  }
+
+  virtual ~TaskStatusChangeEvent() throw();
+   ::apache::airavata::model::status::TaskState::type state;
+  TaskIdentifier taskIdentity;
+
+  void __set_state(const  ::apache::airavata::model::status::TaskState::type val);
+
+  void __set_taskIdentity(const TaskIdentifier& val);
+
+  bool operator == (const TaskStatusChangeEvent & rhs) const
+  {
+    if (!(state == rhs.state))
+      return false;
+    if (!(taskIdentity == rhs.taskIdentity))
+      return false;
+    return true;
+  }
+  bool operator != (const TaskStatusChangeEvent &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const TaskStatusChangeEvent & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  friend std::ostream& operator<<(std::ostream& out, const TaskStatusChangeEvent& obj);
+};
+
+void swap(TaskStatusChangeEvent &a, TaskStatusChangeEvent &b);
+
+
+class TaskStatusChangeRequestEvent {
+ public:
+
+  static const char* ascii_fingerprint; // = "8D18A3CD1822DBC67D7BD8CB98E7B4F1";
+  static const uint8_t binary_fingerprint[16]; // = {0x8D,0x18,0xA3,0xCD,0x18,0x22,0xDB,0xC6,0x7D,0x7B,0xD8,0xCB,0x98,0xE7,0xB4,0xF1};
+
+  TaskStatusChangeRequestEvent(const TaskStatusChangeRequestEvent&);
+  TaskStatusChangeRequestEvent& operator=(const TaskStatusChangeRequestEvent&);
+  TaskStatusChangeRequestEvent() : state(( ::apache::airavata::model::status::TaskState::type)0) {
+  }
+
+  virtual ~TaskStatusChangeRequestEvent() throw();
+   ::apache::airavata::model::status::TaskState::type state;
+  TaskIdentifier taskIdentity;
+
+  void __set_state(const  ::apache::airavata::model::status::TaskState::type val);
+
+  void __set_taskIdentity(const TaskIdentifier& val);
+
+  bool operator == (const TaskStatusChangeRequestEvent & rhs) const
+  {
+    if (!(state == rhs.state))
+      return false;
+    if (!(taskIdentity == rhs.taskIdentity))
+      return false;
+    return true;
+  }
+  bool operator != (const TaskStatusChangeRequestEvent &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const TaskStatusChangeRequestEvent & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  friend std::ostream& operator<<(std::ostream& out, const TaskStatusChangeRequestEvent& obj);
+};
+
+void swap(TaskStatusChangeRequestEvent &a, TaskStatusChangeRequestEvent &b);
+
+
+class ProcessStatusChangeEvent {
+ public:
+
+  static const char* ascii_fingerprint; // = "9686679C94D43D75F2B35A0BED2E4003";
+  static const uint8_t binary_fingerprint[16]; // = {0x96,0x86,0x67,0x9C,0x94,0xD4,0x3D,0x75,0xF2,0xB3,0x5A,0x0B,0xED,0x2E,0x40,0x03};
+
+  ProcessStatusChangeEvent(const ProcessStatusChangeEvent&);
+  ProcessStatusChangeEvent& operator=(const ProcessStatusChangeEvent&);
+  ProcessStatusChangeEvent() : state(( ::apache::airavata::model::status::ProcessState::type)0) {
+  }
+
+  virtual ~ProcessStatusChangeEvent() throw();
+   ::apache::airavata::model::status::ProcessState::type state;
+  ProcessIdentifier processIdentity;
+
+  void __set_state(const  ::apache::airavata::model::status::ProcessState::type val);
+
+  void __set_processIdentity(const ProcessIdentifier& val);
+
+  bool operator == (const ProcessStatusChangeEvent & rhs) const
+  {
+    if (!(state == rhs.state))
+      return false;
+    if (!(processIdentity == rhs.processIdentity))
+      return false;
+    return true;
+  }
+  bool operator != (const ProcessStatusChangeEvent &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ProcessStatusChangeEvent & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  friend std::ostream& operator<<(std::ostream& out, const ProcessStatusChangeEvent& obj);
+};
+
+void swap(ProcessStatusChangeEvent &a, ProcessStatusChangeEvent &b);
+
+
+class ProcessStatusChangeRequestEvent {
+ public:
+
+  static const char* ascii_fingerprint; // = "9686679C94D43D75F2B35A0BED2E4003";
+  static const uint8_t binary_fingerprint[16]; // = {0x96,0x86,0x67,0x9C,0x94,0xD4,0x3D,0x75,0xF2,0xB3,0x5A,0x0B,0xED,0x2E,0x40,0x03};
+
+  ProcessStatusChangeRequestEvent(const ProcessStatusChangeRequestEvent&);
+  ProcessStatusChangeRequestEvent& operator=(const ProcessStatusChangeRequestEvent&);
+  ProcessStatusChangeRequestEvent() : state(( ::apache::airavata::model::status::ProcessState::type)0) {
+  }
+
+  virtual ~ProcessStatusChangeRequestEvent() throw();
+   ::apache::airavata::model::status::ProcessState::type state;
+  ProcessIdentifier processIdentity;
+
+  void __set_state(const  ::apache::airavata::model::status::ProcessState::type val);
+
+  void __set_processIdentity(const ProcessIdentifier& val);
+
+  bool operator == (const ProcessStatusChangeRequestEvent & rhs) const
+  {
+    if (!(state == rhs.state))
+      return false;
+    if (!(processIdentity == rhs.processIdentity))
+      return false;
+    return true;
+  }
+  bool operator != (const ProcessStatusChangeRequestEvent &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ProcessStatusChangeRequestEvent & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  friend std::ostream& operator<<(std::ostream& out, const ProcessStatusChangeRequestEvent& obj);
+};
+
+void swap(ProcessStatusChangeRequestEvent &a, ProcessStatusChangeRequestEvent &b);
+
+
+class TaskOutputChangeEvent {
+ public:
+
+  static const char* ascii_fingerprint; // = "C7C71D05D69F7D8C4A11C9E432FF5A51";
+  static const uint8_t binary_fingerprint[16]; // = {0xC7,0xC7,0x1D,0x05,0xD6,0x9F,0x7D,0x8C,0x4A,0x11,0xC9,0xE4,0x32,0xFF,0x5A,0x51};
+
+  TaskOutputChangeEvent(const TaskOutputChangeEvent&);
+  TaskOutputChangeEvent& operator=(const TaskOutputChangeEvent&);
+  TaskOutputChangeEvent() {
+  }
+
+  virtual ~TaskOutputChangeEvent() throw();
+  std::vector< ::apache::airavata::model::application::io::OutputDataObjectType>  output;
+  TaskIdentifier taskIdentity;
+
+  void __set_output(const std::vector< ::apache::airavata::model::application::io::OutputDataObjectType> & val);
+
+  void __set_taskIdentity(const TaskIdentifier& val);
+
+  bool operator == (const TaskOutputChangeEvent & rhs) const
+  {
+    if (!(output == rhs.output))
+      return false;
+    if (!(taskIdentity == rhs.taskIdentity))
+      return false;
+    return true;
+  }
+  bool operator != (const TaskOutputChangeEvent &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const TaskOutputChangeEvent & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  friend std::ostream& operator<<(std::ostream& out, const TaskOutputChangeEvent& obj);
+};
+
+void swap(TaskOutputChangeEvent &a, TaskOutputChangeEvent &b);
+
+
+class JobIdentifier {
+ public:
+
+  static const char* ascii_fingerprint; // = "BFF0E21728CB005F9AA5774A41542B8D";
+  static const uint8_t binary_fingerprint[16]; // = {0xBF,0xF0,0xE2,0x17,0x28,0xCB,0x00,0x5F,0x9A,0xA5,0x77,0x4A,0x41,0x54,0x2B,0x8D};
+
+  JobIdentifier(const JobIdentifier&);
+  JobIdentifier& operator=(const JobIdentifier&);
+  JobIdentifier() : jobId(), taskId(), processId(), experimentId(), gatewayId() {
+  }
+
+  virtual ~JobIdentifier() throw();
+  std::string jobId;
+  std::string taskId;
+  std::string processId;
+  std::string experimentId;
+  std::string gatewayId;
+
+  void __set_jobId(const std::string& val);
+
+  void __set_taskId(const std::string& val);
+
+  void __set_processId(const std::string& val);
+
+  void __set_experimentId(const std::string& val);
+
+  void __set_gatewayId(const std::string& val);
+
+  bool operator == (const JobIdentifier & rhs) const
+  {
+    if (!(jobId == rhs.jobId))
+      return false;
+    if (!(taskId == rhs.taskId))
+      return false;
+    if (!(processId == rhs.processId))
+      return false;
+    if (!(experimentId == rhs.experimentId))
+      return false;
+    if (!(gatewayId == rhs.gatewayId))
+      return false;
+    return true;
+  }
+  bool operator != (const JobIdentifier &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const JobIdentifier & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  friend std::ostream& operator<<(std::ostream& out, const JobIdentifier& obj);
+};
+
+void swap(JobIdentifier &a, JobIdentifier &b);
+
+
+class ProcessSubmitEvent {
+ public:
+
+  static const char* ascii_fingerprint; // = "AB879940BD15B6B25691265F7384B271";
+  static const uint8_t binary_fingerprint[16]; // = {0xAB,0x87,0x99,0x40,0xBD,0x15,0xB6,0xB2,0x56,0x91,0x26,0x5F,0x73,0x84,0xB2,0x71};
+
+  ProcessSubmitEvent(const ProcessSubmitEvent&);
+  ProcessSubmitEvent& operator=(const ProcessSubmitEvent&);
+  ProcessSubmitEvent() : processId(), gatewayId(), tokenId() {
+  }
+
+  virtual ~ProcessSubmitEvent() throw();
+  std::string processId;
+  std::string gatewayId;
+  std::string tokenId;
+
+  void __set_processId(const std::string& val);
+
+  void __set_gatewayId(const std::string& val);
+
+  void __set_tokenId(const std::string& val);
+
+  bool operator == (const ProcessSubmitEvent & rhs) const
+  {
+    if (!(processId == rhs.processId))
+      return false;
+    if (!(gatewayId == rhs.gatewayId))
+      return false;
+    if (!(tokenId == rhs.tokenId))
+      return false;
+    return true;
+  }
+  bool operator != (const ProcessSubmitEvent &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ProcessSubmitEvent & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  friend std::ostream& operator<<(std::ostream& out, const ProcessSubmitEvent& obj);
+};
+
+void swap(ProcessSubmitEvent &a, ProcessSubmitEvent &b);
+
+
+class ProcessTerminateEvent {
+ public:
+
+  static const char* ascii_fingerprint; // = "AB879940BD15B6B25691265F7384B271";
+  static const uint8_t binary_fingerprint[16]; // = {0xAB,0x87,0x99,0x40,0xBD,0x15,0xB6,0xB2,0x56,0x91,0x26,0x5F,0x73,0x84,0xB2,0x71};
+
+  ProcessTerminateEvent(const ProcessTerminateEvent&);
+  ProcessTerminateEvent& operator=(const ProcessTerminateEvent&);
+  ProcessTerminateEvent() : processId(), gatewayId(), tokenId() {
+  }
+
+  virtual ~ProcessTerminateEvent() throw();
+  std::string processId;
+  std::string gatewayId;
+  std::string tokenId;
+
+  void __set_processId(const std::string& val);
+
+  void __set_gatewayId(const std::string& val);
+
+  void __set_tokenId(const std::string& val);
+
+  bool operator == (const ProcessTerminateEvent & rhs) const
+  {
+    if (!(processId == rhs.processId))
+      return false;
+    if (!(gatewayId == rhs.gatewayId))
+      return false;
+    if (!(tokenId == rhs.tokenId))
+      return false;
+    return true;
+  }
+  bool operator != (const ProcessTerminateEvent &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ProcessTerminateEvent & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  friend std::ostream& operator<<(std::ostream& out, const ProcessTerminateEvent& obj);
+};
+
+void swap(ProcessTerminateEvent &a, ProcessTerminateEvent &b);
+
+
+class JobStatusChangeEvent {
+ public:
+
+  static const char* ascii_fingerprint; // = "062775D589B60D1687103FD465B0F5E8";
+  static const uint8_t binary_fingerprint[16]; // = {0x06,0x27,0x75,0xD5,0x89,0xB6,0x0D,0x16,0x87,0x10,0x3F,0xD4,0x65,0xB0,0xF5,0xE8};
+
+  JobStatusChangeEvent(const JobStatusChangeEvent&);
+  JobStatusChangeEvent& operator=(const JobStatusChangeEvent&);
+  JobStatusChangeEvent() : state(( ::apache::airavata::model::status::JobState::type)0) {
+  }
+
+  virtual ~JobStatusChangeEvent() throw();
+   ::apache::airavata::model::status::JobState::type state;
+  JobIdentifier jobIdentity;
+
+  void __set_state(const  ::apache::airavata::model::status::JobState::type val);
+
+  void __set_jobIdentity(const JobIdentifier& val);
+
+  bool operator == (const JobStatusChangeEvent & rhs) const
+  {
+    if (!(state == rhs.state))
+      return false;
+    if (!(jobIdentity == rhs.jobIdentity))
+      return false;
+    return true;
+  }
+  bool operator != (const JobStatusChangeEvent &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const JobStatusChangeEvent & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  friend std::ostream& operator<<(std::ostream& out, const JobStatusChangeEvent& obj);
+};
+
+void swap(JobStatusChangeEvent &a, JobStatusChangeEvent &b);
+
+
+class JobStatusChangeRequestEvent {
+ public:
+
+  static const char* ascii_fingerprint; // = "062775D589B60D1687103FD465B0F5E8";
+  static const uint8_t binary_fingerprint[16]; // = {0x06,0x27,0x75,0xD5,0x89,0xB6,0x0D,0x16,0x87,0x10,0x3F,0xD4,0x65,0xB0,0xF5,0xE8};
+
+  JobStatusChangeRequestEvent(const JobStatusChangeRequestEvent&);
+  JobStatusChangeRequestEvent& operator=(const JobStatusChangeRequestEvent&);
+  JobStatusChangeRequestEvent() : state(( ::apache::airavata::model::status::JobState::type)0) {
+  }
+
+  virtual ~JobStatusChangeRequestEvent() throw();
+   ::apache::airavata::model::status::JobState::type state;
+  JobIdentifier jobIdentity;
+
+  void __set_state(const  ::apache::airavata::model::status::JobState::type val);
+
+  void __set_jobIdentity(const JobIdentifier& val);
+
+  bool operator == (const JobStatusChangeRequestEvent & rhs) const
+  {
+    if (!(state == rhs.state))
+      return false;
+    if (!(jobIdentity == rhs.jobIdentity))
+      return false;
+    return true;
+  }
+  bool operator != (const JobStatusChangeRequestEvent &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const JobStatusChangeRequestEvent & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  friend std::ostream& operator<<(std::ostream& out, const JobStatusChangeRequestEvent& obj);
+};
+
+void swap(JobStatusChangeRequestEvent &a, JobStatusChangeRequestEvent &b);
+
+typedef struct _Message__isset {
+  _Message__isset() : updatedTime(false), messageLevel(false) {}
+  bool updatedTime :1;
+  bool messageLevel :1;
+} _Message__isset;
+
+class Message {
+ public:
+
+  static const char* ascii_fingerprint; // = "6904C391426E568AF9DEAF69860C076A";
+  static const uint8_t binary_fingerprint[16]; // = {0x69,0x04,0xC3,0x91,0x42,0x6E,0x56,0x8A,0xF9,0xDE,0xAF,0x69,0x86,0x0C,0x07,0x6A};
+
+  Message(const Message&);
+  Message& operator=(const Message&);
+  Message() : event(), messageId("DO_NOT_SET_AT_CLIENTS"), messageType((MessageType::type)0), updatedTime(0), messageLevel((MessageLevel::type)0) {
+  }
+
+  virtual ~Message() throw();
+  std::string event;
+  std::string messageId;
+  MessageType::type messageType;
+  int64_t updatedTime;
+  MessageLevel::type messageLevel;
+
+  _Message__isset __isset;
+
+  void __set_event(const std::string& val);
+
+  void __set_messageId(const std::string& val);
+
+  void __set_messageType(const MessageType::type val);
+
+  void __set_updatedTime(const int64_t val);
+
+  void __set_messageLevel(const MessageLevel::type val);
+
+  bool operator == (const Message & rhs) const
+  {
+    if (!(event == rhs.event))
+      return false;
+    if (!(messageId == rhs.messageId))
+      return false;
+    if (!(messageType == rhs.messageType))
+      return false;
+    if (__isset.updatedTime != rhs.__isset.updatedTime)
+      return false;
+    else if (__isset.updatedTime && !(updatedTime == rhs.updatedTime))
+      return false;
+    if (__isset.messageLevel != rhs.__isset.messageLevel)
+      return false;
+    else if (__isset.messageLevel && !(messageLevel == rhs.messageLevel))
+      return false;
+    return true;
+  }
+  bool operator != (const Message &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Message & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  friend std::ostream& operator<<(std::ostream& out, const Message& obj);
+};
+
+void swap(Message &a, Message &b);
+
+}}}}} // namespace
+
+#endif

http://git-wip-us.apache.org/repos/asf/airavata/blob/dc524490/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/process_model_constants.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/process_model_constants.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/process_model_constants.cpp
new file mode 100644
index 0000000..15f2235
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/process_model_constants.cpp
@@ -0,0 +1,34 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Autogenerated by Thrift Compiler (0.9.2)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+#include "process_model_constants.h"
+
+namespace apache { namespace airavata { namespace model { namespace process {
+
+const process_modelConstants g_process_model_constants;
+
+process_modelConstants::process_modelConstants() {
+}
+
+}}}} // namespace
+