You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@airavata.apache.org by sm...@apache.org on 2014/07/12 06:08:32 UTC
[14/47] Added c++ client samples for integrattion of airavata with
any other application's c++ interface
http://git-wip-us.apache.org/repos/asf/airavata/blob/f891b7dc/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/experimentModel_types.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/experimentModel_types.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/experimentModel_types.h
new file mode 100644
index 0000000..42a6005
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/experimentModel_types.h
@@ -0,0 +1,2077 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+#ifndef experimentModel_TYPES_H
+#define experimentModel_TYPES_H
+
+#include <thrift/Thrift.h>
+#include <thrift/TApplicationException.h>
+#include <thrift/protocol/TProtocol.h>
+#include <thrift/transport/TTransport.h>
+
+#include <thrift/cxxfunctional.h>
+#include "computeResourceModel_types.h"
+
+
+namespace apache { namespace airavata { namespace model { namespace workspace { namespace experiment {
+
+struct ExperimentState {
+ enum type {
+ CREATED = 0,
+ VALIDATED = 1,
+ SCHEDULED = 2,
+ LAUNCHED = 3,
+ EXECUTING = 4,
+ CANCELING = 5,
+ CANCELED = 6,
+ SUSPENDED = 7,
+ COMPLETED = 8,
+ FAILED = 9,
+ UNKNOWN = 10
+ };
+};
+
+extern const std::map<int, const char*> _ExperimentState_VALUES_TO_NAMES;
+
+struct WorkflowNodeState {
+ enum type {
+ INVOKED = 0,
+ EXECUTING = 1,
+ CANCELING = 2,
+ CANCELED = 3,
+ SUSPENDED = 4,
+ COMPLETED = 5,
+ FAILED = 6,
+ UNKNOWN = 7
+ };
+};
+
+extern const std::map<int, const char*> _WorkflowNodeState_VALUES_TO_NAMES;
+
+struct TaskState {
+ enum type {
+ WAITING = 0,
+ STARTED = 1,
+ PRE_PROCESSING = 2,
+ CONFIGURING_WORKSPACE = 3,
+ INPUT_DATA_STAGING = 4,
+ OUTPUT_DATA_STAGING = 5,
+ POST_PROCESSING = 6,
+ EXECUTING = 7,
+ CANCELING = 8,
+ CANCELED = 9,
+ COMPLETED = 10,
+ FAILED = 11,
+ UNKNOWN = 12
+ };
+};
+
+extern const std::map<int, const char*> _TaskState_VALUES_TO_NAMES;
+
+struct JobState {
+ enum type {
+ SUBMITTED = 0,
+ UN_SUBMITTED = 1,
+ SETUP = 2,
+ QUEUED = 3,
+ ACTIVE = 4,
+ COMPLETE = 5,
+ CANCELING = 6,
+ CANCELED = 7,
+ FAILED = 8,
+ HELD = 9,
+ SUSPENDED = 10,
+ UNKNOWN = 11
+ };
+};
+
+extern const std::map<int, const char*> _JobState_VALUES_TO_NAMES;
+
+struct TransferState {
+ enum type {
+ DIRECTORY_SETUP = 0,
+ UPLOAD = 1,
+ DOWNLOAD = 2,
+ ACTIVE = 3,
+ COMPLETE = 4,
+ STDOUT_DOWNLOAD = 5,
+ STDERROR_DOWNLOAD = 6,
+ CANCELING = 7,
+ CANCELED = 8,
+ FAILED = 9,
+ HELD = 10,
+ SUSPENDED = 11,
+ UNKNOWN = 12
+ };
+};
+
+extern const std::map<int, const char*> _TransferState_VALUES_TO_NAMES;
+
+struct ActionableGroup {
+ enum type {
+ RESOURCE_ADMINS = 0,
+ AIRAVATA_ADMINS = 1,
+ GATEWAYS_ADMINS = 2,
+ USER = 3,
+ CANNOT_BE_DETERMINED = 4
+ };
+};
+
+extern const std::map<int, const char*> _ActionableGroup_VALUES_TO_NAMES;
+
+struct ErrorCategory {
+ enum type {
+ FILE_SYSTEM_FAILURE = 0,
+ APPLICATION_FAILURE = 1,
+ RESOURCE_NODE_FAILURE = 2,
+ DISK_FULL = 3,
+ INSUFFICIENT_ALLOCATION = 4,
+ SYSTEM_MAINTENANCE = 5,
+ AIRAVATA_INTERNAL_ERROR = 6,
+ CANNOT_BE_DETERMINED = 7
+ };
+};
+
+extern const std::map<int, const char*> _ErrorCategory_VALUES_TO_NAMES;
+
+struct CorrectiveAction {
+ enum type {
+ RETRY_SUBMISSION = 0,
+ CONTACT_SUPPORT = 1,
+ CANNOT_BE_DETERMINED = 2
+ };
+};
+
+extern const std::map<int, const char*> _CorrectiveAction_VALUES_TO_NAMES;
+
+struct DataType {
+ enum type {
+ STRING = 0,
+ INTEGER = 1,
+ URI = 2,
+ STDOUT = 3,
+ STDERR = 4
+ };
+};
+
+extern const std::map<int, const char*> _DataType_VALUES_TO_NAMES;
+
+struct ExecutionUnit {
+ enum type {
+ INPUT = 0,
+ APPLICATION = 1,
+ OUTPUT = 2
+ };
+};
+
+extern const std::map<int, const char*> _ExecutionUnit_VALUES_TO_NAMES;
+
+typedef struct _ExperimentStatus__isset {
+ _ExperimentStatus__isset() : timeOfStateChange(false) {}
+ bool timeOfStateChange;
+} _ExperimentStatus__isset;
+
+class ExperimentStatus {
+ public:
+
+ static const char* ascii_fingerprint; // = "1662AAADFABAB647546029B578B3B69B";
+ static const uint8_t binary_fingerprint[16]; // = {0x16,0x62,0xAA,0xAD,0xFA,0xBA,0xB6,0x47,0x54,0x60,0x29,0xB5,0x78,0xB3,0xB6,0x9B};
+
+ ExperimentStatus() : experimentState((ExperimentState::type)0), timeOfStateChange(0) {
+ }
+
+ virtual ~ExperimentStatus() throw() {}
+
+ ExperimentState::type experimentState;
+ int64_t timeOfStateChange;
+
+ _ExperimentStatus__isset __isset;
+
+ void __set_experimentState(const ExperimentState::type val) {
+ experimentState = val;
+ }
+
+ void __set_timeOfStateChange(const int64_t val) {
+ timeOfStateChange = val;
+ __isset.timeOfStateChange = true;
+ }
+
+ bool operator == (const ExperimentStatus & rhs) const
+ {
+ if (!(experimentState == rhs.experimentState))
+ return false;
+ if (__isset.timeOfStateChange != rhs.__isset.timeOfStateChange)
+ return false;
+ else if (__isset.timeOfStateChange && !(timeOfStateChange == rhs.timeOfStateChange))
+ return false;
+ return true;
+ }
+ bool operator != (const ExperimentStatus &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ExperimentStatus & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(ExperimentStatus &a, ExperimentStatus &b);
+
+typedef struct _WorkflowNodeStatus__isset {
+ _WorkflowNodeStatus__isset() : timeOfStateChange(false) {}
+ bool timeOfStateChange;
+} _WorkflowNodeStatus__isset;
+
+class WorkflowNodeStatus {
+ public:
+
+ static const char* ascii_fingerprint; // = "1662AAADFABAB647546029B578B3B69B";
+ static const uint8_t binary_fingerprint[16]; // = {0x16,0x62,0xAA,0xAD,0xFA,0xBA,0xB6,0x47,0x54,0x60,0x29,0xB5,0x78,0xB3,0xB6,0x9B};
+
+ WorkflowNodeStatus() : workflowNodeState((WorkflowNodeState::type)0), timeOfStateChange(0) {
+ }
+
+ virtual ~WorkflowNodeStatus() throw() {}
+
+ WorkflowNodeState::type workflowNodeState;
+ int64_t timeOfStateChange;
+
+ _WorkflowNodeStatus__isset __isset;
+
+ void __set_workflowNodeState(const WorkflowNodeState::type val) {
+ workflowNodeState = val;
+ }
+
+ void __set_timeOfStateChange(const int64_t val) {
+ timeOfStateChange = val;
+ __isset.timeOfStateChange = true;
+ }
+
+ bool operator == (const WorkflowNodeStatus & rhs) const
+ {
+ if (!(workflowNodeState == rhs.workflowNodeState))
+ return false;
+ if (__isset.timeOfStateChange != rhs.__isset.timeOfStateChange)
+ return false;
+ else if (__isset.timeOfStateChange && !(timeOfStateChange == rhs.timeOfStateChange))
+ return false;
+ return true;
+ }
+ bool operator != (const WorkflowNodeStatus &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const WorkflowNodeStatus & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(WorkflowNodeStatus &a, WorkflowNodeStatus &b);
+
+typedef struct _TaskStatus__isset {
+ _TaskStatus__isset() : timeOfStateChange(false) {}
+ bool timeOfStateChange;
+} _TaskStatus__isset;
+
+class TaskStatus {
+ public:
+
+ static const char* ascii_fingerprint; // = "1662AAADFABAB647546029B578B3B69B";
+ static const uint8_t binary_fingerprint[16]; // = {0x16,0x62,0xAA,0xAD,0xFA,0xBA,0xB6,0x47,0x54,0x60,0x29,0xB5,0x78,0xB3,0xB6,0x9B};
+
+ TaskStatus() : executionState((TaskState::type)0), timeOfStateChange(0) {
+ }
+
+ virtual ~TaskStatus() throw() {}
+
+ TaskState::type executionState;
+ int64_t timeOfStateChange;
+
+ _TaskStatus__isset __isset;
+
+ void __set_executionState(const TaskState::type val) {
+ executionState = val;
+ }
+
+ void __set_timeOfStateChange(const int64_t val) {
+ timeOfStateChange = val;
+ __isset.timeOfStateChange = true;
+ }
+
+ bool operator == (const TaskStatus & rhs) const
+ {
+ if (!(executionState == rhs.executionState))
+ return false;
+ if (__isset.timeOfStateChange != rhs.__isset.timeOfStateChange)
+ return false;
+ else if (__isset.timeOfStateChange && !(timeOfStateChange == rhs.timeOfStateChange))
+ return false;
+ return true;
+ }
+ bool operator != (const TaskStatus &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const TaskStatus & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(TaskStatus &a, TaskStatus &b);
+
+typedef struct _JobStatus__isset {
+ _JobStatus__isset() : timeOfStateChange(false) {}
+ bool timeOfStateChange;
+} _JobStatus__isset;
+
+class JobStatus {
+ public:
+
+ static const char* ascii_fingerprint; // = "1662AAADFABAB647546029B578B3B69B";
+ static const uint8_t binary_fingerprint[16]; // = {0x16,0x62,0xAA,0xAD,0xFA,0xBA,0xB6,0x47,0x54,0x60,0x29,0xB5,0x78,0xB3,0xB6,0x9B};
+
+ JobStatus() : jobState((JobState::type)0), timeOfStateChange(0) {
+ }
+
+ virtual ~JobStatus() throw() {}
+
+ JobState::type jobState;
+ int64_t timeOfStateChange;
+
+ _JobStatus__isset __isset;
+
+ void __set_jobState(const JobState::type val) {
+ jobState = val;
+ }
+
+ void __set_timeOfStateChange(const int64_t val) {
+ timeOfStateChange = val;
+ __isset.timeOfStateChange = true;
+ }
+
+ bool operator == (const JobStatus & rhs) const
+ {
+ if (!(jobState == rhs.jobState))
+ return false;
+ if (__isset.timeOfStateChange != rhs.__isset.timeOfStateChange)
+ return false;
+ else if (__isset.timeOfStateChange && !(timeOfStateChange == rhs.timeOfStateChange))
+ return false;
+ return true;
+ }
+ bool operator != (const JobStatus &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const JobStatus & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(JobStatus &a, JobStatus &b);
+
+typedef struct _TransferStatus__isset {
+ _TransferStatus__isset() : timeOfStateChange(false) {}
+ bool timeOfStateChange;
+} _TransferStatus__isset;
+
+class TransferStatus {
+ public:
+
+ static const char* ascii_fingerprint; // = "1662AAADFABAB647546029B578B3B69B";
+ static const uint8_t binary_fingerprint[16]; // = {0x16,0x62,0xAA,0xAD,0xFA,0xBA,0xB6,0x47,0x54,0x60,0x29,0xB5,0x78,0xB3,0xB6,0x9B};
+
+ TransferStatus() : transferState((TransferState::type)0), timeOfStateChange(0) {
+ }
+
+ virtual ~TransferStatus() throw() {}
+
+ TransferState::type transferState;
+ int64_t timeOfStateChange;
+
+ _TransferStatus__isset __isset;
+
+ void __set_transferState(const TransferState::type val) {
+ transferState = val;
+ }
+
+ void __set_timeOfStateChange(const int64_t val) {
+ timeOfStateChange = val;
+ __isset.timeOfStateChange = true;
+ }
+
+ bool operator == (const TransferStatus & rhs) const
+ {
+ if (!(transferState == rhs.transferState))
+ return false;
+ if (__isset.timeOfStateChange != rhs.__isset.timeOfStateChange)
+ return false;
+ else if (__isset.timeOfStateChange && !(timeOfStateChange == rhs.timeOfStateChange))
+ return false;
+ return true;
+ }
+ bool operator != (const TransferStatus &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const TransferStatus & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(TransferStatus &a, TransferStatus &b);
+
+typedef struct _ApplicationStatus__isset {
+ _ApplicationStatus__isset() : timeOfStateChange(false) {}
+ bool timeOfStateChange;
+} _ApplicationStatus__isset;
+
+class ApplicationStatus {
+ public:
+
+ static const char* ascii_fingerprint; // = "E17E126D15049701494262EE3246F603";
+ static const uint8_t binary_fingerprint[16]; // = {0xE1,0x7E,0x12,0x6D,0x15,0x04,0x97,0x01,0x49,0x42,0x62,0xEE,0x32,0x46,0xF6,0x03};
+
+ ApplicationStatus() : applicationState(), timeOfStateChange(0) {
+ }
+
+ virtual ~ApplicationStatus() throw() {}
+
+ std::string applicationState;
+ int64_t timeOfStateChange;
+
+ _ApplicationStatus__isset __isset;
+
+ void __set_applicationState(const std::string& val) {
+ applicationState = val;
+ }
+
+ void __set_timeOfStateChange(const int64_t val) {
+ timeOfStateChange = val;
+ __isset.timeOfStateChange = true;
+ }
+
+ bool operator == (const ApplicationStatus & rhs) const
+ {
+ if (!(applicationState == rhs.applicationState))
+ return false;
+ if (__isset.timeOfStateChange != rhs.__isset.timeOfStateChange)
+ return false;
+ else if (__isset.timeOfStateChange && !(timeOfStateChange == rhs.timeOfStateChange))
+ return false;
+ return true;
+ }
+ bool operator != (const ApplicationStatus &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ApplicationStatus & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(ApplicationStatus &a, ApplicationStatus &b);
+
+typedef struct _DataObjectType__isset {
+ _DataObjectType__isset() : value(false), type(false), metaData(false) {}
+ bool value;
+ bool type;
+ bool metaData;
+} _DataObjectType__isset;
+
+class DataObjectType {
+ public:
+
+ static const char* ascii_fingerprint; // = "544FBB8031AE070AEEB7AC0E4A90E43C";
+ static const uint8_t binary_fingerprint[16]; // = {0x54,0x4F,0xBB,0x80,0x31,0xAE,0x07,0x0A,0xEE,0xB7,0xAC,0x0E,0x4A,0x90,0xE4,0x3C};
+
+ DataObjectType() : key(), value(), type((DataType::type)0), metaData() {
+ }
+
+ virtual ~DataObjectType() throw() {}
+
+ std::string key;
+ std::string value;
+ DataType::type type;
+ std::string metaData;
+
+ _DataObjectType__isset __isset;
+
+ void __set_key(const std::string& val) {
+ key = val;
+ }
+
+ void __set_value(const std::string& val) {
+ value = val;
+ __isset.value = true;
+ }
+
+ void __set_type(const DataType::type val) {
+ type = val;
+ __isset.type = true;
+ }
+
+ void __set_metaData(const std::string& val) {
+ metaData = val;
+ __isset.metaData = true;
+ }
+
+ bool operator == (const DataObjectType & rhs) const
+ {
+ if (!(key == rhs.key))
+ return false;
+ if (__isset.value != rhs.__isset.value)
+ return false;
+ else if (__isset.value && !(value == rhs.value))
+ return false;
+ if (__isset.type != rhs.__isset.type)
+ return false;
+ else if (__isset.type && !(type == rhs.type))
+ return false;
+ if (__isset.metaData != rhs.__isset.metaData)
+ return false;
+ else if (__isset.metaData && !(metaData == rhs.metaData))
+ return false;
+ return true;
+ }
+ bool operator != (const DataObjectType &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const DataObjectType & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(DataObjectType &a, DataObjectType &b);
+
+typedef struct _ComputationalResourceScheduling__isset {
+ _ComputationalResourceScheduling__isset() : resourceHostId(false), totalCPUCount(false), nodeCount(false), numberOfThreads(false), queueName(false), wallTimeLimit(false), jobStartTime(false), totalPhysicalMemory(false), computationalProjectAccount(false) {}
+ bool resourceHostId;
+ bool totalCPUCount;
+ bool nodeCount;
+ bool numberOfThreads;
+ bool queueName;
+ bool wallTimeLimit;
+ bool jobStartTime;
+ bool totalPhysicalMemory;
+ bool computationalProjectAccount;
+} _ComputationalResourceScheduling__isset;
+
+class ComputationalResourceScheduling {
+ public:
+
+ static const char* ascii_fingerprint; // = "32AC7AC41AD3753A7224A32FD6EB4B5D";
+ static const uint8_t binary_fingerprint[16]; // = {0x32,0xAC,0x7A,0xC4,0x1A,0xD3,0x75,0x3A,0x72,0x24,0xA3,0x2F,0xD6,0xEB,0x4B,0x5D};
+
+ ComputationalResourceScheduling() : resourceHostId(), totalCPUCount(0), nodeCount(0), numberOfThreads(0), queueName(), wallTimeLimit(0), jobStartTime(0), totalPhysicalMemory(0), computationalProjectAccount() {
+ }
+
+ virtual ~ComputationalResourceScheduling() throw() {}
+
+ std::string resourceHostId;
+ int32_t totalCPUCount;
+ int32_t nodeCount;
+ int32_t numberOfThreads;
+ std::string queueName;
+ int32_t wallTimeLimit;
+ int32_t jobStartTime;
+ int32_t totalPhysicalMemory;
+ std::string computationalProjectAccount;
+
+ _ComputationalResourceScheduling__isset __isset;
+
+ void __set_resourceHostId(const std::string& val) {
+ resourceHostId = val;
+ __isset.resourceHostId = true;
+ }
+
+ void __set_totalCPUCount(const int32_t val) {
+ totalCPUCount = val;
+ __isset.totalCPUCount = true;
+ }
+
+ void __set_nodeCount(const int32_t val) {
+ nodeCount = val;
+ __isset.nodeCount = true;
+ }
+
+ void __set_numberOfThreads(const int32_t val) {
+ numberOfThreads = val;
+ __isset.numberOfThreads = true;
+ }
+
+ void __set_queueName(const std::string& val) {
+ queueName = val;
+ __isset.queueName = true;
+ }
+
+ void __set_wallTimeLimit(const int32_t val) {
+ wallTimeLimit = val;
+ __isset.wallTimeLimit = true;
+ }
+
+ void __set_jobStartTime(const int32_t val) {
+ jobStartTime = val;
+ __isset.jobStartTime = true;
+ }
+
+ void __set_totalPhysicalMemory(const int32_t val) {
+ totalPhysicalMemory = val;
+ __isset.totalPhysicalMemory = true;
+ }
+
+ void __set_computationalProjectAccount(const std::string& val) {
+ computationalProjectAccount = val;
+ __isset.computationalProjectAccount = true;
+ }
+
+ bool operator == (const ComputationalResourceScheduling & rhs) const
+ {
+ if (__isset.resourceHostId != rhs.__isset.resourceHostId)
+ return false;
+ else if (__isset.resourceHostId && !(resourceHostId == rhs.resourceHostId))
+ return false;
+ if (__isset.totalCPUCount != rhs.__isset.totalCPUCount)
+ return false;
+ else if (__isset.totalCPUCount && !(totalCPUCount == rhs.totalCPUCount))
+ return false;
+ if (__isset.nodeCount != rhs.__isset.nodeCount)
+ return false;
+ else if (__isset.nodeCount && !(nodeCount == rhs.nodeCount))
+ return false;
+ if (__isset.numberOfThreads != rhs.__isset.numberOfThreads)
+ return false;
+ else if (__isset.numberOfThreads && !(numberOfThreads == rhs.numberOfThreads))
+ return false;
+ if (__isset.queueName != rhs.__isset.queueName)
+ return false;
+ else if (__isset.queueName && !(queueName == rhs.queueName))
+ return false;
+ if (__isset.wallTimeLimit != rhs.__isset.wallTimeLimit)
+ return false;
+ else if (__isset.wallTimeLimit && !(wallTimeLimit == rhs.wallTimeLimit))
+ return false;
+ if (__isset.jobStartTime != rhs.__isset.jobStartTime)
+ return false;
+ else if (__isset.jobStartTime && !(jobStartTime == rhs.jobStartTime))
+ return false;
+ if (__isset.totalPhysicalMemory != rhs.__isset.totalPhysicalMemory)
+ return false;
+ else if (__isset.totalPhysicalMemory && !(totalPhysicalMemory == rhs.totalPhysicalMemory))
+ return false;
+ if (__isset.computationalProjectAccount != rhs.__isset.computationalProjectAccount)
+ return false;
+ else if (__isset.computationalProjectAccount && !(computationalProjectAccount == rhs.computationalProjectAccount))
+ return false;
+ return true;
+ }
+ bool operator != (const ComputationalResourceScheduling &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ComputationalResourceScheduling & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(ComputationalResourceScheduling &a, ComputationalResourceScheduling &b);
+
+typedef struct _AdvancedInputDataHandling__isset {
+ _AdvancedInputDataHandling__isset() : stageInputFilesToWorkingDir(true), parentWorkingDirectory(false), uniqueWorkingDirectory(false), cleanUpWorkingDirAfterJob(true) {}
+ bool stageInputFilesToWorkingDir;
+ bool parentWorkingDirectory;
+ bool uniqueWorkingDirectory;
+ bool cleanUpWorkingDirAfterJob;
+} _AdvancedInputDataHandling__isset;
+
+class AdvancedInputDataHandling {
+ public:
+
+ static const char* ascii_fingerprint; // = "6139039875942E8B25C483838DD664B7";
+ static const uint8_t binary_fingerprint[16]; // = {0x61,0x39,0x03,0x98,0x75,0x94,0x2E,0x8B,0x25,0xC4,0x83,0x83,0x8D,0xD6,0x64,0xB7};
+
+ AdvancedInputDataHandling() : stageInputFilesToWorkingDir(false), parentWorkingDirectory(), uniqueWorkingDirectory(), cleanUpWorkingDirAfterJob(false) {
+ }
+
+ virtual ~AdvancedInputDataHandling() throw() {}
+
+ bool stageInputFilesToWorkingDir;
+ std::string parentWorkingDirectory;
+ std::string uniqueWorkingDirectory;
+ bool cleanUpWorkingDirAfterJob;
+
+ _AdvancedInputDataHandling__isset __isset;
+
+ void __set_stageInputFilesToWorkingDir(const bool val) {
+ stageInputFilesToWorkingDir = val;
+ __isset.stageInputFilesToWorkingDir = true;
+ }
+
+ void __set_parentWorkingDirectory(const std::string& val) {
+ parentWorkingDirectory = val;
+ __isset.parentWorkingDirectory = true;
+ }
+
+ void __set_uniqueWorkingDirectory(const std::string& val) {
+ uniqueWorkingDirectory = val;
+ __isset.uniqueWorkingDirectory = true;
+ }
+
+ void __set_cleanUpWorkingDirAfterJob(const bool val) {
+ cleanUpWorkingDirAfterJob = val;
+ __isset.cleanUpWorkingDirAfterJob = true;
+ }
+
+ bool operator == (const AdvancedInputDataHandling & rhs) const
+ {
+ if (__isset.stageInputFilesToWorkingDir != rhs.__isset.stageInputFilesToWorkingDir)
+ return false;
+ else if (__isset.stageInputFilesToWorkingDir && !(stageInputFilesToWorkingDir == rhs.stageInputFilesToWorkingDir))
+ return false;
+ if (__isset.parentWorkingDirectory != rhs.__isset.parentWorkingDirectory)
+ return false;
+ else if (__isset.parentWorkingDirectory && !(parentWorkingDirectory == rhs.parentWorkingDirectory))
+ return false;
+ if (__isset.uniqueWorkingDirectory != rhs.__isset.uniqueWorkingDirectory)
+ return false;
+ else if (__isset.uniqueWorkingDirectory && !(uniqueWorkingDirectory == rhs.uniqueWorkingDirectory))
+ return false;
+ if (__isset.cleanUpWorkingDirAfterJob != rhs.__isset.cleanUpWorkingDirAfterJob)
+ return false;
+ else if (__isset.cleanUpWorkingDirAfterJob && !(cleanUpWorkingDirAfterJob == rhs.cleanUpWorkingDirAfterJob))
+ return false;
+ return true;
+ }
+ bool operator != (const AdvancedInputDataHandling &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const AdvancedInputDataHandling & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(AdvancedInputDataHandling &a, AdvancedInputDataHandling &b);
+
+typedef struct _AdvancedOutputDataHandling__isset {
+ _AdvancedOutputDataHandling__isset() : outputDataDir(false), dataRegistryURL(false), persistOutputData(true) {}
+ bool outputDataDir;
+ bool dataRegistryURL;
+ bool persistOutputData;
+} _AdvancedOutputDataHandling__isset;
+
+class AdvancedOutputDataHandling {
+ public:
+
+ static const char* ascii_fingerprint; // = "6EC898D3B5ECFF21200795BD22F73CD2";
+ static const uint8_t binary_fingerprint[16]; // = {0x6E,0xC8,0x98,0xD3,0xB5,0xEC,0xFF,0x21,0x20,0x07,0x95,0xBD,0x22,0xF7,0x3C,0xD2};
+
+ AdvancedOutputDataHandling() : outputDataDir(), dataRegistryURL(), persistOutputData(true) {
+ }
+
+ virtual ~AdvancedOutputDataHandling() throw() {}
+
+ std::string outputDataDir;
+ std::string dataRegistryURL;
+ bool persistOutputData;
+
+ _AdvancedOutputDataHandling__isset __isset;
+
+ void __set_outputDataDir(const std::string& val) {
+ outputDataDir = val;
+ __isset.outputDataDir = true;
+ }
+
+ void __set_dataRegistryURL(const std::string& val) {
+ dataRegistryURL = val;
+ __isset.dataRegistryURL = true;
+ }
+
+ void __set_persistOutputData(const bool val) {
+ persistOutputData = val;
+ __isset.persistOutputData = true;
+ }
+
+ bool operator == (const AdvancedOutputDataHandling & rhs) const
+ {
+ if (__isset.outputDataDir != rhs.__isset.outputDataDir)
+ return false;
+ else if (__isset.outputDataDir && !(outputDataDir == rhs.outputDataDir))
+ return false;
+ if (__isset.dataRegistryURL != rhs.__isset.dataRegistryURL)
+ return false;
+ else if (__isset.dataRegistryURL && !(dataRegistryURL == rhs.dataRegistryURL))
+ return false;
+ if (__isset.persistOutputData != rhs.__isset.persistOutputData)
+ return false;
+ else if (__isset.persistOutputData && !(persistOutputData == rhs.persistOutputData))
+ return false;
+ return true;
+ }
+ bool operator != (const AdvancedOutputDataHandling &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const AdvancedOutputDataHandling & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(AdvancedOutputDataHandling &a, AdvancedOutputDataHandling &b);
+
+typedef struct _QualityOfServiceParams__isset {
+ _QualityOfServiceParams__isset() : startExecutionAt(false), executeBefore(false), numberofRetries(false) {}
+ bool startExecutionAt;
+ bool executeBefore;
+ bool numberofRetries;
+} _QualityOfServiceParams__isset;
+
+class QualityOfServiceParams {
+ public:
+
+ static const char* ascii_fingerprint; // = "35985D966603A273E8D7132543B44873";
+ static const uint8_t binary_fingerprint[16]; // = {0x35,0x98,0x5D,0x96,0x66,0x03,0xA2,0x73,0xE8,0xD7,0x13,0x25,0x43,0xB4,0x48,0x73};
+
+ QualityOfServiceParams() : startExecutionAt(), executeBefore(), numberofRetries(0) {
+ }
+
+ virtual ~QualityOfServiceParams() throw() {}
+
+ std::string startExecutionAt;
+ std::string executeBefore;
+ int32_t numberofRetries;
+
+ _QualityOfServiceParams__isset __isset;
+
+ void __set_startExecutionAt(const std::string& val) {
+ startExecutionAt = val;
+ __isset.startExecutionAt = true;
+ }
+
+ void __set_executeBefore(const std::string& val) {
+ executeBefore = val;
+ __isset.executeBefore = true;
+ }
+
+ void __set_numberofRetries(const int32_t val) {
+ numberofRetries = val;
+ __isset.numberofRetries = true;
+ }
+
+ bool operator == (const QualityOfServiceParams & rhs) const
+ {
+ if (__isset.startExecutionAt != rhs.__isset.startExecutionAt)
+ return false;
+ else if (__isset.startExecutionAt && !(startExecutionAt == rhs.startExecutionAt))
+ return false;
+ if (__isset.executeBefore != rhs.__isset.executeBefore)
+ return false;
+ else if (__isset.executeBefore && !(executeBefore == rhs.executeBefore))
+ return false;
+ if (__isset.numberofRetries != rhs.__isset.numberofRetries)
+ return false;
+ else if (__isset.numberofRetries && !(numberofRetries == rhs.numberofRetries))
+ return false;
+ return true;
+ }
+ bool operator != (const QualityOfServiceParams &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const QualityOfServiceParams & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(QualityOfServiceParams &a, QualityOfServiceParams &b);
+
+typedef struct _UserConfigurationData__isset {
+ _UserConfigurationData__isset() : shareExperimentPublicly(true), computationalResourceScheduling(false), advanceInputDataHandling(false), advanceOutputDataHandling(false), qosParams(false) {}
+ bool shareExperimentPublicly;
+ bool computationalResourceScheduling;
+ bool advanceInputDataHandling;
+ bool advanceOutputDataHandling;
+ bool qosParams;
+} _UserConfigurationData__isset;
+
+class UserConfigurationData {
+ public:
+
+ static const char* ascii_fingerprint; // = "889486266D7ADC041ED1C586A2468611";
+ static const uint8_t binary_fingerprint[16]; // = {0x88,0x94,0x86,0x26,0x6D,0x7A,0xDC,0x04,0x1E,0xD1,0xC5,0x86,0xA2,0x46,0x86,0x11};
+
+ UserConfigurationData() : airavataAutoSchedule(false), overrideManualScheduledParams(false), shareExperimentPublicly(false) {
+ }
+
+ virtual ~UserConfigurationData() throw() {}
+
+ bool airavataAutoSchedule;
+ bool overrideManualScheduledParams;
+ bool shareExperimentPublicly;
+ ComputationalResourceScheduling computationalResourceScheduling;
+ AdvancedInputDataHandling advanceInputDataHandling;
+ AdvancedOutputDataHandling advanceOutputDataHandling;
+ QualityOfServiceParams qosParams;
+
+ _UserConfigurationData__isset __isset;
+
+ void __set_airavataAutoSchedule(const bool val) {
+ airavataAutoSchedule = val;
+ }
+
+ void __set_overrideManualScheduledParams(const bool val) {
+ overrideManualScheduledParams = val;
+ }
+
+ void __set_shareExperimentPublicly(const bool val) {
+ shareExperimentPublicly = val;
+ __isset.shareExperimentPublicly = true;
+ }
+
+ void __set_computationalResourceScheduling(const ComputationalResourceScheduling& val) {
+ computationalResourceScheduling = val;
+ __isset.computationalResourceScheduling = true;
+ }
+
+ void __set_advanceInputDataHandling(const AdvancedInputDataHandling& val) {
+ advanceInputDataHandling = val;
+ __isset.advanceInputDataHandling = true;
+ }
+
+ void __set_advanceOutputDataHandling(const AdvancedOutputDataHandling& val) {
+ advanceOutputDataHandling = val;
+ __isset.advanceOutputDataHandling = true;
+ }
+
+ void __set_qosParams(const QualityOfServiceParams& val) {
+ qosParams = val;
+ __isset.qosParams = true;
+ }
+
+ bool operator == (const UserConfigurationData & rhs) const
+ {
+ if (!(airavataAutoSchedule == rhs.airavataAutoSchedule))
+ return false;
+ if (!(overrideManualScheduledParams == rhs.overrideManualScheduledParams))
+ return false;
+ if (__isset.shareExperimentPublicly != rhs.__isset.shareExperimentPublicly)
+ return false;
+ else if (__isset.shareExperimentPublicly && !(shareExperimentPublicly == rhs.shareExperimentPublicly))
+ return false;
+ if (__isset.computationalResourceScheduling != rhs.__isset.computationalResourceScheduling)
+ return false;
+ else if (__isset.computationalResourceScheduling && !(computationalResourceScheduling == rhs.computationalResourceScheduling))
+ return false;
+ if (__isset.advanceInputDataHandling != rhs.__isset.advanceInputDataHandling)
+ return false;
+ else if (__isset.advanceInputDataHandling && !(advanceInputDataHandling == rhs.advanceInputDataHandling))
+ return false;
+ if (__isset.advanceOutputDataHandling != rhs.__isset.advanceOutputDataHandling)
+ return false;
+ else if (__isset.advanceOutputDataHandling && !(advanceOutputDataHandling == rhs.advanceOutputDataHandling))
+ return false;
+ if (__isset.qosParams != rhs.__isset.qosParams)
+ return false;
+ else if (__isset.qosParams && !(qosParams == rhs.qosParams))
+ return false;
+ return true;
+ }
+ bool operator != (const UserConfigurationData &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const UserConfigurationData & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(UserConfigurationData &a, UserConfigurationData &b);
+
+typedef struct _ErrorDetails__isset {
+ _ErrorDetails__isset() : creationTime(false), actualErrorMessage(false), userFriendlyMessage(false), errorCategory(false), transientOrPersistent(true), correctiveAction(false), actionableGroup(false), rootCauseErrorIdList(false) {}
+ bool creationTime;
+ bool actualErrorMessage;
+ bool userFriendlyMessage;
+ bool errorCategory;
+ bool transientOrPersistent;
+ bool correctiveAction;
+ bool actionableGroup;
+ bool rootCauseErrorIdList;
+} _ErrorDetails__isset;
+
+class ErrorDetails {
+ public:
+
+ static const char* ascii_fingerprint; // = "170CA6E79EB283F31417B9D68071DA33";
+ static const uint8_t binary_fingerprint[16]; // = {0x17,0x0C,0xA6,0xE7,0x9E,0xB2,0x83,0xF3,0x14,0x17,0xB9,0xD6,0x80,0x71,0xDA,0x33};
+
+ ErrorDetails() : errorID("DO_NOT_SET_AT_CLIENTS"), creationTime(0), actualErrorMessage(), userFriendlyMessage(), errorCategory((ErrorCategory::type)0), transientOrPersistent(false), correctiveAction((CorrectiveAction::type)0), actionableGroup((ActionableGroup::type)0) {
+ }
+
+ virtual ~ErrorDetails() throw() {}
+
+ std::string errorID;
+ int64_t creationTime;
+ std::string actualErrorMessage;
+ std::string userFriendlyMessage;
+ ErrorCategory::type errorCategory;
+ bool transientOrPersistent;
+ CorrectiveAction::type correctiveAction;
+ ActionableGroup::type actionableGroup;
+ std::vector<std::string> rootCauseErrorIdList;
+
+ _ErrorDetails__isset __isset;
+
+ void __set_errorID(const std::string& val) {
+ errorID = val;
+ }
+
+ void __set_creationTime(const int64_t val) {
+ creationTime = val;
+ __isset.creationTime = true;
+ }
+
+ void __set_actualErrorMessage(const std::string& val) {
+ actualErrorMessage = val;
+ __isset.actualErrorMessage = true;
+ }
+
+ void __set_userFriendlyMessage(const std::string& val) {
+ userFriendlyMessage = val;
+ __isset.userFriendlyMessage = true;
+ }
+
+ void __set_errorCategory(const ErrorCategory::type val) {
+ errorCategory = val;
+ __isset.errorCategory = true;
+ }
+
+ void __set_transientOrPersistent(const bool val) {
+ transientOrPersistent = val;
+ __isset.transientOrPersistent = true;
+ }
+
+ void __set_correctiveAction(const CorrectiveAction::type val) {
+ correctiveAction = val;
+ __isset.correctiveAction = true;
+ }
+
+ void __set_actionableGroup(const ActionableGroup::type val) {
+ actionableGroup = val;
+ __isset.actionableGroup = true;
+ }
+
+ void __set_rootCauseErrorIdList(const std::vector<std::string> & val) {
+ rootCauseErrorIdList = val;
+ __isset.rootCauseErrorIdList = true;
+ }
+
+ bool operator == (const ErrorDetails & rhs) const
+ {
+ if (!(errorID == rhs.errorID))
+ return false;
+ if (__isset.creationTime != rhs.__isset.creationTime)
+ return false;
+ else if (__isset.creationTime && !(creationTime == rhs.creationTime))
+ return false;
+ if (__isset.actualErrorMessage != rhs.__isset.actualErrorMessage)
+ return false;
+ else if (__isset.actualErrorMessage && !(actualErrorMessage == rhs.actualErrorMessage))
+ return false;
+ if (__isset.userFriendlyMessage != rhs.__isset.userFriendlyMessage)
+ return false;
+ else if (__isset.userFriendlyMessage && !(userFriendlyMessage == rhs.userFriendlyMessage))
+ return false;
+ if (__isset.errorCategory != rhs.__isset.errorCategory)
+ return false;
+ else if (__isset.errorCategory && !(errorCategory == rhs.errorCategory))
+ return false;
+ if (__isset.transientOrPersistent != rhs.__isset.transientOrPersistent)
+ return false;
+ else if (__isset.transientOrPersistent && !(transientOrPersistent == rhs.transientOrPersistent))
+ return false;
+ if (__isset.correctiveAction != rhs.__isset.correctiveAction)
+ return false;
+ else if (__isset.correctiveAction && !(correctiveAction == rhs.correctiveAction))
+ return false;
+ if (__isset.actionableGroup != rhs.__isset.actionableGroup)
+ return false;
+ else if (__isset.actionableGroup && !(actionableGroup == rhs.actionableGroup))
+ return false;
+ if (__isset.rootCauseErrorIdList != rhs.__isset.rootCauseErrorIdList)
+ return false;
+ else if (__isset.rootCauseErrorIdList && !(rootCauseErrorIdList == rhs.rootCauseErrorIdList))
+ return false;
+ return true;
+ }
+ bool operator != (const ErrorDetails &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ErrorDetails & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(ErrorDetails &a, ErrorDetails &b);
+
+typedef struct _JobDetails__isset {
+ _JobDetails__isset() : creationTime(false), jobStatus(false), applicationStatus(false), errors(false), computeResourceConsumed(false) {}
+ bool creationTime;
+ bool jobStatus;
+ bool applicationStatus;
+ bool errors;
+ bool computeResourceConsumed;
+} _JobDetails__isset;
+
+class JobDetails {
+ public:
+
+ static const char* ascii_fingerprint; // = "5946807521C11BC65075D497F8568057";
+ static const uint8_t binary_fingerprint[16]; // = {0x59,0x46,0x80,0x75,0x21,0xC1,0x1B,0xC6,0x50,0x75,0xD4,0x97,0xF8,0x56,0x80,0x57};
+
+ JobDetails() : jobID("DO_NOT_SET_AT_CLIENTS"), jobDescription(), creationTime(0), computeResourceConsumed() {
+ }
+
+ virtual ~JobDetails() throw() {}
+
+ std::string jobID;
+ std::string jobDescription;
+ int64_t creationTime;
+ JobStatus jobStatus;
+ ApplicationStatus applicationStatus;
+ std::vector<ErrorDetails> errors;
+ std::string computeResourceConsumed;
+
+ _JobDetails__isset __isset;
+
+ void __set_jobID(const std::string& val) {
+ jobID = val;
+ }
+
+ void __set_jobDescription(const std::string& val) {
+ jobDescription = val;
+ }
+
+ void __set_creationTime(const int64_t val) {
+ creationTime = val;
+ __isset.creationTime = true;
+ }
+
+ void __set_jobStatus(const JobStatus& val) {
+ jobStatus = val;
+ __isset.jobStatus = true;
+ }
+
+ void __set_applicationStatus(const ApplicationStatus& val) {
+ applicationStatus = val;
+ __isset.applicationStatus = true;
+ }
+
+ void __set_errors(const std::vector<ErrorDetails> & val) {
+ errors = val;
+ __isset.errors = true;
+ }
+
+ void __set_computeResourceConsumed(const std::string& val) {
+ computeResourceConsumed = val;
+ __isset.computeResourceConsumed = true;
+ }
+
+ bool operator == (const JobDetails & rhs) const
+ {
+ if (!(jobID == rhs.jobID))
+ return false;
+ if (!(jobDescription == rhs.jobDescription))
+ return false;
+ if (__isset.creationTime != rhs.__isset.creationTime)
+ return false;
+ else if (__isset.creationTime && !(creationTime == rhs.creationTime))
+ return false;
+ if (__isset.jobStatus != rhs.__isset.jobStatus)
+ return false;
+ else if (__isset.jobStatus && !(jobStatus == rhs.jobStatus))
+ return false;
+ if (__isset.applicationStatus != rhs.__isset.applicationStatus)
+ return false;
+ else if (__isset.applicationStatus && !(applicationStatus == rhs.applicationStatus))
+ return false;
+ if (__isset.errors != rhs.__isset.errors)
+ return false;
+ else if (__isset.errors && !(errors == rhs.errors))
+ return false;
+ if (__isset.computeResourceConsumed != rhs.__isset.computeResourceConsumed)
+ return false;
+ else if (__isset.computeResourceConsumed && !(computeResourceConsumed == rhs.computeResourceConsumed))
+ return false;
+ return true;
+ }
+ bool operator != (const JobDetails &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const JobDetails & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(JobDetails &a, JobDetails &b);
+
+typedef struct _DataTransferDetails__isset {
+ _DataTransferDetails__isset() : creationTime(false), transferStatus(false) {}
+ bool creationTime;
+ bool transferStatus;
+} _DataTransferDetails__isset;
+
+class DataTransferDetails {
+ public:
+
+ static const char* ascii_fingerprint; // = "40D4FEC20E3B334AEEBA92DA2AB9E91E";
+ static const uint8_t binary_fingerprint[16]; // = {0x40,0xD4,0xFE,0xC2,0x0E,0x3B,0x33,0x4A,0xEE,0xBA,0x92,0xDA,0x2A,0xB9,0xE9,0x1E};
+
+ DataTransferDetails() : transferID("DO_NOT_SET_AT_CLIENTS"), creationTime(0), transferDescription() {
+ }
+
+ virtual ~DataTransferDetails() throw() {}
+
+ std::string transferID;
+ int64_t creationTime;
+ std::string transferDescription;
+ TransferStatus transferStatus;
+
+ _DataTransferDetails__isset __isset;
+
+ void __set_transferID(const std::string& val) {
+ transferID = val;
+ }
+
+ void __set_creationTime(const int64_t val) {
+ creationTime = val;
+ __isset.creationTime = true;
+ }
+
+ void __set_transferDescription(const std::string& val) {
+ transferDescription = val;
+ }
+
+ void __set_transferStatus(const TransferStatus& val) {
+ transferStatus = val;
+ __isset.transferStatus = true;
+ }
+
+ bool operator == (const DataTransferDetails & rhs) const
+ {
+ if (!(transferID == rhs.transferID))
+ return false;
+ if (__isset.creationTime != rhs.__isset.creationTime)
+ return false;
+ else if (__isset.creationTime && !(creationTime == rhs.creationTime))
+ return false;
+ if (!(transferDescription == rhs.transferDescription))
+ return false;
+ if (__isset.transferStatus != rhs.__isset.transferStatus)
+ return false;
+ else if (__isset.transferStatus && !(transferStatus == rhs.transferStatus))
+ return false;
+ return true;
+ }
+ bool operator != (const DataTransferDetails &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const DataTransferDetails & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(DataTransferDetails &a, DataTransferDetails &b);
+
+typedef struct _TaskDetails__isset {
+ _TaskDetails__isset() : creationTime(false), applicationId(false), applicationVersion(false), applicationDeploymentId(false), applicationInputs(false), applicationOutputs(false), taskScheduling(false), advancedInputDataHandling(false), advancedOutputDataHandling(false), taskStatus(false), jobDetailsList(false), dataTransferDetailsList(false), errors(false) {}
+ bool creationTime;
+ bool applicationId;
+ bool applicationVersion;
+ bool applicationDeploymentId;
+ bool applicationInputs;
+ bool applicationOutputs;
+ bool taskScheduling;
+ bool advancedInputDataHandling;
+ bool advancedOutputDataHandling;
+ bool taskStatus;
+ bool jobDetailsList;
+ bool dataTransferDetailsList;
+ bool errors;
+} _TaskDetails__isset;
+
+class TaskDetails {
+ public:
+
+ static const char* ascii_fingerprint; // = "482C560A67EC84E3BEB13AFC5FEDA02C";
+ static const uint8_t binary_fingerprint[16]; // = {0x48,0x2C,0x56,0x0A,0x67,0xEC,0x84,0xE3,0xBE,0xB1,0x3A,0xFC,0x5F,0xED,0xA0,0x2C};
+
+ TaskDetails() : taskID("DO_NOT_SET_AT_CLIENTS"), creationTime(0), applicationId(), applicationVersion(), applicationDeploymentId() {
+ }
+
+ virtual ~TaskDetails() throw() {}
+
+ std::string taskID;
+ int64_t creationTime;
+ std::string applicationId;
+ std::string applicationVersion;
+ std::string applicationDeploymentId;
+ std::vector<DataObjectType> applicationInputs;
+ std::vector<DataObjectType> applicationOutputs;
+ ComputationalResourceScheduling taskScheduling;
+ AdvancedInputDataHandling advancedInputDataHandling;
+ AdvancedOutputDataHandling advancedOutputDataHandling;
+ TaskStatus taskStatus;
+ std::vector<JobDetails> jobDetailsList;
+ std::vector<DataTransferDetails> dataTransferDetailsList;
+ std::vector<ErrorDetails> errors;
+
+ _TaskDetails__isset __isset;
+
+ void __set_taskID(const std::string& val) {
+ taskID = val;
+ }
+
+ void __set_creationTime(const int64_t val) {
+ creationTime = val;
+ __isset.creationTime = true;
+ }
+
+ void __set_applicationId(const std::string& val) {
+ applicationId = val;
+ __isset.applicationId = true;
+ }
+
+ void __set_applicationVersion(const std::string& val) {
+ applicationVersion = val;
+ __isset.applicationVersion = true;
+ }
+
+ void __set_applicationDeploymentId(const std::string& val) {
+ applicationDeploymentId = val;
+ __isset.applicationDeploymentId = true;
+ }
+
+ void __set_applicationInputs(const std::vector<DataObjectType> & val) {
+ applicationInputs = val;
+ __isset.applicationInputs = true;
+ }
+
+ void __set_applicationOutputs(const std::vector<DataObjectType> & val) {
+ applicationOutputs = val;
+ __isset.applicationOutputs = true;
+ }
+
+ void __set_taskScheduling(const ComputationalResourceScheduling& val) {
+ taskScheduling = val;
+ __isset.taskScheduling = true;
+ }
+
+ void __set_advancedInputDataHandling(const AdvancedInputDataHandling& val) {
+ advancedInputDataHandling = val;
+ __isset.advancedInputDataHandling = true;
+ }
+
+ void __set_advancedOutputDataHandling(const AdvancedOutputDataHandling& val) {
+ advancedOutputDataHandling = val;
+ __isset.advancedOutputDataHandling = true;
+ }
+
+ void __set_taskStatus(const TaskStatus& val) {
+ taskStatus = val;
+ __isset.taskStatus = true;
+ }
+
+ void __set_jobDetailsList(const std::vector<JobDetails> & val) {
+ jobDetailsList = val;
+ __isset.jobDetailsList = true;
+ }
+
+ void __set_dataTransferDetailsList(const std::vector<DataTransferDetails> & val) {
+ dataTransferDetailsList = val;
+ __isset.dataTransferDetailsList = true;
+ }
+
+ void __set_errors(const std::vector<ErrorDetails> & val) {
+ errors = val;
+ __isset.errors = true;
+ }
+
+ bool operator == (const TaskDetails & rhs) const
+ {
+ if (!(taskID == rhs.taskID))
+ return false;
+ if (__isset.creationTime != rhs.__isset.creationTime)
+ return false;
+ else if (__isset.creationTime && !(creationTime == rhs.creationTime))
+ return false;
+ if (__isset.applicationId != rhs.__isset.applicationId)
+ return false;
+ else if (__isset.applicationId && !(applicationId == rhs.applicationId))
+ return false;
+ if (__isset.applicationVersion != rhs.__isset.applicationVersion)
+ return false;
+ else if (__isset.applicationVersion && !(applicationVersion == rhs.applicationVersion))
+ return false;
+ if (__isset.applicationDeploymentId != rhs.__isset.applicationDeploymentId)
+ return false;
+ else if (__isset.applicationDeploymentId && !(applicationDeploymentId == rhs.applicationDeploymentId))
+ return false;
+ if (__isset.applicationInputs != rhs.__isset.applicationInputs)
+ return false;
+ else if (__isset.applicationInputs && !(applicationInputs == rhs.applicationInputs))
+ return false;
+ if (__isset.applicationOutputs != rhs.__isset.applicationOutputs)
+ return false;
+ else if (__isset.applicationOutputs && !(applicationOutputs == rhs.applicationOutputs))
+ return false;
+ if (__isset.taskScheduling != rhs.__isset.taskScheduling)
+ return false;
+ else if (__isset.taskScheduling && !(taskScheduling == rhs.taskScheduling))
+ return false;
+ if (__isset.advancedInputDataHandling != rhs.__isset.advancedInputDataHandling)
+ return false;
+ else if (__isset.advancedInputDataHandling && !(advancedInputDataHandling == rhs.advancedInputDataHandling))
+ return false;
+ if (__isset.advancedOutputDataHandling != rhs.__isset.advancedOutputDataHandling)
+ return false;
+ else if (__isset.advancedOutputDataHandling && !(advancedOutputDataHandling == rhs.advancedOutputDataHandling))
+ return false;
+ if (__isset.taskStatus != rhs.__isset.taskStatus)
+ return false;
+ else if (__isset.taskStatus && !(taskStatus == rhs.taskStatus))
+ return false;
+ if (__isset.jobDetailsList != rhs.__isset.jobDetailsList)
+ return false;
+ else if (__isset.jobDetailsList && !(jobDetailsList == rhs.jobDetailsList))
+ return false;
+ if (__isset.dataTransferDetailsList != rhs.__isset.dataTransferDetailsList)
+ return false;
+ else if (__isset.dataTransferDetailsList && !(dataTransferDetailsList == rhs.dataTransferDetailsList))
+ return false;
+ if (__isset.errors != rhs.__isset.errors)
+ return false;
+ else if (__isset.errors && !(errors == rhs.errors))
+ return false;
+ return true;
+ }
+ bool operator != (const TaskDetails &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const TaskDetails & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(TaskDetails &a, TaskDetails &b);
+
+typedef struct _WorkflowNodeDetails__isset {
+ _WorkflowNodeDetails__isset() : creationTime(false), executionUnitData(false), nodeInputs(false), nodeOutputs(false), workflowNodeStatus(false), taskDetailsList(false), errors(false) {}
+ bool creationTime;
+ bool executionUnitData;
+ bool nodeInputs;
+ bool nodeOutputs;
+ bool workflowNodeStatus;
+ bool taskDetailsList;
+ bool errors;
+} _WorkflowNodeDetails__isset;
+
+class WorkflowNodeDetails {
+ public:
+
+ static const char* ascii_fingerprint; // = "95130A9D83D5C73D70BAEBDF11F2FFE7";
+ static const uint8_t binary_fingerprint[16]; // = {0x95,0x13,0x0A,0x9D,0x83,0xD5,0xC7,0x3D,0x70,0xBA,0xEB,0xDF,0x11,0xF2,0xFF,0xE7};
+
+ WorkflowNodeDetails() : nodeInstanceId("DO_NOT_SET_AT_CLIENTS"), creationTime(0), nodeName("SINGLE_APP_NODE"), executionUnit((ExecutionUnit::type)1), executionUnitData() {
+ executionUnit = (ExecutionUnit::type)1;
+
+ }
+
+ virtual ~WorkflowNodeDetails() throw() {}
+
+ std::string nodeInstanceId;
+ int64_t creationTime;
+ std::string nodeName;
+ ExecutionUnit::type executionUnit;
+ std::string executionUnitData;
+ std::vector<DataObjectType> nodeInputs;
+ std::vector<DataObjectType> nodeOutputs;
+ WorkflowNodeStatus workflowNodeStatus;
+ std::vector<TaskDetails> taskDetailsList;
+ std::vector<ErrorDetails> errors;
+
+ _WorkflowNodeDetails__isset __isset;
+
+ void __set_nodeInstanceId(const std::string& val) {
+ nodeInstanceId = val;
+ }
+
+ void __set_creationTime(const int64_t val) {
+ creationTime = val;
+ __isset.creationTime = true;
+ }
+
+ void __set_nodeName(const std::string& val) {
+ nodeName = val;
+ }
+
+ void __set_executionUnit(const ExecutionUnit::type val) {
+ executionUnit = val;
+ }
+
+ void __set_executionUnitData(const std::string& val) {
+ executionUnitData = val;
+ __isset.executionUnitData = true;
+ }
+
+ void __set_nodeInputs(const std::vector<DataObjectType> & val) {
+ nodeInputs = val;
+ __isset.nodeInputs = true;
+ }
+
+ void __set_nodeOutputs(const std::vector<DataObjectType> & val) {
+ nodeOutputs = val;
+ __isset.nodeOutputs = true;
+ }
+
+ void __set_workflowNodeStatus(const WorkflowNodeStatus& val) {
+ workflowNodeStatus = val;
+ __isset.workflowNodeStatus = true;
+ }
+
+ void __set_taskDetailsList(const std::vector<TaskDetails> & val) {
+ taskDetailsList = val;
+ __isset.taskDetailsList = true;
+ }
+
+ void __set_errors(const std::vector<ErrorDetails> & val) {
+ errors = val;
+ __isset.errors = true;
+ }
+
+ bool operator == (const WorkflowNodeDetails & rhs) const
+ {
+ if (!(nodeInstanceId == rhs.nodeInstanceId))
+ return false;
+ if (__isset.creationTime != rhs.__isset.creationTime)
+ return false;
+ else if (__isset.creationTime && !(creationTime == rhs.creationTime))
+ return false;
+ if (!(nodeName == rhs.nodeName))
+ return false;
+ if (!(executionUnit == rhs.executionUnit))
+ return false;
+ if (__isset.executionUnitData != rhs.__isset.executionUnitData)
+ return false;
+ else if (__isset.executionUnitData && !(executionUnitData == rhs.executionUnitData))
+ return false;
+ if (__isset.nodeInputs != rhs.__isset.nodeInputs)
+ return false;
+ else if (__isset.nodeInputs && !(nodeInputs == rhs.nodeInputs))
+ return false;
+ if (__isset.nodeOutputs != rhs.__isset.nodeOutputs)
+ return false;
+ else if (__isset.nodeOutputs && !(nodeOutputs == rhs.nodeOutputs))
+ return false;
+ if (__isset.workflowNodeStatus != rhs.__isset.workflowNodeStatus)
+ return false;
+ else if (__isset.workflowNodeStatus && !(workflowNodeStatus == rhs.workflowNodeStatus))
+ return false;
+ if (__isset.taskDetailsList != rhs.__isset.taskDetailsList)
+ return false;
+ else if (__isset.taskDetailsList && !(taskDetailsList == rhs.taskDetailsList))
+ return false;
+ if (__isset.errors != rhs.__isset.errors)
+ return false;
+ else if (__isset.errors && !(errors == rhs.errors))
+ return false;
+ return true;
+ }
+ bool operator != (const WorkflowNodeDetails &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const WorkflowNodeDetails & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(WorkflowNodeDetails &a, WorkflowNodeDetails &b);
+
+typedef struct _ValidatorResult__isset {
+ _ValidatorResult__isset() : errorDetails(false) {}
+ bool errorDetails;
+} _ValidatorResult__isset;
+
+class ValidatorResult {
+ public:
+
+ static const char* ascii_fingerprint; // = "EB04A806CFFC9025AEE48CFFDC378A86";
+ static const uint8_t binary_fingerprint[16]; // = {0xEB,0x04,0xA8,0x06,0xCF,0xFC,0x90,0x25,0xAE,0xE4,0x8C,0xFF,0xDC,0x37,0x8A,0x86};
+
+ ValidatorResult() : result(0), errorDetails() {
+ }
+
+ virtual ~ValidatorResult() throw() {}
+
+ bool result;
+ std::string errorDetails;
+
+ _ValidatorResult__isset __isset;
+
+ void __set_result(const bool val) {
+ result = val;
+ }
+
+ void __set_errorDetails(const std::string& val) {
+ errorDetails = val;
+ __isset.errorDetails = true;
+ }
+
+ bool operator == (const ValidatorResult & rhs) const
+ {
+ if (!(result == rhs.result))
+ return false;
+ if (__isset.errorDetails != rhs.__isset.errorDetails)
+ return false;
+ else if (__isset.errorDetails && !(errorDetails == rhs.errorDetails))
+ return false;
+ return true;
+ }
+ bool operator != (const ValidatorResult &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ValidatorResult & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(ValidatorResult &a, ValidatorResult &b);
+
+
+class ValidationResults {
+ public:
+
+ static const char* ascii_fingerprint; // = "E73BC8630EE405DA5FB801ED852143D2";
+ static const uint8_t binary_fingerprint[16]; // = {0xE7,0x3B,0xC8,0x63,0x0E,0xE4,0x05,0xDA,0x5F,0xB8,0x01,0xED,0x85,0x21,0x43,0xD2};
+
+ ValidationResults() : validationState(0) {
+ }
+
+ virtual ~ValidationResults() throw() {}
+
+ bool validationState;
+ std::vector<ValidatorResult> validationResultList;
+
+ void __set_validationState(const bool val) {
+ validationState = val;
+ }
+
+ void __set_validationResultList(const std::vector<ValidatorResult> & val) {
+ validationResultList = val;
+ }
+
+ bool operator == (const ValidationResults & rhs) const
+ {
+ if (!(validationState == rhs.validationState))
+ return false;
+ if (!(validationResultList == rhs.validationResultList))
+ return false;
+ return true;
+ }
+ bool operator != (const ValidationResults &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ValidationResults & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(ValidationResults &a, ValidationResults &b);
+
+typedef struct _Experiment__isset {
+ _Experiment__isset() : creationTime(false), description(false), applicationId(false), applicationVersion(false), workflowTemplateId(false), workflowTemplateVersion(false), userConfigurationData(false), workflowExecutionInstanceId(false), experimentInputs(false), experimentOutputs(false), experimentStatus(false), stateChangeList(false), workflowNodeDetailsList(false), errors(false) {}
+ bool creationTime;
+ bool description;
+ bool applicationId;
+ bool applicationVersion;
+ bool workflowTemplateId;
+ bool workflowTemplateVersion;
+ bool userConfigurationData;
+ bool workflowExecutionInstanceId;
+ bool experimentInputs;
+ bool experimentOutputs;
+ bool experimentStatus;
+ bool stateChangeList;
+ bool workflowNodeDetailsList;
+ bool errors;
+} _Experiment__isset;
+
+class Experiment {
+ public:
+
+ static const char* ascii_fingerprint; // = "6B1FF2298EF5AE2B9EA8F76C2DFA9E8C";
+ static const uint8_t binary_fingerprint[16]; // = {0x6B,0x1F,0xF2,0x29,0x8E,0xF5,0xAE,0x2B,0x9E,0xA8,0xF7,0x6C,0x2D,0xFA,0x9E,0x8C};
+
+ Experiment() : experimentID("DO_NOT_SET_AT_CLIENTS"), projectID("DEFAULT"), creationTime(0), userName(), name(), description(), applicationId(), applicationVersion(), workflowTemplateId(), workflowTemplateVersion(), workflowExecutionInstanceId() {
+ }
+
+ virtual ~Experiment() throw() {}
+
+ std::string experimentID;
+ std::string projectID;
+ int64_t creationTime;
+ std::string userName;
+ std::string name;
+ std::string description;
+ std::string applicationId;
+ std::string applicationVersion;
+ std::string workflowTemplateId;
+ std::string workflowTemplateVersion;
+ UserConfigurationData userConfigurationData;
+ std::string workflowExecutionInstanceId;
+ std::vector<DataObjectType> experimentInputs;
+ std::vector<DataObjectType> experimentOutputs;
+ ExperimentStatus experimentStatus;
+ std::vector<WorkflowNodeStatus> stateChangeList;
+ std::vector<WorkflowNodeDetails> workflowNodeDetailsList;
+ std::vector<ErrorDetails> errors;
+
+ _Experiment__isset __isset;
+
+ void __set_experimentID(const std::string& val) {
+ experimentID = val;
+ }
+
+ void __set_projectID(const std::string& val) {
+ projectID = val;
+ }
+
+ void __set_creationTime(const int64_t val) {
+ creationTime = val;
+ __isset.creationTime = true;
+ }
+
+ void __set_userName(const std::string& val) {
+ userName = val;
+ }
+
+ void __set_name(const std::string& val) {
+ name = val;
+ }
+
+ void __set_description(const std::string& val) {
+ description = val;
+ __isset.description = true;
+ }
+
+ void __set_applicationId(const std::string& val) {
+ applicationId = val;
+ __isset.applicationId = true;
+ }
+
+ void __set_applicationVersion(const std::string& val) {
+ applicationVersion = val;
+ __isset.applicationVersion = true;
+ }
+
+ void __set_workflowTemplateId(const std::string& val) {
+ workflowTemplateId = val;
+ __isset.workflowTemplateId = true;
+ }
+
+ void __set_workflowTemplateVersion(const std::string& val) {
+ workflowTemplateVersion = val;
+ __isset.workflowTemplateVersion = true;
+ }
+
+ void __set_userConfigurationData(const UserConfigurationData& val) {
+ userConfigurationData = val;
+ __isset.userConfigurationData = true;
+ }
+
+ void __set_workflowExecutionInstanceId(const std::string& val) {
+ workflowExecutionInstanceId = val;
+ __isset.workflowExecutionInstanceId = true;
+ }
+
+ void __set_experimentInputs(const std::vector<DataObjectType> & val) {
+ experimentInputs = val;
+ __isset.experimentInputs = true;
+ }
+
+ void __set_experimentOutputs(const std::vector<DataObjectType> & val) {
+ experimentOutputs = val;
+ __isset.experimentOutputs = true;
+ }
+
+ void __set_experimentStatus(const ExperimentStatus& val) {
+ experimentStatus = val;
+ __isset.experimentStatus = true;
+ }
+
+ void __set_stateChangeList(const std::vector<WorkflowNodeStatus> & val) {
+ stateChangeList = val;
+ __isset.stateChangeList = true;
+ }
+
+ void __set_workflowNodeDetailsList(const std::vector<WorkflowNodeDetails> & val) {
+ workflowNodeDetailsList = val;
+ __isset.workflowNodeDetailsList = true;
+ }
+
+ void __set_errors(const std::vector<ErrorDetails> & val) {
+ errors = val;
+ __isset.errors = true;
+ }
+
+ bool operator == (const Experiment & rhs) const
+ {
+ if (!(experimentID == rhs.experimentID))
+ return false;
+ if (!(projectID == rhs.projectID))
+ return false;
+ if (__isset.creationTime != rhs.__isset.creationTime)
+ return false;
+ else if (__isset.creationTime && !(creationTime == rhs.creationTime))
+ return false;
+ if (!(userName == rhs.userName))
+ return false;
+ if (!(name == rhs.name))
+ return false;
+ if (__isset.description != rhs.__isset.description)
+ return false;
+ else if (__isset.description && !(description == rhs.description))
+ return false;
+ if (__isset.applicationId != rhs.__isset.applicationId)
+ return false;
+ else if (__isset.applicationId && !(applicationId == rhs.applicationId))
+ return false;
+ if (__isset.applicationVersion != rhs.__isset.applicationVersion)
+ return false;
+ else if (__isset.applicationVersion && !(applicationVersion == rhs.applicationVersion))
+ return false;
+ if (__isset.workflowTemplateId != rhs.__isset.workflowTemplateId)
+ return false;
+ else if (__isset.workflowTemplateId && !(workflowTemplateId == rhs.workflowTemplateId))
+ return false;
+ if (__isset.workflowTemplateVersion != rhs.__isset.workflowTemplateVersion)
+ return false;
+ else if (__isset.workflowTemplateVersion && !(workflowTemplateVersion == rhs.workflowTemplateVersion))
+ return false;
+ if (__isset.userConfigurationData != rhs.__isset.userConfigurationData)
+ return false;
+ else if (__isset.userConfigurationData && !(userConfigurationData == rhs.userConfigurationData))
+ return false;
+ if (__isset.workflowExecutionInstanceId != rhs.__isset.workflowExecutionInstanceId)
+ return false;
+ else if (__isset.workflowExecutionInstanceId && !(workflowExecutionInstanceId == rhs.workflowExecutionInstanceId))
+ return false;
+ if (__isset.experimentInputs != rhs.__isset.experimentInputs)
+ return false;
+ else if (__isset.experimentInputs && !(experimentInputs == rhs.experimentInputs))
+ return false;
+ if (__isset.experimentOutputs != rhs.__isset.experimentOutputs)
+ return false;
+ else if (__isset.experimentOutputs && !(experimentOutputs == rhs.experimentOutputs))
+ return false;
+ if (__isset.experimentStatus != rhs.__isset.experimentStatus)
+ return false;
+ else if (__isset.experimentStatus && !(experimentStatus == rhs.experimentStatus))
+ return false;
+ if (__isset.stateChangeList != rhs.__isset.stateChangeList)
+ return false;
+ else if (__isset.stateChangeList && !(stateChangeList == rhs.stateChangeList))
+ return false;
+ if (__isset.workflowNodeDetailsList != rhs.__isset.workflowNodeDetailsList)
+ return false;
+ else if (__isset.workflowNodeDetailsList && !(workflowNodeDetailsList == rhs.workflowNodeDetailsList))
+ return false;
+ if (__isset.errors != rhs.__isset.errors)
+ return false;
+ else if (__isset.errors && !(errors == rhs.errors))
+ return false;
+ return true;
+ }
+ bool operator != (const Experiment &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Experiment & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(Experiment &a, Experiment &b);
+
+typedef struct _ExperimentSummary__isset {
+ _ExperimentSummary__isset() : creationTime(false), description(false), applicationId(false), experimentStatus(false), errors(false) {}
+ bool creationTime;
+ bool description;
+ bool applicationId;
+ bool experimentStatus;
+ bool errors;
+} _ExperimentSummary__isset;
+
+class ExperimentSummary {
+ public:
+
+ static const char* ascii_fingerprint; // = "44FD485ABF32F5EB94D6F393F51241B6";
+ static const uint8_t binary_fingerprint[16]; // = {0x44,0xFD,0x48,0x5A,0xBF,0x32,0xF5,0xEB,0x94,0xD6,0xF3,0x93,0xF5,0x12,0x41,0xB6};
+
+ ExperimentSummary() : experimentID(), projectID(), creationTime(0), userName(), name(), description(), applicationId() {
+ }
+
+ virtual ~ExperimentSummary() throw() {}
+
+ std::string experimentID;
+ std::string projectID;
+ int64_t creationTime;
+ std::string userName;
+ std::string name;
+ std::string description;
+ std::string applicationId;
+ ExperimentStatus experimentStatus;
+ std::vector<ErrorDetails> errors;
+
+ _ExperimentSummary__isset __isset;
+
+ void __set_experimentID(const std::string& val) {
+ experimentID = val;
+ }
+
+ void __set_projectID(const std::string& val) {
+ projectID = val;
+ }
+
+ void __set_creationTime(const int64_t val) {
+ creationTime = val;
+ __isset.creationTime = true;
+ }
+
+ void __set_userName(const std::string& val) {
+ userName = val;
+ }
+
+ void __set_name(const std::string& val) {
+ name = val;
+ }
+
+ void __set_description(const std::string& val) {
+ description = val;
+ __isset.description = true;
+ }
+
+ void __set_applicationId(const std::string& val) {
+ applicationId = val;
+ __isset.applicationId = true;
+ }
+
+ void __set_experimentStatus(const ExperimentStatus& val) {
+ experimentStatus = val;
+ __isset.experimentStatus = true;
+ }
+
+ void __set_errors(const std::vector<ErrorDetails> & val) {
+ errors = val;
+ __isset.errors = true;
+ }
+
+ bool operator == (const ExperimentSummary & rhs) const
+ {
+ if (!(experimentID == rhs.experimentID))
+ return false;
+ if (!(projectID == rhs.projectID))
+ return false;
+ if (__isset.creationTime != rhs.__isset.creationTime)
+ return false;
+ else if (__isset.creationTime && !(creationTime == rhs.creationTime))
+ return false;
+ if (!(userName == rhs.userName))
+ return false;
+ if (!(name == rhs.name))
+ return false;
+ if (__isset.description != rhs.__isset.description)
+ return false;
+ else if (__isset.description && !(description == rhs.description))
+ return false;
+ if (__isset.applicationId != rhs.__isset.applicationId)
+ return false;
+ else if (__isset.applicationId && !(applicationId == rhs.applicationId))
+ return false;
+ if (__isset.experimentStatus != rhs.__isset.experimentStatus)
+ return false;
+ else if (__isset.experimentStatus && !(experimentStatus == rhs.experimentStatus))
+ return false;
+ if (__isset.errors != rhs.__isset.errors)
+ return false;
+ else if (__isset.errors && !(errors == rhs.errors))
+ return false;
+ return true;
+ }
+ bool operator != (const ExperimentSummary &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ExperimentSummary & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(ExperimentSummary &a, ExperimentSummary &b);
+
+}}}}} // namespace
+
+#endif
http://git-wip-us.apache.org/repos/asf/airavata/blob/f891b7dc/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/gatewayProfileModel_constants.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/gatewayProfileModel_constants.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/gatewayProfileModel_constants.cpp
new file mode 100644
index 0000000..8627ee3
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/gatewayProfileModel_constants.cpp
@@ -0,0 +1,19 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+#include "gatewayProfileModel_constants.h"
+
+
+
+const gatewayProfileModelConstants g_gatewayProfileModel_constants;
+
+gatewayProfileModelConstants::gatewayProfileModelConstants() {
+ DEFAULT_ID = "DO_NOT_SET_AT_CLIENTS";
+
+}
+
+
+
http://git-wip-us.apache.org/repos/asf/airavata/blob/f891b7dc/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/gatewayProfileModel_constants.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/gatewayProfileModel_constants.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/gatewayProfileModel_constants.h
new file mode 100644
index 0000000..4061d03
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/gatewayProfileModel_constants.h
@@ -0,0 +1,25 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+#ifndef gatewayProfileModel_CONSTANTS_H
+#define gatewayProfileModel_CONSTANTS_H
+
+#include "gatewayProfileModel_types.h"
+
+
+
+class gatewayProfileModelConstants {
+ public:
+ gatewayProfileModelConstants();
+
+ std::string DEFAULT_ID;
+};
+
+extern const gatewayProfileModelConstants g_gatewayProfileModel_constants;
+
+
+
+#endif
http://git-wip-us.apache.org/repos/asf/airavata/blob/f891b7dc/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/gatewayProfileModel_types.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/gatewayProfileModel_types.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/gatewayProfileModel_types.cpp
new file mode 100644
index 0000000..896a770
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/gatewayProfileModel_types.cpp
@@ -0,0 +1,293 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+#include "gatewayProfileModel_types.h"
+
+#include <algorithm>
+
+
+
+const char* ComputeResourcePreference::ascii_fingerprint = "9C98338B7E052CD4DEECB22F243D6DAE";
+const uint8_t ComputeResourcePreference::binary_fingerprint[16] = {0x9C,0x98,0x33,0x8B,0x7E,0x05,0x2C,0xD4,0xDE,0xEC,0xB2,0x2F,0x24,0x3D,0x6D,0xAE};
+
+uint32_t ComputeResourcePreference::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_overridebyAiravata = 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_BOOL) {
+ xfer += iprot->readBool(this->overridebyAiravata);
+ isset_overridebyAiravata = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->preferredJobSubmissionProtocol);
+ this->__isset.preferredJobSubmissionProtocol = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->preferredDataMovementProtocol);
+ this->__isset.preferredDataMovementProtocol = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 5:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->preferredBatchQueue);
+ this->__isset.preferredBatchQueue = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 6:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->scratchLocation);
+ this->__isset.scratchLocation = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 7:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->allocationProjectNumber);
+ this->__isset.allocationProjectNumber = 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_overridebyAiravata)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t ComputeResourcePreference::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ComputeResourcePreference");
+
+ xfer += oprot->writeFieldBegin("computeResourceId", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->computeResourceId);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("overridebyAiravata", ::apache::thrift::protocol::T_BOOL, 2);
+ xfer += oprot->writeBool(this->overridebyAiravata);
+ xfer += oprot->writeFieldEnd();
+
+ if (this->__isset.preferredJobSubmissionProtocol) {
+ xfer += oprot->writeFieldBegin("preferredJobSubmissionProtocol", ::apache::thrift::protocol::T_STRING, 3);
+ xfer += oprot->writeString(this->preferredJobSubmissionProtocol);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.preferredDataMovementProtocol) {
+ xfer += oprot->writeFieldBegin("preferredDataMovementProtocol", ::apache::thrift::protocol::T_STRING, 4);
+ xfer += oprot->writeString(this->preferredDataMovementProtocol);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.preferredBatchQueue) {
+ xfer += oprot->writeFieldBegin("preferredBatchQueue", ::apache::thrift::protocol::T_STRING, 5);
+ xfer += oprot->writeString(this->preferredBatchQueue);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.scratchLocation) {
+ xfer += oprot->writeFieldBegin("scratchLocation", ::apache::thrift::protocol::T_STRING, 6);
+ xfer += oprot->writeString(this->scratchLocation);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.allocationProjectNumber) {
+ xfer += oprot->writeFieldBegin("allocationProjectNumber", ::apache::thrift::protocol::T_STRING, 7);
+ xfer += oprot->writeString(this->allocationProjectNumber);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(ComputeResourcePreference &a, ComputeResourcePreference &b) {
+ using ::std::swap;
+ swap(a.computeResourceId, b.computeResourceId);
+ swap(a.overridebyAiravata, b.overridebyAiravata);
+ swap(a.preferredJobSubmissionProtocol, b.preferredJobSubmissionProtocol);
+ swap(a.preferredDataMovementProtocol, b.preferredDataMovementProtocol);
+ swap(a.preferredBatchQueue, b.preferredBatchQueue);
+ swap(a.scratchLocation, b.scratchLocation);
+ swap(a.allocationProjectNumber, b.allocationProjectNumber);
+ swap(a.__isset, b.__isset);
+}
+
+const char* GatewayProfile::ascii_fingerprint = "D6477904C48AAB4DC8F09369D670B400";
+const uint8_t GatewayProfile::binary_fingerprint[16] = {0xD6,0x47,0x79,0x04,0xC4,0x8A,0xAB,0x4D,0xC8,0xF0,0x93,0x69,0xD6,0x70,0xB4,0x00};
+
+uint32_t GatewayProfile::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_gatewayID = false;
+ bool isset_gatewayName = 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->gatewayID);
+ isset_gatewayID = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->gatewayName);
+ isset_gatewayName = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->gatewayDescription);
+ this->__isset.gatewayDescription = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->computeResourcePreferences.clear();
+ uint32_t _size0;
+ ::apache::thrift::protocol::TType _etype3;
+ xfer += iprot->readListBegin(_etype3, _size0);
+ this->computeResourcePreferences.resize(_size0);
+ uint32_t _i4;
+ for (_i4 = 0; _i4 < _size0; ++_i4)
+ {
+ xfer += this->computeResourcePreferences[_i4].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.computeResourcePreferences = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_gatewayID)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_gatewayName)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t GatewayProfile::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("GatewayProfile");
+
+ xfer += oprot->writeFieldBegin("gatewayID", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->gatewayID);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("gatewayName", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->gatewayName);
+ xfer += oprot->writeFieldEnd();
+
+ if (this->__isset.gatewayDescription) {
+ xfer += oprot->writeFieldBegin("gatewayDescription", ::apache::thrift::protocol::T_STRING, 3);
+ xfer += oprot->writeString(this->gatewayDescription);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.computeResourcePreferences) {
+ xfer += oprot->writeFieldBegin("computeResourcePreferences", ::apache::thrift::protocol::T_LIST, 4);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->computeResourcePreferences.size()));
+ std::vector<ComputeResourcePreference> ::const_iterator _iter5;
+ for (_iter5 = this->computeResourcePreferences.begin(); _iter5 != this->computeResourcePreferences.end(); ++_iter5)
+ {
+ xfer += (*_iter5).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(GatewayProfile &a, GatewayProfile &b) {
+ using ::std::swap;
+ swap(a.gatewayID, b.gatewayID);
+ swap(a.gatewayName, b.gatewayName);
+ swap(a.gatewayDescription, b.gatewayDescription);
+ swap(a.computeResourcePreferences, b.computeResourcePreferences);
+ swap(a.__isset, b.__isset);
+}
+
+
http://git-wip-us.apache.org/repos/asf/airavata/blob/f891b7dc/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/gatewayProfileModel_types.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/gatewayProfileModel_types.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/gatewayProfileModel_types.h
new file mode 100644
index 0000000..6bab76c
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/gatewayProfileModel_types.h
@@ -0,0 +1,197 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+#ifndef gatewayProfileModel_TYPES_H
+#define gatewayProfileModel_TYPES_H
+
+#include <thrift/Thrift.h>
+#include <thrift/TApplicationException.h>
+#include <thrift/protocol/TProtocol.h>
+#include <thrift/transport/TTransport.h>
+
+#include <thrift/cxxfunctional.h>
+
+
+
+
+typedef struct _ComputeResourcePreference__isset {
+ _ComputeResourcePreference__isset() : preferredJobSubmissionProtocol(false), preferredDataMovementProtocol(false), preferredBatchQueue(false), scratchLocation(false), allocationProjectNumber(false) {}
+ bool preferredJobSubmissionProtocol;
+ bool preferredDataMovementProtocol;
+ bool preferredBatchQueue;
+ bool scratchLocation;
+ bool allocationProjectNumber;
+} _ComputeResourcePreference__isset;
+
+class ComputeResourcePreference {
+ public:
+
+ static const char* ascii_fingerprint; // = "9C98338B7E052CD4DEECB22F243D6DAE";
+ static const uint8_t binary_fingerprint[16]; // = {0x9C,0x98,0x33,0x8B,0x7E,0x05,0x2C,0xD4,0xDE,0xEC,0xB2,0x2F,0x24,0x3D,0x6D,0xAE};
+
+ ComputeResourcePreference() : computeResourceId(), overridebyAiravata(true), preferredJobSubmissionProtocol(), preferredDataMovementProtocol(), preferredBatchQueue(), scratchLocation(), allocationProjectNumber() {
+ }
+
+ virtual ~ComputeResourcePreference() throw() {}
+
+ std::string computeResourceId;
+ bool overridebyAiravata;
+ std::string preferredJobSubmissionProtocol;
+ std::string preferredDataMovementProtocol;
+ std::string preferredBatchQueue;
+ std::string scratchLocation;
+ std::string allocationProjectNumber;
+
+ _ComputeResourcePreference__isset __isset;
+
+ void __set_computeResourceId(const std::string& val) {
+ computeResourceId = val;
+ }
+
+ void __set_overridebyAiravata(const bool val) {
+ overridebyAiravata = val;
+ }
+
+ void __set_preferredJobSubmissionProtocol(const std::string& val) {
+ preferredJobSubmissionProtocol = val;
+ __isset.preferredJobSubmissionProtocol = true;
+ }
+
+ void __set_preferredDataMovementProtocol(const std::string& val) {
+ preferredDataMovementProtocol = val;
+ __isset.preferredDataMovementProtocol = true;
+ }
+
+ void __set_preferredBatchQueue(const std::string& val) {
+ preferredBatchQueue = val;
+ __isset.preferredBatchQueue = true;
+ }
+
+ void __set_scratchLocation(const std::string& val) {
+ scratchLocation = val;
+ __isset.scratchLocation = true;
+ }
+
+ void __set_allocationProjectNumber(const std::string& val) {
+ allocationProjectNumber = val;
+ __isset.allocationProjectNumber = true;
+ }
+
+ bool operator == (const ComputeResourcePreference & rhs) const
+ {
+ if (!(computeResourceId == rhs.computeResourceId))
+ return false;
+ if (!(overridebyAiravata == rhs.overridebyAiravata))
+ return false;
+ if (__isset.preferredJobSubmissionProtocol != rhs.__isset.preferredJobSubmissionProtocol)
+ return false;
+ else if (__isset.preferredJobSubmissionProtocol && !(preferredJobSubmissionProtocol == rhs.preferredJobSubmissionProtocol))
+ return false;
+ if (__isset.preferredDataMovementProtocol != rhs.__isset.preferredDataMovementProtocol)
+ return false;
+ else if (__isset.preferredDataMovementProtocol && !(preferredDataMovementProtocol == rhs.preferredDataMovementProtocol))
+ return false;
+ if (__isset.preferredBatchQueue != rhs.__isset.preferredBatchQueue)
+ return false;
+ else if (__isset.preferredBatchQueue && !(preferredBatchQueue == rhs.preferredBatchQueue))
+ return false;
+ if (__isset.scratchLocation != rhs.__isset.scratchLocation)
+ return false;
+ else if (__isset.scratchLocation && !(scratchLocation == rhs.scratchLocation))
+ return false;
+ if (__isset.allocationProjectNumber != rhs.__isset.allocationProjectNumber)
+ return false;
+ else if (__isset.allocationProjectNumber && !(allocationProjectNumber == rhs.allocationProjectNumber))
+ return false;
+ return true;
+ }
+ bool operator != (const ComputeResourcePreference &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ComputeResourcePreference & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(ComputeResourcePreference &a, ComputeResourcePreference &b);
+
+typedef struct _GatewayProfile__isset {
+ _GatewayProfile__isset() : gatewayDescription(false), computeResourcePreferences(false) {}
+ bool gatewayDescription;
+ bool computeResourcePreferences;
+} _GatewayProfile__isset;
+
+class GatewayProfile {
+ public:
+
+ static const char* ascii_fingerprint; // = "D6477904C48AAB4DC8F09369D670B400";
+ static const uint8_t binary_fingerprint[16]; // = {0xD6,0x47,0x79,0x04,0xC4,0x8A,0xAB,0x4D,0xC8,0xF0,0x93,0x69,0xD6,0x70,0xB4,0x00};
+
+ GatewayProfile() : gatewayID("DO_NOT_SET_AT_CLIENTS"), gatewayName(), gatewayDescription() {
+ }
+
+ virtual ~GatewayProfile() throw() {}
+
+ std::string gatewayID;
+ std::string gatewayName;
+ std::string gatewayDescription;
+ std::vector<ComputeResourcePreference> computeResourcePreferences;
+
+ _GatewayProfile__isset __isset;
+
+ void __set_gatewayID(const std::string& val) {
+ gatewayID = val;
+ }
+
+ void __set_gatewayName(const std::string& val) {
+ gatewayName = val;
+ }
+
+ void __set_gatewayDescription(const std::string& val) {
+ gatewayDescription = val;
+ __isset.gatewayDescription = true;
+ }
+
+ void __set_computeResourcePreferences(const std::vector<ComputeResourcePreference> & val) {
+ computeResourcePreferences = val;
+ __isset.computeResourcePreferences = true;
+ }
+
+ bool operator == (const GatewayProfile & rhs) const
+ {
+ if (!(gatewayID == rhs.gatewayID))
+ return false;
+ if (!(gatewayName == rhs.gatewayName))
+ return false;
+ if (__isset.gatewayDescription != rhs.__isset.gatewayDescription)
+ return false;
+ else if (__isset.gatewayDescription && !(gatewayDescription == rhs.gatewayDescription))
+ return false;
+ if (__isset.computeResourcePreferences != rhs.__isset.computeResourcePreferences)
+ return false;
+ else if (__isset.computeResourcePreferences && !(computeResourcePreferences == rhs.computeResourcePreferences))
+ return false;
+ return true;
+ }
+ bool operator != (const GatewayProfile &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const GatewayProfile & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(GatewayProfile &a, GatewayProfile &b);
+
+
+
+#endif
http://git-wip-us.apache.org/repos/asf/airavata/blob/f891b7dc/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/gatewayResourceProfileModel_constants.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/gatewayResourceProfileModel_constants.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/gatewayResourceProfileModel_constants.cpp
new file mode 100644
index 0000000..1b7a9c1
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/gatewayResourceProfileModel_constants.cpp
@@ -0,0 +1,19 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+#include "gatewayResourceProfileModel_constants.h"
+
+namespace apache { namespace airavata { namespace model { namespace appcatalog { namespace gatewayprofile {
+
+const gatewayResourceProfileModelConstants g_gatewayResourceProfileModel_constants;
+
+gatewayResourceProfileModelConstants::gatewayResourceProfileModelConstants() {
+ DEFAULT_ID = "DO_NOT_SET_AT_CLIENTS";
+
+}
+
+}}}}} // namespace
+