You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@airavata.apache.org by sa...@apache.org on 2014/04/17 04:17:25 UTC
[16/31] AIRAVATA-1144
http://git-wip-us.apache.org/repos/asf/airavata/blob/4903770b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/experimentModel_types.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/experimentModel_types.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/experimentModel_types.h
new file mode 100644
index 0000000..c0ec3c2
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/experimentModel_types.h
@@ -0,0 +1,1801 @@
+/**
+ * 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>
+
+
+
+
+struct ExperimentState {
+ enum type {
+ CREATED = 0,
+ VALIDATED = 1,
+ SCHEDULED = 2,
+ LAUNCHED = 3,
+ EXECUTING = 4,
+ CANCELED = 5,
+ COMPLETED = 6,
+ FAILED = 7,
+ UNKNOWN = 8
+ };
+};
+
+extern const std::map<int, const char*> _ExperimentState_VALUES_TO_NAMES;
+
+struct WorkflowNodeState {
+ enum type {
+ INVOKED = 0,
+ EXECUTING = 1,
+ CANCELED = 2,
+ COMPLETED = 3,
+ FAILED = 4,
+ UNKNOWN = 5
+ };
+};
+
+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,
+ CANCELED = 8,
+ COMPLETED = 9,
+ FAILED = 10,
+ UNKNOWN = 11
+ };
+};
+
+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,
+ CANCELED = 6,
+ FAILED = 7,
+ HELD = 8,
+ SUSPENDED = 9,
+ UNKNOWN = 10
+ };
+};
+
+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,
+ CANCELED = 7,
+ FAILED = 8,
+ HELD = 9,
+ SUSPENDED = 10,
+ UNKNOWN = 11
+ };
+};
+
+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;
+
+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; // = "6BA700CA2E5FC52A8DA5ADCF811DC8DA";
+ static const uint8_t binary_fingerprint[16]; // = {0x6B,0xA7,0x00,0xCA,0x2E,0x5F,0xC5,0x2A,0x8D,0xA5,0xAD,0xCF,0x81,0x1D,0xC8,0xDA};
+
+ DataObjectType() : key(), value(), type(), metaData() {
+ }
+
+ virtual ~DataObjectType() throw() {}
+
+ std::string key;
+ std::string value;
+ std::string 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 std::string& 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), 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 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; // = "705A0D2F86DF8E37DD3741EEF4EB51A0";
+ static const uint8_t binary_fingerprint[16]; // = {0x70,0x5A,0x0D,0x2F,0x86,0xDF,0x8E,0x37,0xDD,0x37,0x41,0xEE,0xF4,0xEB,0x51,0xA0};
+
+ TaskDetails() : taskID("DO_NOT_SET_AT_CLIENTS"), creationTime(0), applicationId(), applicationVersion() {
+ }
+
+ virtual ~TaskDetails() throw() {}
+
+ std::string taskID;
+ int64_t creationTime;
+ std::string applicationId;
+ std::string applicationVersion;
+ 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_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.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), nodeInputs(false), nodeOutputs(false), workflowNodeStatus(false), taskDetailsList(false), errors(false) {}
+ bool creationTime;
+ bool nodeInputs;
+ bool nodeOutputs;
+ bool workflowNodeStatus;
+ bool taskDetailsList;
+ bool errors;
+} _WorkflowNodeDetails__isset;
+
+class WorkflowNodeDetails {
+ public:
+
+ static const char* ascii_fingerprint; // = "D244C94A6A1DF1DFBA2E34E7756C28EF";
+ static const uint8_t binary_fingerprint[16]; // = {0xD2,0x44,0xC9,0x4A,0x6A,0x1D,0xF1,0xDF,0xBA,0x2E,0x34,0xE7,0x75,0x6C,0x28,0xEF};
+
+ WorkflowNodeDetails() : nodeInstanceId("DO_NOT_SET_AT_CLIENTS"), creationTime(0), nodeName("SINGLE_APP_NODE") {
+ }
+
+ virtual ~WorkflowNodeDetails() throw() {}
+
+ std::string nodeInstanceId;
+ int64_t creationTime;
+ std::string nodeName;
+ 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_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 (__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 _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; // = "AAEAE252F6A2D0BD15514CB57DB7745F";
+ static const uint8_t binary_fingerprint[16]; // = {0xAA,0xEA,0xE2,0x52,0xF6,0xA2,0xD0,0xBD,0x15,0x51,0x4C,0xB5,0x7D,0xB7,0x74,0x5F};
+
+ 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);
+
+
+
+#endif
http://git-wip-us.apache.org/repos/asf/airavata/blob/4903770b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/workspaceModel_constants.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/workspaceModel_constants.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/workspaceModel_constants.cpp
new file mode 100644
index 0000000..656aed3
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/workspaceModel_constants.cpp
@@ -0,0 +1,17 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+#include "workspaceModel_constants.h"
+
+
+
+const workspaceModelConstants g_workspaceModel_constants;
+
+workspaceModelConstants::workspaceModelConstants() {
+}
+
+
+
http://git-wip-us.apache.org/repos/asf/airavata/blob/4903770b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/workspaceModel_constants.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/workspaceModel_constants.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/workspaceModel_constants.h
new file mode 100644
index 0000000..d3417fd
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/workspaceModel_constants.h
@@ -0,0 +1,24 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+#ifndef workspaceModel_CONSTANTS_H
+#define workspaceModel_CONSTANTS_H
+
+#include "workspaceModel_types.h"
+
+
+
+class workspaceModelConstants {
+ public:
+ workspaceModelConstants();
+
+};
+
+extern const workspaceModelConstants g_workspaceModel_constants;
+
+
+
+#endif
http://git-wip-us.apache.org/repos/asf/airavata/blob/4903770b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/workspaceModel_types.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/workspaceModel_types.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/workspaceModel_types.cpp
new file mode 100644
index 0000000..dd81192
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/workspaceModel_types.cpp
@@ -0,0 +1,464 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+#include "workspaceModel_types.h"
+
+#include <algorithm>
+
+
+
+const char* Group::ascii_fingerprint = "5B708A954C550ECA9C1A49D3C5CAFAB9";
+const uint8_t Group::binary_fingerprint[16] = {0x5B,0x70,0x8A,0x95,0x4C,0x55,0x0E,0xCA,0x9C,0x1A,0x49,0xD3,0xC5,0xCA,0xFA,0xB9};
+
+uint32_t Group::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_groupName = 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->groupName);
+ isset_groupName = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->description);
+ this->__isset.description = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_groupName)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t Group::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Group");
+
+ xfer += oprot->writeFieldBegin("groupName", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->groupName);
+ xfer += oprot->writeFieldEnd();
+
+ if (this->__isset.description) {
+ xfer += oprot->writeFieldBegin("description", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->description);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(Group &a, Group &b) {
+ using ::std::swap;
+ swap(a.groupName, b.groupName);
+ swap(a.description, b.description);
+ swap(a.__isset, b.__isset);
+}
+
+const char* Project::ascii_fingerprint = "AFD8090DE564134035942D450F918628";
+const uint8_t Project::binary_fingerprint[16] = {0xAF,0xD8,0x09,0x0D,0xE5,0x64,0x13,0x40,0x35,0x94,0x2D,0x45,0x0F,0x91,0x86,0x28};
+
+uint32_t Project::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_projectID = false;
+ bool isset_owner = false;
+ bool isset_name = 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->projectID);
+ isset_projectID = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->owner);
+ isset_owner = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->name);
+ isset_name = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->description);
+ this->__isset.description = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 5:
+ if (ftype == ::apache::thrift::protocol::T_I64) {
+ xfer += iprot->readI64(this->creationTime);
+ this->__isset.creationTime = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 6:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->sharedUsers.clear();
+ uint32_t _size0;
+ ::apache::thrift::protocol::TType _etype3;
+ xfer += iprot->readListBegin(_etype3, _size0);
+ this->sharedUsers.resize(_size0);
+ uint32_t _i4;
+ for (_i4 = 0; _i4 < _size0; ++_i4)
+ {
+ xfer += iprot->readString(this->sharedUsers[_i4]);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.sharedUsers = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 7:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->sharedGroups.clear();
+ uint32_t _size5;
+ ::apache::thrift::protocol::TType _etype8;
+ xfer += iprot->readListBegin(_etype8, _size5);
+ this->sharedGroups.resize(_size5);
+ uint32_t _i9;
+ for (_i9 = 0; _i9 < _size5; ++_i9)
+ {
+ xfer += iprot->readString(this->sharedGroups[_i9]);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.sharedGroups = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_projectID)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_owner)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_name)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t Project::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Project");
+
+ xfer += oprot->writeFieldBegin("projectID", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->projectID);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("owner", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->owner);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 3);
+ xfer += oprot->writeString(this->name);
+ xfer += oprot->writeFieldEnd();
+
+ if (this->__isset.description) {
+ xfer += oprot->writeFieldBegin("description", ::apache::thrift::protocol::T_STRING, 4);
+ xfer += oprot->writeString(this->description);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.creationTime) {
+ xfer += oprot->writeFieldBegin("creationTime", ::apache::thrift::protocol::T_I64, 5);
+ xfer += oprot->writeI64(this->creationTime);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.sharedUsers) {
+ xfer += oprot->writeFieldBegin("sharedUsers", ::apache::thrift::protocol::T_LIST, 6);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->sharedUsers.size()));
+ std::vector<std::string> ::const_iterator _iter10;
+ for (_iter10 = this->sharedUsers.begin(); _iter10 != this->sharedUsers.end(); ++_iter10)
+ {
+ xfer += oprot->writeString((*_iter10));
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.sharedGroups) {
+ xfer += oprot->writeFieldBegin("sharedGroups", ::apache::thrift::protocol::T_LIST, 7);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->sharedGroups.size()));
+ std::vector<std::string> ::const_iterator _iter11;
+ for (_iter11 = this->sharedGroups.begin(); _iter11 != this->sharedGroups.end(); ++_iter11)
+ {
+ xfer += oprot->writeString((*_iter11));
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(Project &a, Project &b) {
+ using ::std::swap;
+ swap(a.projectID, b.projectID);
+ swap(a.owner, b.owner);
+ swap(a.name, b.name);
+ swap(a.description, b.description);
+ swap(a.creationTime, b.creationTime);
+ swap(a.sharedUsers, b.sharedUsers);
+ swap(a.sharedGroups, b.sharedGroups);
+ swap(a.__isset, b.__isset);
+}
+
+const char* User::ascii_fingerprint = "D7DA282D6B2F08CB02B4E3CF47DB44E5";
+const uint8_t User::binary_fingerprint[16] = {0xD7,0xDA,0x28,0x2D,0x6B,0x2F,0x08,0xCB,0x02,0xB4,0xE3,0xCF,0x47,0xDB,0x44,0xE5};
+
+uint32_t User::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_userName = 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->userName);
+ isset_userName = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->groupList.clear();
+ uint32_t _size12;
+ ::apache::thrift::protocol::TType _etype15;
+ xfer += iprot->readListBegin(_etype15, _size12);
+ this->groupList.resize(_size12);
+ uint32_t _i16;
+ for (_i16 = 0; _i16 < _size12; ++_i16)
+ {
+ xfer += this->groupList[_i16].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.groupList = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_userName)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t User::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("User");
+
+ xfer += oprot->writeFieldBegin("userName", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->userName);
+ xfer += oprot->writeFieldEnd();
+
+ if (this->__isset.groupList) {
+ xfer += oprot->writeFieldBegin("groupList", ::apache::thrift::protocol::T_LIST, 2);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->groupList.size()));
+ std::vector<Group> ::const_iterator _iter17;
+ for (_iter17 = this->groupList.begin(); _iter17 != this->groupList.end(); ++_iter17)
+ {
+ xfer += (*_iter17).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(User &a, User &b) {
+ using ::std::swap;
+ swap(a.userName, b.userName);
+ swap(a.groupList, b.groupList);
+ swap(a.__isset, b.__isset);
+}
+
+const char* Gateway::ascii_fingerprint = "07A9615F837F7D0A952B595DD3020972";
+const uint8_t Gateway::binary_fingerprint[16] = {0x07,0xA9,0x61,0x5F,0x83,0x7F,0x7D,0x0A,0x95,0x2B,0x59,0x5D,0xD3,0x02,0x09,0x72};
+
+uint32_t Gateway::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_name = 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->name);
+ isset_name = 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_name)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t Gateway::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Gateway");
+
+ xfer += oprot->writeFieldBegin("gatewayId", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->gatewayId);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->name);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(Gateway &a, Gateway &b) {
+ using ::std::swap;
+ swap(a.gatewayId, b.gatewayId);
+ swap(a.name, b.name);
+}
+
+
http://git-wip-us.apache.org/repos/asf/airavata/blob/4903770b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/workspaceModel_types.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/workspaceModel_types.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/workspaceModel_types.h
new file mode 100644
index 0000000..340fd54
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/workspaceModel_types.h
@@ -0,0 +1,273 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+#ifndef workspaceModel_TYPES_H
+#define workspaceModel_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 "experimentModel_types.h"
+
+
+
+
+typedef struct _Group__isset {
+ _Group__isset() : description(false) {}
+ bool description;
+} _Group__isset;
+
+class Group {
+ public:
+
+ static const char* ascii_fingerprint; // = "5B708A954C550ECA9C1A49D3C5CAFAB9";
+ static const uint8_t binary_fingerprint[16]; // = {0x5B,0x70,0x8A,0x95,0x4C,0x55,0x0E,0xCA,0x9C,0x1A,0x49,0xD3,0xC5,0xCA,0xFA,0xB9};
+
+ Group() : groupName(), description() {
+ }
+
+ virtual ~Group() throw() {}
+
+ std::string groupName;
+ std::string description;
+
+ _Group__isset __isset;
+
+ void __set_groupName(const std::string& val) {
+ groupName = val;
+ }
+
+ void __set_description(const std::string& val) {
+ description = val;
+ __isset.description = true;
+ }
+
+ bool operator == (const Group & rhs) const
+ {
+ if (!(groupName == rhs.groupName))
+ return false;
+ if (__isset.description != rhs.__isset.description)
+ return false;
+ else if (__isset.description && !(description == rhs.description))
+ return false;
+ return true;
+ }
+ bool operator != (const Group &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Group & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(Group &a, Group &b);
+
+typedef struct _Project__isset {
+ _Project__isset() : description(false), creationTime(false), sharedUsers(false), sharedGroups(false) {}
+ bool description;
+ bool creationTime;
+ bool sharedUsers;
+ bool sharedGroups;
+} _Project__isset;
+
+class Project {
+ public:
+
+ static const char* ascii_fingerprint; // = "AFD8090DE564134035942D450F918628";
+ static const uint8_t binary_fingerprint[16]; // = {0xAF,0xD8,0x09,0x0D,0xE5,0x64,0x13,0x40,0x35,0x94,0x2D,0x45,0x0F,0x91,0x86,0x28};
+
+ Project() : projectID("DEFAULT"), owner(), name(), description(), creationTime(0) {
+ }
+
+ virtual ~Project() throw() {}
+
+ std::string projectID;
+ std::string owner;
+ std::string name;
+ std::string description;
+ int64_t creationTime;
+ std::vector<std::string> sharedUsers;
+ std::vector<std::string> sharedGroups;
+
+ _Project__isset __isset;
+
+ void __set_projectID(const std::string& val) {
+ projectID = val;
+ }
+
+ void __set_owner(const std::string& val) {
+ owner = val;
+ }
+
+ void __set_name(const std::string& val) {
+ name = val;
+ }
+
+ void __set_description(const std::string& val) {
+ description = val;
+ __isset.description = true;
+ }
+
+ void __set_creationTime(const int64_t val) {
+ creationTime = val;
+ __isset.creationTime = true;
+ }
+
+ void __set_sharedUsers(const std::vector<std::string> & val) {
+ sharedUsers = val;
+ __isset.sharedUsers = true;
+ }
+
+ void __set_sharedGroups(const std::vector<std::string> & val) {
+ sharedGroups = val;
+ __isset.sharedGroups = true;
+ }
+
+ bool operator == (const Project & rhs) const
+ {
+ if (!(projectID == rhs.projectID))
+ return false;
+ if (!(owner == rhs.owner))
+ 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.creationTime != rhs.__isset.creationTime)
+ return false;
+ else if (__isset.creationTime && !(creationTime == rhs.creationTime))
+ return false;
+ if (__isset.sharedUsers != rhs.__isset.sharedUsers)
+ return false;
+ else if (__isset.sharedUsers && !(sharedUsers == rhs.sharedUsers))
+ return false;
+ if (__isset.sharedGroups != rhs.__isset.sharedGroups)
+ return false;
+ else if (__isset.sharedGroups && !(sharedGroups == rhs.sharedGroups))
+ return false;
+ return true;
+ }
+ bool operator != (const Project &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Project & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(Project &a, Project &b);
+
+typedef struct _User__isset {
+ _User__isset() : groupList(false) {}
+ bool groupList;
+} _User__isset;
+
+class User {
+ public:
+
+ static const char* ascii_fingerprint; // = "D7DA282D6B2F08CB02B4E3CF47DB44E5";
+ static const uint8_t binary_fingerprint[16]; // = {0xD7,0xDA,0x28,0x2D,0x6B,0x2F,0x08,0xCB,0x02,0xB4,0xE3,0xCF,0x47,0xDB,0x44,0xE5};
+
+ User() : userName() {
+ }
+
+ virtual ~User() throw() {}
+
+ std::string userName;
+ std::vector<Group> groupList;
+
+ _User__isset __isset;
+
+ void __set_userName(const std::string& val) {
+ userName = val;
+ }
+
+ void __set_groupList(const std::vector<Group> & val) {
+ groupList = val;
+ __isset.groupList = true;
+ }
+
+ bool operator == (const User & rhs) const
+ {
+ if (!(userName == rhs.userName))
+ return false;
+ if (__isset.groupList != rhs.__isset.groupList)
+ return false;
+ else if (__isset.groupList && !(groupList == rhs.groupList))
+ return false;
+ return true;
+ }
+ bool operator != (const User &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const User & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(User &a, User &b);
+
+
+class Gateway {
+ public:
+
+ static const char* ascii_fingerprint; // = "07A9615F837F7D0A952B595DD3020972";
+ static const uint8_t binary_fingerprint[16]; // = {0x07,0xA9,0x61,0x5F,0x83,0x7F,0x7D,0x0A,0x95,0x2B,0x59,0x5D,0xD3,0x02,0x09,0x72};
+
+ Gateway() : gatewayId("DO_NOT_SET_AT_CLIENTS"), name() {
+ }
+
+ virtual ~Gateway() throw() {}
+
+ std::string gatewayId;
+ std::string name;
+
+ void __set_gatewayId(const std::string& val) {
+ gatewayId = val;
+ }
+
+ void __set_name(const std::string& val) {
+ name = val;
+ }
+
+ bool operator == (const Gateway & rhs) const
+ {
+ if (!(gatewayId == rhs.gatewayId))
+ return false;
+ if (!(name == rhs.name))
+ return false;
+ return true;
+ }
+ bool operator != (const Gateway &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Gateway & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(Gateway &a, Gateway &b);
+
+
+
+#endif