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/03/12 19:01:47 UTC
[1/6] Generated C++ Client SDK - AIRAVATA-1075
Repository: airavata
Updated Branches:
refs/heads/master 576729b3e -> 77758cb9f
http://git-wip-us.apache.org/repos/asf/airavata/blob/77758cb9/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/experimentModel_types.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/experimentModel_types.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/experimentModel_types.h
new file mode 100644
index 0000000..c0ec3c2
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/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/77758cb9/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/workspaceModel_constants.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/workspaceModel_constants.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/workspaceModel_constants.cpp
new file mode 100644
index 0000000..656aed3
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/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/77758cb9/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/workspaceModel_constants.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/workspaceModel_constants.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/workspaceModel_constants.h
new file mode 100644
index 0000000..d3417fd
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/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/77758cb9/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/workspaceModel_types.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/workspaceModel_types.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/workspaceModel_types.cpp
new file mode 100644
index 0000000..dd81192
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/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/77758cb9/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/workspaceModel_types.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/workspaceModel_types.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/workspaceModel_types.h
new file mode 100644
index 0000000..340fd54
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/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
http://git-wip-us.apache.org/repos/asf/airavata/blob/77758cb9/airavata-api/generate-thrift-files.sh
----------------------------------------------------------------------
diff --git a/airavata-api/generate-thrift-files.sh b/airavata-api/generate-thrift-files.sh
index 236780e..c12a488 100755
--- a/airavata-api/generate-thrift-files.sh
+++ b/airavata-api/generate-thrift-files.sh
@@ -25,6 +25,7 @@ THRIFT_IDL_DIR='thrift-interface-descriptions'
BASE_TARGET_DIR='target'
DATAMODEL_SRC_DIR='airavata-data-models/src/main/java'
JAVA_API_SDK_DIR='airavata-api-stubs/src/main/java'
+CPP_SDK_DIR='airavata-client-sdks/airavata-cpp-sdk/airavata-stubs'
# The Funcation fail prints error messages on failure and quits the script.
fail() {
@@ -106,9 +107,9 @@ THRIFT_ARGS="-r -o ${BASE_TARGET_DIR}"
# Ensure the required target directories exists, if not create.
mkdir -p ${BASE_TARGET_DIR}
-##############################
-# Update Airavata Data Model #
-##############################
+#######################################
+# Generate/Update Airavata Data Model #
+#######################################
#Java Beans generation directory
JAVA_BEAN_GEN_DIR=${BASE_TARGET_DIR}/gen-javabean
@@ -127,10 +128,10 @@ add_license_header ${JAVA_BEAN_GEN_DIR}
# Compare the newly generated beans with existing sources and replace the changed ones.
copy_changed_files ${JAVA_BEAN_GEN_DIR} ${DATAMODEL_SRC_DIR}
-######################################################################
-# Update source used by Airavata Server Skeltons & Java Client Stubs #
-# JAVA server and client both use generated api-boilerplate-code #
-######################################################################
+###############################################################################
+# Generate/Update source used by Airavata Server Skeltons & Java Client Stubs #
+# JAVA server and client both use generated api-boilerplate-code #
+###############################################################################
#Java generation directory
JAVA_GEN_DIR=${BASE_TARGET_DIR}/gen-java
@@ -149,6 +150,30 @@ add_license_header $JAVA_GEN_DIR
# Only copying the API related classes and avoiding copy of any data models which already exist in the data-models.
copy_changed_files ${JAVA_GEN_DIR}/org/apache/airavata/api ${JAVA_API_SDK_DIR}/org/apache/airavata/api
+####################################
+# Generate/Update C++ Client Stubs #
+####################################
+
+#Java generation directory
+CPP_GEN_DIR=${BASE_TARGET_DIR}/gen-cpp
+
+# As a precausion remove and previously generated files if exists
+rm -rf ${CPP_GEN_DIR}
+
+# Using thrify Java generator, generate the java classes based on Airavata API. This
+# The airavataAPI.thrift includes rest of data models.
+thrift ${THRIFT_ARGS} --gen cpp ${THRIFT_IDL_DIR}/airavataAPI.thrift || fail unable to generate C++ thrift classes
+
+# For the generated java classes add the ASF V2 License header
+## TODO Write C++ license parser
+
+# Compare the newly generated classes with existing java generated skelton/stub sources and replace the changed ones.
+# Only copying the API related classes and avoiding copy of any data models which already exist in the data-models.
+copy_changed_files ${CPP_GEN_DIR} ${CPP_SDK_DIR}
+
+####################
+# Cleanup and Exit #
+####################
# CleanUp: Delete the base target build directory
rm -rf ${BASE_TARGET_DIR}
http://git-wip-us.apache.org/repos/asf/airavata/blob/77758cb9/modules/gfac/gfac-core/README.txt
----------------------------------------------------------------------
diff --git a/modules/gfac/gfac-core/README.txt b/modules/gfac/gfac-core/README.txt
deleted file mode 100644
index 452bb6b..0000000
--- a/modules/gfac/gfac-core/README.txt
+++ /dev/null
@@ -1 +0,0 @@
-# Readme file for gfac core
[2/6] Generated C++ Client SDK - AIRAVATA-1075
Posted by sm...@apache.org.
http://git-wip-us.apache.org/repos/asf/airavata/blob/77758cb9/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/experimentModel_types.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/experimentModel_types.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/experimentModel_types.cpp
new file mode 100644
index 0000000..9fc4be0
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/experimentModel_types.cpp
@@ -0,0 +1,2867 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+#include "experimentModel_types.h"
+
+#include <algorithm>
+
+
+
+int _kExperimentStateValues[] = {
+ ExperimentState::CREATED,
+ ExperimentState::VALIDATED,
+ ExperimentState::SCHEDULED,
+ ExperimentState::LAUNCHED,
+ ExperimentState::EXECUTING,
+ ExperimentState::CANCELED,
+ ExperimentState::COMPLETED,
+ ExperimentState::FAILED,
+ ExperimentState::UNKNOWN
+};
+const char* _kExperimentStateNames[] = {
+ "CREATED",
+ "VALIDATED",
+ "SCHEDULED",
+ "LAUNCHED",
+ "EXECUTING",
+ "CANCELED",
+ "COMPLETED",
+ "FAILED",
+ "UNKNOWN"
+};
+const std::map<int, const char*> _ExperimentState_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(9, _kExperimentStateValues, _kExperimentStateNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
+
+int _kWorkflowNodeStateValues[] = {
+ WorkflowNodeState::INVOKED,
+ WorkflowNodeState::EXECUTING,
+ WorkflowNodeState::CANCELED,
+ WorkflowNodeState::COMPLETED,
+ WorkflowNodeState::FAILED,
+ WorkflowNodeState::UNKNOWN
+};
+const char* _kWorkflowNodeStateNames[] = {
+ "INVOKED",
+ "EXECUTING",
+ "CANCELED",
+ "COMPLETED",
+ "FAILED",
+ "UNKNOWN"
+};
+const std::map<int, const char*> _WorkflowNodeState_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(6, _kWorkflowNodeStateValues, _kWorkflowNodeStateNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
+
+int _kTaskStateValues[] = {
+ TaskState::WAITING,
+ TaskState::STARTED,
+ TaskState::PRE_PROCESSING,
+ TaskState::CONFIGURING_WORKSPACE,
+ TaskState::INPUT_DATA_STAGING,
+ TaskState::OUTPUT_DATA_STAGING,
+ TaskState::POST_PROCESSING,
+ TaskState::EXECUTING,
+ TaskState::CANCELED,
+ TaskState::COMPLETED,
+ TaskState::FAILED,
+ TaskState::UNKNOWN
+};
+const char* _kTaskStateNames[] = {
+ "WAITING",
+ "STARTED",
+ "PRE_PROCESSING",
+ "CONFIGURING_WORKSPACE",
+ "INPUT_DATA_STAGING",
+ "OUTPUT_DATA_STAGING",
+ "POST_PROCESSING",
+ "EXECUTING",
+ "CANCELED",
+ "COMPLETED",
+ "FAILED",
+ "UNKNOWN"
+};
+const std::map<int, const char*> _TaskState_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(12, _kTaskStateValues, _kTaskStateNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
+
+int _kJobStateValues[] = {
+ JobState::SUBMITTED,
+ JobState::UN_SUBMITTED,
+ JobState::SETUP,
+ JobState::QUEUED,
+ JobState::ACTIVE,
+ JobState::COMPLETE,
+ JobState::CANCELED,
+ JobState::FAILED,
+ JobState::HELD,
+ JobState::SUSPENDED,
+ JobState::UNKNOWN
+};
+const char* _kJobStateNames[] = {
+ "SUBMITTED",
+ "UN_SUBMITTED",
+ "SETUP",
+ "QUEUED",
+ "ACTIVE",
+ "COMPLETE",
+ "CANCELED",
+ "FAILED",
+ "HELD",
+ "SUSPENDED",
+ "UNKNOWN"
+};
+const std::map<int, const char*> _JobState_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(11, _kJobStateValues, _kJobStateNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
+
+int _kTransferStateValues[] = {
+ TransferState::DIRECTORY_SETUP,
+ TransferState::UPLOAD,
+ TransferState::DOWNLOAD,
+ TransferState::ACTIVE,
+ TransferState::COMPLETE,
+ TransferState::STDOUT_DOWNLOAD,
+ TransferState::STDERROR_DOWNLOAD,
+ TransferState::CANCELED,
+ TransferState::FAILED,
+ TransferState::HELD,
+ TransferState::SUSPENDED,
+ TransferState::UNKNOWN
+};
+const char* _kTransferStateNames[] = {
+ "DIRECTORY_SETUP",
+ "UPLOAD",
+ "DOWNLOAD",
+ "ACTIVE",
+ "COMPLETE",
+ "STDOUT_DOWNLOAD",
+ "STDERROR_DOWNLOAD",
+ "CANCELED",
+ "FAILED",
+ "HELD",
+ "SUSPENDED",
+ "UNKNOWN"
+};
+const std::map<int, const char*> _TransferState_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(12, _kTransferStateValues, _kTransferStateNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
+
+int _kActionableGroupValues[] = {
+ ActionableGroup::RESOURCE_ADMINS,
+ ActionableGroup::AIRAVATA_ADMINS,
+ ActionableGroup::GATEWAYS_ADMINS,
+ ActionableGroup::USER,
+ ActionableGroup::CANNOT_BE_DETERMINED
+};
+const char* _kActionableGroupNames[] = {
+ "RESOURCE_ADMINS",
+ "AIRAVATA_ADMINS",
+ "GATEWAYS_ADMINS",
+ "USER",
+ "CANNOT_BE_DETERMINED"
+};
+const std::map<int, const char*> _ActionableGroup_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(5, _kActionableGroupValues, _kActionableGroupNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
+
+int _kErrorCategoryValues[] = {
+ ErrorCategory::FILE_SYSTEM_FAILURE,
+ ErrorCategory::APPLICATION_FAILURE,
+ ErrorCategory::RESOURCE_NODE_FAILURE,
+ ErrorCategory::DISK_FULL,
+ ErrorCategory::INSUFFICIENT_ALLOCATION,
+ ErrorCategory::SYSTEM_MAINTENANCE,
+ ErrorCategory::AIRAVATA_INTERNAL_ERROR,
+ ErrorCategory::CANNOT_BE_DETERMINED
+};
+const char* _kErrorCategoryNames[] = {
+ "FILE_SYSTEM_FAILURE",
+ "APPLICATION_FAILURE",
+ "RESOURCE_NODE_FAILURE",
+ "DISK_FULL",
+ "INSUFFICIENT_ALLOCATION",
+ "SYSTEM_MAINTENANCE",
+ "AIRAVATA_INTERNAL_ERROR",
+ "CANNOT_BE_DETERMINED"
+};
+const std::map<int, const char*> _ErrorCategory_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(8, _kErrorCategoryValues, _kErrorCategoryNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
+
+int _kCorrectiveActionValues[] = {
+ CorrectiveAction::RETRY_SUBMISSION,
+ CorrectiveAction::CONTACT_SUPPORT,
+ CorrectiveAction::CANNOT_BE_DETERMINED
+};
+const char* _kCorrectiveActionNames[] = {
+ "RETRY_SUBMISSION",
+ "CONTACT_SUPPORT",
+ "CANNOT_BE_DETERMINED"
+};
+const std::map<int, const char*> _CorrectiveAction_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(3, _kCorrectiveActionValues, _kCorrectiveActionNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
+
+const char* ExperimentStatus::ascii_fingerprint = "1662AAADFABAB647546029B578B3B69B";
+const uint8_t ExperimentStatus::binary_fingerprint[16] = {0x16,0x62,0xAA,0xAD,0xFA,0xBA,0xB6,0x47,0x54,0x60,0x29,0xB5,0x78,0xB3,0xB6,0x9B};
+
+uint32_t ExperimentStatus::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_experimentState = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ int32_t ecast0;
+ xfer += iprot->readI32(ecast0);
+ this->experimentState = (ExperimentState::type)ecast0;
+ isset_experimentState = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_I64) {
+ xfer += iprot->readI64(this->timeOfStateChange);
+ this->__isset.timeOfStateChange = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_experimentState)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t ExperimentStatus::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ExperimentStatus");
+
+ xfer += oprot->writeFieldBegin("experimentState", ::apache::thrift::protocol::T_I32, 1);
+ xfer += oprot->writeI32((int32_t)this->experimentState);
+ xfer += oprot->writeFieldEnd();
+
+ if (this->__isset.timeOfStateChange) {
+ xfer += oprot->writeFieldBegin("timeOfStateChange", ::apache::thrift::protocol::T_I64, 2);
+ xfer += oprot->writeI64(this->timeOfStateChange);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(ExperimentStatus &a, ExperimentStatus &b) {
+ using ::std::swap;
+ swap(a.experimentState, b.experimentState);
+ swap(a.timeOfStateChange, b.timeOfStateChange);
+ swap(a.__isset, b.__isset);
+}
+
+const char* WorkflowNodeStatus::ascii_fingerprint = "1662AAADFABAB647546029B578B3B69B";
+const uint8_t WorkflowNodeStatus::binary_fingerprint[16] = {0x16,0x62,0xAA,0xAD,0xFA,0xBA,0xB6,0x47,0x54,0x60,0x29,0xB5,0x78,0xB3,0xB6,0x9B};
+
+uint32_t WorkflowNodeStatus::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_workflowNodeState = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ int32_t ecast1;
+ xfer += iprot->readI32(ecast1);
+ this->workflowNodeState = (WorkflowNodeState::type)ecast1;
+ isset_workflowNodeState = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_I64) {
+ xfer += iprot->readI64(this->timeOfStateChange);
+ this->__isset.timeOfStateChange = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_workflowNodeState)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t WorkflowNodeStatus::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("WorkflowNodeStatus");
+
+ xfer += oprot->writeFieldBegin("workflowNodeState", ::apache::thrift::protocol::T_I32, 1);
+ xfer += oprot->writeI32((int32_t)this->workflowNodeState);
+ xfer += oprot->writeFieldEnd();
+
+ if (this->__isset.timeOfStateChange) {
+ xfer += oprot->writeFieldBegin("timeOfStateChange", ::apache::thrift::protocol::T_I64, 2);
+ xfer += oprot->writeI64(this->timeOfStateChange);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(WorkflowNodeStatus &a, WorkflowNodeStatus &b) {
+ using ::std::swap;
+ swap(a.workflowNodeState, b.workflowNodeState);
+ swap(a.timeOfStateChange, b.timeOfStateChange);
+ swap(a.__isset, b.__isset);
+}
+
+const char* TaskStatus::ascii_fingerprint = "1662AAADFABAB647546029B578B3B69B";
+const uint8_t TaskStatus::binary_fingerprint[16] = {0x16,0x62,0xAA,0xAD,0xFA,0xBA,0xB6,0x47,0x54,0x60,0x29,0xB5,0x78,0xB3,0xB6,0x9B};
+
+uint32_t TaskStatus::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_executionState = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ int32_t ecast2;
+ xfer += iprot->readI32(ecast2);
+ this->executionState = (TaskState::type)ecast2;
+ isset_executionState = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_I64) {
+ xfer += iprot->readI64(this->timeOfStateChange);
+ this->__isset.timeOfStateChange = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_executionState)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t TaskStatus::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("TaskStatus");
+
+ xfer += oprot->writeFieldBegin("executionState", ::apache::thrift::protocol::T_I32, 1);
+ xfer += oprot->writeI32((int32_t)this->executionState);
+ xfer += oprot->writeFieldEnd();
+
+ if (this->__isset.timeOfStateChange) {
+ xfer += oprot->writeFieldBegin("timeOfStateChange", ::apache::thrift::protocol::T_I64, 2);
+ xfer += oprot->writeI64(this->timeOfStateChange);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(TaskStatus &a, TaskStatus &b) {
+ using ::std::swap;
+ swap(a.executionState, b.executionState);
+ swap(a.timeOfStateChange, b.timeOfStateChange);
+ swap(a.__isset, b.__isset);
+}
+
+const char* JobStatus::ascii_fingerprint = "1662AAADFABAB647546029B578B3B69B";
+const uint8_t JobStatus::binary_fingerprint[16] = {0x16,0x62,0xAA,0xAD,0xFA,0xBA,0xB6,0x47,0x54,0x60,0x29,0xB5,0x78,0xB3,0xB6,0x9B};
+
+uint32_t JobStatus::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_jobState = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ int32_t ecast3;
+ xfer += iprot->readI32(ecast3);
+ this->jobState = (JobState::type)ecast3;
+ isset_jobState = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_I64) {
+ xfer += iprot->readI64(this->timeOfStateChange);
+ this->__isset.timeOfStateChange = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_jobState)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t JobStatus::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("JobStatus");
+
+ xfer += oprot->writeFieldBegin("jobState", ::apache::thrift::protocol::T_I32, 1);
+ xfer += oprot->writeI32((int32_t)this->jobState);
+ xfer += oprot->writeFieldEnd();
+
+ if (this->__isset.timeOfStateChange) {
+ xfer += oprot->writeFieldBegin("timeOfStateChange", ::apache::thrift::protocol::T_I64, 2);
+ xfer += oprot->writeI64(this->timeOfStateChange);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(JobStatus &a, JobStatus &b) {
+ using ::std::swap;
+ swap(a.jobState, b.jobState);
+ swap(a.timeOfStateChange, b.timeOfStateChange);
+ swap(a.__isset, b.__isset);
+}
+
+const char* TransferStatus::ascii_fingerprint = "1662AAADFABAB647546029B578B3B69B";
+const uint8_t TransferStatus::binary_fingerprint[16] = {0x16,0x62,0xAA,0xAD,0xFA,0xBA,0xB6,0x47,0x54,0x60,0x29,0xB5,0x78,0xB3,0xB6,0x9B};
+
+uint32_t TransferStatus::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_transferState = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ int32_t ecast4;
+ xfer += iprot->readI32(ecast4);
+ this->transferState = (TransferState::type)ecast4;
+ isset_transferState = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_I64) {
+ xfer += iprot->readI64(this->timeOfStateChange);
+ this->__isset.timeOfStateChange = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_transferState)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t TransferStatus::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("TransferStatus");
+
+ xfer += oprot->writeFieldBegin("transferState", ::apache::thrift::protocol::T_I32, 1);
+ xfer += oprot->writeI32((int32_t)this->transferState);
+ xfer += oprot->writeFieldEnd();
+
+ if (this->__isset.timeOfStateChange) {
+ xfer += oprot->writeFieldBegin("timeOfStateChange", ::apache::thrift::protocol::T_I64, 2);
+ xfer += oprot->writeI64(this->timeOfStateChange);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(TransferStatus &a, TransferStatus &b) {
+ using ::std::swap;
+ swap(a.transferState, b.transferState);
+ swap(a.timeOfStateChange, b.timeOfStateChange);
+ swap(a.__isset, b.__isset);
+}
+
+const char* ApplicationStatus::ascii_fingerprint = "E17E126D15049701494262EE3246F603";
+const uint8_t ApplicationStatus::binary_fingerprint[16] = {0xE1,0x7E,0x12,0x6D,0x15,0x04,0x97,0x01,0x49,0x42,0x62,0xEE,0x32,0x46,0xF6,0x03};
+
+uint32_t ApplicationStatus::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_applicationState = 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->applicationState);
+ isset_applicationState = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_I64) {
+ xfer += iprot->readI64(this->timeOfStateChange);
+ this->__isset.timeOfStateChange = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_applicationState)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t ApplicationStatus::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ApplicationStatus");
+
+ xfer += oprot->writeFieldBegin("applicationState", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->applicationState);
+ xfer += oprot->writeFieldEnd();
+
+ if (this->__isset.timeOfStateChange) {
+ xfer += oprot->writeFieldBegin("timeOfStateChange", ::apache::thrift::protocol::T_I64, 2);
+ xfer += oprot->writeI64(this->timeOfStateChange);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(ApplicationStatus &a, ApplicationStatus &b) {
+ using ::std::swap;
+ swap(a.applicationState, b.applicationState);
+ swap(a.timeOfStateChange, b.timeOfStateChange);
+ swap(a.__isset, b.__isset);
+}
+
+const char* DataObjectType::ascii_fingerprint = "6BA700CA2E5FC52A8DA5ADCF811DC8DA";
+const uint8_t DataObjectType::binary_fingerprint[16] = {0x6B,0xA7,0x00,0xCA,0x2E,0x5F,0xC5,0x2A,0x8D,0xA5,0xAD,0xCF,0x81,0x1D,0xC8,0xDA};
+
+uint32_t DataObjectType::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_key = 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->key);
+ isset_key = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->value);
+ this->__isset.value = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->type);
+ this->__isset.type = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->metaData);
+ this->__isset.metaData = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_key)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t DataObjectType::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("DataObjectType");
+
+ xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->key);
+ xfer += oprot->writeFieldEnd();
+
+ if (this->__isset.value) {
+ xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->value);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.type) {
+ xfer += oprot->writeFieldBegin("type", ::apache::thrift::protocol::T_STRING, 3);
+ xfer += oprot->writeString(this->type);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.metaData) {
+ xfer += oprot->writeFieldBegin("metaData", ::apache::thrift::protocol::T_STRING, 4);
+ xfer += oprot->writeString(this->metaData);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(DataObjectType &a, DataObjectType &b) {
+ using ::std::swap;
+ swap(a.key, b.key);
+ swap(a.value, b.value);
+ swap(a.type, b.type);
+ swap(a.metaData, b.metaData);
+ swap(a.__isset, b.__isset);
+}
+
+const char* ComputationalResourceScheduling::ascii_fingerprint = "32AC7AC41AD3753A7224A32FD6EB4B5D";
+const uint8_t ComputationalResourceScheduling::binary_fingerprint[16] = {0x32,0xAC,0x7A,0xC4,0x1A,0xD3,0x75,0x3A,0x72,0x24,0xA3,0x2F,0xD6,0xEB,0x4B,0x5D};
+
+uint32_t ComputationalResourceScheduling::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->resourceHostId);
+ this->__isset.resourceHostId = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ xfer += iprot->readI32(this->totalCPUCount);
+ this->__isset.totalCPUCount = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ xfer += iprot->readI32(this->nodeCount);
+ this->__isset.nodeCount = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ xfer += iprot->readI32(this->numberOfThreads);
+ this->__isset.numberOfThreads = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 5:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->queueName);
+ this->__isset.queueName = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 6:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ xfer += iprot->readI32(this->wallTimeLimit);
+ this->__isset.wallTimeLimit = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 7:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ xfer += iprot->readI32(this->jobStartTime);
+ this->__isset.jobStartTime = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 8:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ xfer += iprot->readI32(this->totalPhysicalMemory);
+ this->__isset.totalPhysicalMemory = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 9:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->ComputationalProjectAccount);
+ this->__isset.ComputationalProjectAccount = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t ComputationalResourceScheduling::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ComputationalResourceScheduling");
+
+ if (this->__isset.resourceHostId) {
+ xfer += oprot->writeFieldBegin("resourceHostId", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->resourceHostId);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.totalCPUCount) {
+ xfer += oprot->writeFieldBegin("totalCPUCount", ::apache::thrift::protocol::T_I32, 2);
+ xfer += oprot->writeI32(this->totalCPUCount);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.nodeCount) {
+ xfer += oprot->writeFieldBegin("nodeCount", ::apache::thrift::protocol::T_I32, 3);
+ xfer += oprot->writeI32(this->nodeCount);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.numberOfThreads) {
+ xfer += oprot->writeFieldBegin("numberOfThreads", ::apache::thrift::protocol::T_I32, 4);
+ xfer += oprot->writeI32(this->numberOfThreads);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.queueName) {
+ xfer += oprot->writeFieldBegin("queueName", ::apache::thrift::protocol::T_STRING, 5);
+ xfer += oprot->writeString(this->queueName);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.wallTimeLimit) {
+ xfer += oprot->writeFieldBegin("wallTimeLimit", ::apache::thrift::protocol::T_I32, 6);
+ xfer += oprot->writeI32(this->wallTimeLimit);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.jobStartTime) {
+ xfer += oprot->writeFieldBegin("jobStartTime", ::apache::thrift::protocol::T_I32, 7);
+ xfer += oprot->writeI32(this->jobStartTime);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.totalPhysicalMemory) {
+ xfer += oprot->writeFieldBegin("totalPhysicalMemory", ::apache::thrift::protocol::T_I32, 8);
+ xfer += oprot->writeI32(this->totalPhysicalMemory);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.ComputationalProjectAccount) {
+ xfer += oprot->writeFieldBegin("ComputationalProjectAccount", ::apache::thrift::protocol::T_STRING, 9);
+ xfer += oprot->writeString(this->ComputationalProjectAccount);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(ComputationalResourceScheduling &a, ComputationalResourceScheduling &b) {
+ using ::std::swap;
+ swap(a.resourceHostId, b.resourceHostId);
+ swap(a.totalCPUCount, b.totalCPUCount);
+ swap(a.nodeCount, b.nodeCount);
+ swap(a.numberOfThreads, b.numberOfThreads);
+ swap(a.queueName, b.queueName);
+ swap(a.wallTimeLimit, b.wallTimeLimit);
+ swap(a.jobStartTime, b.jobStartTime);
+ swap(a.totalPhysicalMemory, b.totalPhysicalMemory);
+ swap(a.ComputationalProjectAccount, b.ComputationalProjectAccount);
+ swap(a.__isset, b.__isset);
+}
+
+const char* AdvancedInputDataHandling::ascii_fingerprint = "6139039875942E8B25C483838DD664B7";
+const uint8_t AdvancedInputDataHandling::binary_fingerprint[16] = {0x61,0x39,0x03,0x98,0x75,0x94,0x2E,0x8B,0x25,0xC4,0x83,0x83,0x8D,0xD6,0x64,0xB7};
+
+uint32_t AdvancedInputDataHandling::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->stageInputFilesToWorkingDir);
+ this->__isset.stageInputFilesToWorkingDir = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->parentWorkingDirectory);
+ this->__isset.parentWorkingDirectory = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->uniqueWorkingDirectory);
+ this->__isset.uniqueWorkingDirectory = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->cleanUpWorkingDirAfterJob);
+ this->__isset.cleanUpWorkingDirAfterJob = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t AdvancedInputDataHandling::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("AdvancedInputDataHandling");
+
+ if (this->__isset.stageInputFilesToWorkingDir) {
+ xfer += oprot->writeFieldBegin("stageInputFilesToWorkingDir", ::apache::thrift::protocol::T_BOOL, 1);
+ xfer += oprot->writeBool(this->stageInputFilesToWorkingDir);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.parentWorkingDirectory) {
+ xfer += oprot->writeFieldBegin("parentWorkingDirectory", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->parentWorkingDirectory);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.uniqueWorkingDirectory) {
+ xfer += oprot->writeFieldBegin("uniqueWorkingDirectory", ::apache::thrift::protocol::T_STRING, 3);
+ xfer += oprot->writeString(this->uniqueWorkingDirectory);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.cleanUpWorkingDirAfterJob) {
+ xfer += oprot->writeFieldBegin("cleanUpWorkingDirAfterJob", ::apache::thrift::protocol::T_BOOL, 4);
+ xfer += oprot->writeBool(this->cleanUpWorkingDirAfterJob);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(AdvancedInputDataHandling &a, AdvancedInputDataHandling &b) {
+ using ::std::swap;
+ swap(a.stageInputFilesToWorkingDir, b.stageInputFilesToWorkingDir);
+ swap(a.parentWorkingDirectory, b.parentWorkingDirectory);
+ swap(a.uniqueWorkingDirectory, b.uniqueWorkingDirectory);
+ swap(a.cleanUpWorkingDirAfterJob, b.cleanUpWorkingDirAfterJob);
+ swap(a.__isset, b.__isset);
+}
+
+const char* AdvancedOutputDataHandling::ascii_fingerprint = "6EC898D3B5ECFF21200795BD22F73CD2";
+const uint8_t AdvancedOutputDataHandling::binary_fingerprint[16] = {0x6E,0xC8,0x98,0xD3,0xB5,0xEC,0xFF,0x21,0x20,0x07,0x95,0xBD,0x22,0xF7,0x3C,0xD2};
+
+uint32_t AdvancedOutputDataHandling::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->outputDataDir);
+ this->__isset.outputDataDir = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->dataRegistryURL);
+ this->__isset.dataRegistryURL = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->persistOutputData);
+ this->__isset.persistOutputData = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t AdvancedOutputDataHandling::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("AdvancedOutputDataHandling");
+
+ if (this->__isset.outputDataDir) {
+ xfer += oprot->writeFieldBegin("outputDataDir", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->outputDataDir);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.dataRegistryURL) {
+ xfer += oprot->writeFieldBegin("dataRegistryURL", ::apache::thrift::protocol::T_STRING, 3);
+ xfer += oprot->writeString(this->dataRegistryURL);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.persistOutputData) {
+ xfer += oprot->writeFieldBegin("persistOutputData", ::apache::thrift::protocol::T_BOOL, 4);
+ xfer += oprot->writeBool(this->persistOutputData);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(AdvancedOutputDataHandling &a, AdvancedOutputDataHandling &b) {
+ using ::std::swap;
+ swap(a.outputDataDir, b.outputDataDir);
+ swap(a.dataRegistryURL, b.dataRegistryURL);
+ swap(a.persistOutputData, b.persistOutputData);
+ swap(a.__isset, b.__isset);
+}
+
+const char* QualityOfServiceParams::ascii_fingerprint = "35985D966603A273E8D7132543B44873";
+const uint8_t QualityOfServiceParams::binary_fingerprint[16] = {0x35,0x98,0x5D,0x96,0x66,0x03,0xA2,0x73,0xE8,0xD7,0x13,0x25,0x43,0xB4,0x48,0x73};
+
+uint32_t QualityOfServiceParams::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->startExecutionAt);
+ this->__isset.startExecutionAt = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->executeBefore);
+ this->__isset.executeBefore = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ xfer += iprot->readI32(this->numberofRetries);
+ this->__isset.numberofRetries = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t QualityOfServiceParams::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("QualityOfServiceParams");
+
+ if (this->__isset.startExecutionAt) {
+ xfer += oprot->writeFieldBegin("startExecutionAt", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->startExecutionAt);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.executeBefore) {
+ xfer += oprot->writeFieldBegin("executeBefore", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->executeBefore);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.numberofRetries) {
+ xfer += oprot->writeFieldBegin("numberofRetries", ::apache::thrift::protocol::T_I32, 3);
+ xfer += oprot->writeI32(this->numberofRetries);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(QualityOfServiceParams &a, QualityOfServiceParams &b) {
+ using ::std::swap;
+ swap(a.startExecutionAt, b.startExecutionAt);
+ swap(a.executeBefore, b.executeBefore);
+ swap(a.numberofRetries, b.numberofRetries);
+ swap(a.__isset, b.__isset);
+}
+
+const char* UserConfigurationData::ascii_fingerprint = "889486266D7ADC041ED1C586A2468611";
+const uint8_t UserConfigurationData::binary_fingerprint[16] = {0x88,0x94,0x86,0x26,0x6D,0x7A,0xDC,0x04,0x1E,0xD1,0xC5,0x86,0xA2,0x46,0x86,0x11};
+
+uint32_t UserConfigurationData::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_airavataAutoSchedule = false;
+ bool isset_overrideManualScheduledParams = 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_BOOL) {
+ xfer += iprot->readBool(this->airavataAutoSchedule);
+ isset_airavataAutoSchedule = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->overrideManualScheduledParams);
+ isset_overrideManualScheduledParams = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->shareExperimentPublicly);
+ this->__isset.shareExperimentPublicly = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->computationalResourceScheduling.read(iprot);
+ this->__isset.computationalResourceScheduling = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 5:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->advanceInputDataHandling.read(iprot);
+ this->__isset.advanceInputDataHandling = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 6:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->advanceOutputDataHandling.read(iprot);
+ this->__isset.advanceOutputDataHandling = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 7:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->qosParams.read(iprot);
+ this->__isset.qosParams = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_airavataAutoSchedule)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_overrideManualScheduledParams)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t UserConfigurationData::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("UserConfigurationData");
+
+ xfer += oprot->writeFieldBegin("airavataAutoSchedule", ::apache::thrift::protocol::T_BOOL, 1);
+ xfer += oprot->writeBool(this->airavataAutoSchedule);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("overrideManualScheduledParams", ::apache::thrift::protocol::T_BOOL, 2);
+ xfer += oprot->writeBool(this->overrideManualScheduledParams);
+ xfer += oprot->writeFieldEnd();
+
+ if (this->__isset.shareExperimentPublicly) {
+ xfer += oprot->writeFieldBegin("shareExperimentPublicly", ::apache::thrift::protocol::T_BOOL, 3);
+ xfer += oprot->writeBool(this->shareExperimentPublicly);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.computationalResourceScheduling) {
+ xfer += oprot->writeFieldBegin("computationalResourceScheduling", ::apache::thrift::protocol::T_STRUCT, 4);
+ xfer += this->computationalResourceScheduling.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.advanceInputDataHandling) {
+ xfer += oprot->writeFieldBegin("advanceInputDataHandling", ::apache::thrift::protocol::T_STRUCT, 5);
+ xfer += this->advanceInputDataHandling.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.advanceOutputDataHandling) {
+ xfer += oprot->writeFieldBegin("advanceOutputDataHandling", ::apache::thrift::protocol::T_STRUCT, 6);
+ xfer += this->advanceOutputDataHandling.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.qosParams) {
+ xfer += oprot->writeFieldBegin("qosParams", ::apache::thrift::protocol::T_STRUCT, 7);
+ xfer += this->qosParams.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(UserConfigurationData &a, UserConfigurationData &b) {
+ using ::std::swap;
+ swap(a.airavataAutoSchedule, b.airavataAutoSchedule);
+ swap(a.overrideManualScheduledParams, b.overrideManualScheduledParams);
+ swap(a.shareExperimentPublicly, b.shareExperimentPublicly);
+ swap(a.computationalResourceScheduling, b.computationalResourceScheduling);
+ swap(a.advanceInputDataHandling, b.advanceInputDataHandling);
+ swap(a.advanceOutputDataHandling, b.advanceOutputDataHandling);
+ swap(a.qosParams, b.qosParams);
+ swap(a.__isset, b.__isset);
+}
+
+const char* ErrorDetails::ascii_fingerprint = "170CA6E79EB283F31417B9D68071DA33";
+const uint8_t ErrorDetails::binary_fingerprint[16] = {0x17,0x0C,0xA6,0xE7,0x9E,0xB2,0x83,0xF3,0x14,0x17,0xB9,0xD6,0x80,0x71,0xDA,0x33};
+
+uint32_t ErrorDetails::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_errorID = 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->errorID);
+ isset_errorID = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_I64) {
+ xfer += iprot->readI64(this->creationTime);
+ this->__isset.creationTime = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->actualErrorMessage);
+ this->__isset.actualErrorMessage = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->userFriendlyMessage);
+ this->__isset.userFriendlyMessage = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 5:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ int32_t ecast5;
+ xfer += iprot->readI32(ecast5);
+ this->errorCategory = (ErrorCategory::type)ecast5;
+ this->__isset.errorCategory = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 6:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->transientOrPersistent);
+ this->__isset.transientOrPersistent = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 7:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ int32_t ecast6;
+ xfer += iprot->readI32(ecast6);
+ this->correctiveAction = (CorrectiveAction::type)ecast6;
+ this->__isset.correctiveAction = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 8:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ int32_t ecast7;
+ xfer += iprot->readI32(ecast7);
+ this->actionableGroup = (ActionableGroup::type)ecast7;
+ this->__isset.actionableGroup = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 9:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->rootCauseErrorIdList.clear();
+ uint32_t _size8;
+ ::apache::thrift::protocol::TType _etype11;
+ xfer += iprot->readListBegin(_etype11, _size8);
+ this->rootCauseErrorIdList.resize(_size8);
+ uint32_t _i12;
+ for (_i12 = 0; _i12 < _size8; ++_i12)
+ {
+ xfer += iprot->readString(this->rootCauseErrorIdList[_i12]);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.rootCauseErrorIdList = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_errorID)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t ErrorDetails::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ErrorDetails");
+
+ xfer += oprot->writeFieldBegin("errorID", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->errorID);
+ xfer += oprot->writeFieldEnd();
+
+ if (this->__isset.creationTime) {
+ xfer += oprot->writeFieldBegin("creationTime", ::apache::thrift::protocol::T_I64, 2);
+ xfer += oprot->writeI64(this->creationTime);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.actualErrorMessage) {
+ xfer += oprot->writeFieldBegin("actualErrorMessage", ::apache::thrift::protocol::T_STRING, 3);
+ xfer += oprot->writeString(this->actualErrorMessage);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.userFriendlyMessage) {
+ xfer += oprot->writeFieldBegin("userFriendlyMessage", ::apache::thrift::protocol::T_STRING, 4);
+ xfer += oprot->writeString(this->userFriendlyMessage);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.errorCategory) {
+ xfer += oprot->writeFieldBegin("errorCategory", ::apache::thrift::protocol::T_I32, 5);
+ xfer += oprot->writeI32((int32_t)this->errorCategory);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.transientOrPersistent) {
+ xfer += oprot->writeFieldBegin("transientOrPersistent", ::apache::thrift::protocol::T_BOOL, 6);
+ xfer += oprot->writeBool(this->transientOrPersistent);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.correctiveAction) {
+ xfer += oprot->writeFieldBegin("correctiveAction", ::apache::thrift::protocol::T_I32, 7);
+ xfer += oprot->writeI32((int32_t)this->correctiveAction);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.actionableGroup) {
+ xfer += oprot->writeFieldBegin("actionableGroup", ::apache::thrift::protocol::T_I32, 8);
+ xfer += oprot->writeI32((int32_t)this->actionableGroup);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.rootCauseErrorIdList) {
+ xfer += oprot->writeFieldBegin("rootCauseErrorIdList", ::apache::thrift::protocol::T_LIST, 9);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->rootCauseErrorIdList.size()));
+ std::vector<std::string> ::const_iterator _iter13;
+ for (_iter13 = this->rootCauseErrorIdList.begin(); _iter13 != this->rootCauseErrorIdList.end(); ++_iter13)
+ {
+ xfer += oprot->writeString((*_iter13));
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(ErrorDetails &a, ErrorDetails &b) {
+ using ::std::swap;
+ swap(a.errorID, b.errorID);
+ swap(a.creationTime, b.creationTime);
+ swap(a.actualErrorMessage, b.actualErrorMessage);
+ swap(a.userFriendlyMessage, b.userFriendlyMessage);
+ swap(a.errorCategory, b.errorCategory);
+ swap(a.transientOrPersistent, b.transientOrPersistent);
+ swap(a.correctiveAction, b.correctiveAction);
+ swap(a.actionableGroup, b.actionableGroup);
+ swap(a.rootCauseErrorIdList, b.rootCauseErrorIdList);
+ swap(a.__isset, b.__isset);
+}
+
+const char* JobDetails::ascii_fingerprint = "5946807521C11BC65075D497F8568057";
+const uint8_t JobDetails::binary_fingerprint[16] = {0x59,0x46,0x80,0x75,0x21,0xC1,0x1B,0xC6,0x50,0x75,0xD4,0x97,0xF8,0x56,0x80,0x57};
+
+uint32_t JobDetails::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_jobID = false;
+ bool isset_jobDescription = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->jobID);
+ isset_jobID = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->jobDescription);
+ isset_jobDescription = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_I64) {
+ xfer += iprot->readI64(this->creationTime);
+ this->__isset.creationTime = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->jobStatus.read(iprot);
+ this->__isset.jobStatus = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 5:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->applicationStatus.read(iprot);
+ this->__isset.applicationStatus = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 6:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->errors.clear();
+ uint32_t _size14;
+ ::apache::thrift::protocol::TType _etype17;
+ xfer += iprot->readListBegin(_etype17, _size14);
+ this->errors.resize(_size14);
+ uint32_t _i18;
+ for (_i18 = 0; _i18 < _size14; ++_i18)
+ {
+ xfer += this->errors[_i18].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.errors = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 7:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->computeResourceConsumed);
+ this->__isset.computeResourceConsumed = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_jobID)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_jobDescription)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t JobDetails::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("JobDetails");
+
+ xfer += oprot->writeFieldBegin("jobID", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->jobID);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("jobDescription", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->jobDescription);
+ xfer += oprot->writeFieldEnd();
+
+ if (this->__isset.creationTime) {
+ xfer += oprot->writeFieldBegin("creationTime", ::apache::thrift::protocol::T_I64, 3);
+ xfer += oprot->writeI64(this->creationTime);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.jobStatus) {
+ xfer += oprot->writeFieldBegin("jobStatus", ::apache::thrift::protocol::T_STRUCT, 4);
+ xfer += this->jobStatus.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.applicationStatus) {
+ xfer += oprot->writeFieldBegin("applicationStatus", ::apache::thrift::protocol::T_STRUCT, 5);
+ xfer += this->applicationStatus.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.errors) {
+ xfer += oprot->writeFieldBegin("errors", ::apache::thrift::protocol::T_LIST, 6);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->errors.size()));
+ std::vector<ErrorDetails> ::const_iterator _iter19;
+ for (_iter19 = this->errors.begin(); _iter19 != this->errors.end(); ++_iter19)
+ {
+ xfer += (*_iter19).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.computeResourceConsumed) {
+ xfer += oprot->writeFieldBegin("computeResourceConsumed", ::apache::thrift::protocol::T_STRING, 7);
+ xfer += oprot->writeString(this->computeResourceConsumed);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(JobDetails &a, JobDetails &b) {
+ using ::std::swap;
+ swap(a.jobID, b.jobID);
+ swap(a.jobDescription, b.jobDescription);
+ swap(a.creationTime, b.creationTime);
+ swap(a.jobStatus, b.jobStatus);
+ swap(a.applicationStatus, b.applicationStatus);
+ swap(a.errors, b.errors);
+ swap(a.computeResourceConsumed, b.computeResourceConsumed);
+ swap(a.__isset, b.__isset);
+}
+
+const char* DataTransferDetails::ascii_fingerprint = "40D4FEC20E3B334AEEBA92DA2AB9E91E";
+const uint8_t DataTransferDetails::binary_fingerprint[16] = {0x40,0xD4,0xFE,0xC2,0x0E,0x3B,0x33,0x4A,0xEE,0xBA,0x92,0xDA,0x2A,0xB9,0xE9,0x1E};
+
+uint32_t DataTransferDetails::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_transferID = false;
+ bool isset_transferDescription = 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->transferID);
+ isset_transferID = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_I64) {
+ xfer += iprot->readI64(this->creationTime);
+ this->__isset.creationTime = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->transferDescription);
+ isset_transferDescription = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->transferStatus.read(iprot);
+ this->__isset.transferStatus = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_transferID)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_transferDescription)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t DataTransferDetails::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("DataTransferDetails");
+
+ xfer += oprot->writeFieldBegin("transferID", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->transferID);
+ xfer += oprot->writeFieldEnd();
+
+ if (this->__isset.creationTime) {
+ xfer += oprot->writeFieldBegin("creationTime", ::apache::thrift::protocol::T_I64, 2);
+ xfer += oprot->writeI64(this->creationTime);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldBegin("transferDescription", ::apache::thrift::protocol::T_STRING, 3);
+ xfer += oprot->writeString(this->transferDescription);
+ xfer += oprot->writeFieldEnd();
+
+ if (this->__isset.transferStatus) {
+ xfer += oprot->writeFieldBegin("transferStatus", ::apache::thrift::protocol::T_STRUCT, 4);
+ xfer += this->transferStatus.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(DataTransferDetails &a, DataTransferDetails &b) {
+ using ::std::swap;
+ swap(a.transferID, b.transferID);
+ swap(a.creationTime, b.creationTime);
+ swap(a.transferDescription, b.transferDescription);
+ swap(a.transferStatus, b.transferStatus);
+ swap(a.__isset, b.__isset);
+}
+
+const char* TaskDetails::ascii_fingerprint = "705A0D2F86DF8E37DD3741EEF4EB51A0";
+const uint8_t TaskDetails::binary_fingerprint[16] = {0x70,0x5A,0x0D,0x2F,0x86,0xDF,0x8E,0x37,0xDD,0x37,0x41,0xEE,0xF4,0xEB,0x51,0xA0};
+
+uint32_t TaskDetails::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_taskID = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->taskID);
+ isset_taskID = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_I64) {
+ xfer += iprot->readI64(this->creationTime);
+ this->__isset.creationTime = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->applicationId);
+ this->__isset.applicationId = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->applicationVersion);
+ this->__isset.applicationVersion = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 5:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->applicationInputs.clear();
+ uint32_t _size20;
+ ::apache::thrift::protocol::TType _etype23;
+ xfer += iprot->readListBegin(_etype23, _size20);
+ this->applicationInputs.resize(_size20);
+ uint32_t _i24;
+ for (_i24 = 0; _i24 < _size20; ++_i24)
+ {
+ xfer += this->applicationInputs[_i24].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.applicationInputs = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 6:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->applicationOutputs.clear();
+ uint32_t _size25;
+ ::apache::thrift::protocol::TType _etype28;
+ xfer += iprot->readListBegin(_etype28, _size25);
+ this->applicationOutputs.resize(_size25);
+ uint32_t _i29;
+ for (_i29 = 0; _i29 < _size25; ++_i29)
+ {
+ xfer += this->applicationOutputs[_i29].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.applicationOutputs = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 7:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->taskScheduling.read(iprot);
+ this->__isset.taskScheduling = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 8:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->advancedInputDataHandling.read(iprot);
+ this->__isset.advancedInputDataHandling = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 9:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->advancedOutputDataHandling.read(iprot);
+ this->__isset.advancedOutputDataHandling = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 10:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->taskStatus.read(iprot);
+ this->__isset.taskStatus = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 11:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->jobDetailsList.clear();
+ uint32_t _size30;
+ ::apache::thrift::protocol::TType _etype33;
+ xfer += iprot->readListBegin(_etype33, _size30);
+ this->jobDetailsList.resize(_size30);
+ uint32_t _i34;
+ for (_i34 = 0; _i34 < _size30; ++_i34)
+ {
+ xfer += this->jobDetailsList[_i34].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.jobDetailsList = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 12:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->dataTransferDetailsList.clear();
+ uint32_t _size35;
+ ::apache::thrift::protocol::TType _etype38;
+ xfer += iprot->readListBegin(_etype38, _size35);
+ this->dataTransferDetailsList.resize(_size35);
+ uint32_t _i39;
+ for (_i39 = 0; _i39 < _size35; ++_i39)
+ {
+ xfer += this->dataTransferDetailsList[_i39].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.dataTransferDetailsList = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 13:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->errors.clear();
+ uint32_t _size40;
+ ::apache::thrift::protocol::TType _etype43;
+ xfer += iprot->readListBegin(_etype43, _size40);
+ this->errors.resize(_size40);
+ uint32_t _i44;
+ for (_i44 = 0; _i44 < _size40; ++_i44)
+ {
+ xfer += this->errors[_i44].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.errors = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_taskID)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t TaskDetails::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("TaskDetails");
+
+ xfer += oprot->writeFieldBegin("taskID", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->taskID);
+ xfer += oprot->writeFieldEnd();
+
+ if (this->__isset.creationTime) {
+ xfer += oprot->writeFieldBegin("creationTime", ::apache::thrift::protocol::T_I64, 2);
+ xfer += oprot->writeI64(this->creationTime);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.applicationId) {
+ xfer += oprot->writeFieldBegin("applicationId", ::apache::thrift::protocol::T_STRING, 3);
+ xfer += oprot->writeString(this->applicationId);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.applicationVersion) {
+ xfer += oprot->writeFieldBegin("applicationVersion", ::apache::thrift::protocol::T_STRING, 4);
+ xfer += oprot->writeString(this->applicationVersion);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.applicationInputs) {
+ xfer += oprot->writeFieldBegin("applicationInputs", ::apache::thrift::protocol::T_LIST, 5);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->applicationInputs.size()));
+ std::vector<DataObjectType> ::const_iterator _iter45;
+ for (_iter45 = this->applicationInputs.begin(); _iter45 != this->applicationInputs.end(); ++_iter45)
+ {
+ xfer += (*_iter45).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.applicationOutputs) {
+ xfer += oprot->writeFieldBegin("applicationOutputs", ::apache::thrift::protocol::T_LIST, 6);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->applicationOutputs.size()));
+ std::vector<DataObjectType> ::const_iterator _iter46;
+ for (_iter46 = this->applicationOutputs.begin(); _iter46 != this->applicationOutputs.end(); ++_iter46)
+ {
+ xfer += (*_iter46).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.taskScheduling) {
+ xfer += oprot->writeFieldBegin("taskScheduling", ::apache::thrift::protocol::T_STRUCT, 7);
+ xfer += this->taskScheduling.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.advancedInputDataHandling) {
+ xfer += oprot->writeFieldBegin("advancedInputDataHandling", ::apache::thrift::protocol::T_STRUCT, 8);
+ xfer += this->advancedInputDataHandling.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.advancedOutputDataHandling) {
+ xfer += oprot->writeFieldBegin("advancedOutputDataHandling", ::apache::thrift::protocol::T_STRUCT, 9);
+ xfer += this->advancedOutputDataHandling.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.taskStatus) {
+ xfer += oprot->writeFieldBegin("taskStatus", ::apache::thrift::protocol::T_STRUCT, 10);
+ xfer += this->taskStatus.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.jobDetailsList) {
+ xfer += oprot->writeFieldBegin("jobDetailsList", ::apache::thrift::protocol::T_LIST, 11);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->jobDetailsList.size()));
+ std::vector<JobDetails> ::const_iterator _iter47;
+ for (_iter47 = this->jobDetailsList.begin(); _iter47 != this->jobDetailsList.end(); ++_iter47)
+ {
+ xfer += (*_iter47).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.dataTransferDetailsList) {
+ xfer += oprot->writeFieldBegin("dataTransferDetailsList", ::apache::thrift::protocol::T_LIST, 12);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->dataTransferDetailsList.size()));
+ std::vector<DataTransferDetails> ::const_iterator _iter48;
+ for (_iter48 = this->dataTransferDetailsList.begin(); _iter48 != this->dataTransferDetailsList.end(); ++_iter48)
+ {
+ xfer += (*_iter48).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.errors) {
+ xfer += oprot->writeFieldBegin("errors", ::apache::thrift::protocol::T_LIST, 13);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->errors.size()));
+ std::vector<ErrorDetails> ::const_iterator _iter49;
+ for (_iter49 = this->errors.begin(); _iter49 != this->errors.end(); ++_iter49)
+ {
+ xfer += (*_iter49).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(TaskDetails &a, TaskDetails &b) {
+ using ::std::swap;
+ swap(a.taskID, b.taskID);
+ swap(a.creationTime, b.creationTime);
+ swap(a.applicationId, b.applicationId);
+ swap(a.applicationVersion, b.applicationVersion);
+ swap(a.applicationInputs, b.applicationInputs);
+ swap(a.applicationOutputs, b.applicationOutputs);
+ swap(a.taskScheduling, b.taskScheduling);
+ swap(a.advancedInputDataHandling, b.advancedInputDataHandling);
+ swap(a.advancedOutputDataHandling, b.advancedOutputDataHandling);
+ swap(a.taskStatus, b.taskStatus);
+ swap(a.jobDetailsList, b.jobDetailsList);
+ swap(a.dataTransferDetailsList, b.dataTransferDetailsList);
+ swap(a.errors, b.errors);
+ swap(a.__isset, b.__isset);
+}
+
+const char* WorkflowNodeDetails::ascii_fingerprint = "D244C94A6A1DF1DFBA2E34E7756C28EF";
+const uint8_t WorkflowNodeDetails::binary_fingerprint[16] = {0xD2,0x44,0xC9,0x4A,0x6A,0x1D,0xF1,0xDF,0xBA,0x2E,0x34,0xE7,0x75,0x6C,0x28,0xEF};
+
+uint32_t WorkflowNodeDetails::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_nodeInstanceId = false;
+ bool isset_nodeName = 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->nodeInstanceId);
+ isset_nodeInstanceId = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_I64) {
+ xfer += iprot->readI64(this->creationTime);
+ this->__isset.creationTime = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->nodeName);
+ isset_nodeName = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->nodeInputs.clear();
+ uint32_t _size50;
+ ::apache::thrift::protocol::TType _etype53;
+ xfer += iprot->readListBegin(_etype53, _size50);
+ this->nodeInputs.resize(_size50);
+ uint32_t _i54;
+ for (_i54 = 0; _i54 < _size50; ++_i54)
+ {
+ xfer += this->nodeInputs[_i54].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.nodeInputs = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 5:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->nodeOutputs.clear();
+ uint32_t _size55;
+ ::apache::thrift::protocol::TType _etype58;
+ xfer += iprot->readListBegin(_etype58, _size55);
+ this->nodeOutputs.resize(_size55);
+ uint32_t _i59;
+ for (_i59 = 0; _i59 < _size55; ++_i59)
+ {
+ xfer += this->nodeOutputs[_i59].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.nodeOutputs = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 6:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->workflowNodeStatus.read(iprot);
+ this->__isset.workflowNodeStatus = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 7:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->taskDetailsList.clear();
+ uint32_t _size60;
+ ::apache::thrift::protocol::TType _etype63;
+ xfer += iprot->readListBegin(_etype63, _size60);
+ this->taskDetailsList.resize(_size60);
+ uint32_t _i64;
+ for (_i64 = 0; _i64 < _size60; ++_i64)
+ {
+ xfer += this->taskDetailsList[_i64].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.taskDetailsList = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 8:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->errors.clear();
+ uint32_t _size65;
+ ::apache::thrift::protocol::TType _etype68;
+ xfer += iprot->readListBegin(_etype68, _size65);
+ this->errors.resize(_size65);
+ uint32_t _i69;
+ for (_i69 = 0; _i69 < _size65; ++_i69)
+ {
+ xfer += this->errors[_i69].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.errors = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_nodeInstanceId)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_nodeName)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t WorkflowNodeDetails::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("WorkflowNodeDetails");
+
+ xfer += oprot->writeFieldBegin("nodeInstanceId", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->nodeInstanceId);
+ xfer += oprot->writeFieldEnd();
+
+ if (this->__isset.creationTime) {
+ xfer += oprot->writeFieldBegin("creationTime", ::apache::thrift::protocol::T_I64, 2);
+ xfer += oprot->writeI64(this->creationTime);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldBegin("nodeName", ::apache::thrift::protocol::T_STRING, 3);
+ xfer += oprot->writeString(this->nodeName);
+ xfer += oprot->writeFieldEnd();
+
+ if (this->__isset.nodeInputs) {
+ xfer += oprot->writeFieldBegin("nodeInputs", ::apache::thrift::protocol::T_LIST, 4);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->nodeInputs.size()));
+ std::vector<DataObjectType> ::const_iterator _iter70;
+ for (_iter70 = this->nodeInputs.begin(); _iter70 != this->nodeInputs.end(); ++_iter70)
+ {
+ xfer += (*_iter70).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.nodeOutputs) {
+ xfer += oprot->writeFieldBegin("nodeOutputs", ::apache::thrift::protocol::T_LIST, 5);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->nodeOutputs.size()));
+ std::vector<DataObjectType> ::const_iterator _iter71;
+ for (_iter71 = this->nodeOutputs.begin(); _iter71 != this->nodeOutputs.end(); ++_iter71)
+ {
+ xfer += (*_iter71).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.workflowNodeStatus) {
+ xfer += oprot->writeFieldBegin("workflowNodeStatus", ::apache::thrift::protocol::T_STRUCT, 6);
+ xfer += this->workflowNodeStatus.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.taskDetailsList) {
+ xfer += oprot->writeFieldBegin("taskDetailsList", ::apache::thrift::protocol::T_LIST, 7);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->taskDetailsList.size()));
+ std::vector<TaskDetails> ::const_iterator _iter72;
+ for (_iter72 = this->taskDetailsList.begin(); _iter72 != this->taskDetailsList.end(); ++_iter72)
+ {
+ xfer += (*_iter72).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.errors) {
+ xfer += oprot->writeFieldBegin("errors", ::apache::thrift::protocol::T_LIST, 8);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->errors.size()));
+ std::vector<ErrorDetails> ::const_iterator _iter73;
+ for (_iter73 = this->errors.begin(); _iter73 != this->errors.end(); ++_iter73)
+ {
+ xfer += (*_iter73).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(WorkflowNodeDetails &a, WorkflowNodeDetails &b) {
+ using ::std::swap;
+ swap(a.nodeInstanceId, b.nodeInstanceId);
+ swap(a.creationTime, b.creationTime);
+ swap(a.nodeName, b.nodeName);
+ swap(a.nodeInputs, b.nodeInputs);
+ swap(a.nodeOutputs, b.nodeOutputs);
+ swap(a.workflowNodeStatus, b.workflowNodeStatus);
+ swap(a.taskDetailsList, b.taskDetailsList);
+ swap(a.errors, b.errors);
+ swap(a.__isset, b.__isset);
+}
+
+const char* Experiment::ascii_fingerprint = "AAEAE252F6A2D0BD15514CB57DB7745F";
+const uint8_t Experiment::binary_fingerprint[16] = {0xAA,0xEA,0xE2,0x52,0xF6,0xA2,0xD0,0xBD,0x15,0x51,0x4C,0xB5,0x7D,0xB7,0x74,0x5F};
+
+uint32_t Experiment::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_experimentID = false;
+ bool isset_projectID = false;
+ bool isset_userName = 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->experimentID);
+ isset_experimentID = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->projectID);
+ isset_projectID = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_I64) {
+ xfer += iprot->readI64(this->creationTime);
+ this->__isset.creationTime = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->userName);
+ isset_userName = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 5:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->name);
+ isset_name = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 6:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->description);
+ this->__isset.description = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 7:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->applicationId);
+ this->__isset.applicationId = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 8:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->applicationVersion);
+ this->__isset.applicationVersion = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 9:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->workflowTemplateId);
+ this->__isset.workflowTemplateId = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 10:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->workflowTemplateVersion);
+ this->__isset.workflowTemplateVersion = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 11:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->userConfigurationData.read(iprot);
+ this->__isset.userConfigurationData = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 12:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->workflowExecutionInstanceId);
+ this->__isset.workflowExecutionInstanceId = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 13:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->experimentInputs.clear();
+ uint32_t _size74;
+ ::apache::thrift::protocol::TType _etype77;
+ xfer += iprot->readListBegin(_etype77, _size74);
+ this->experimentInputs.resize(_size74);
+ uint32_t _i78;
+ for (_i78 = 0; _i78 < _size74; ++_i78)
+ {
+ xfer += this->experimentInputs[_i78].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.experimentInputs = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 14:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->experimentOutputs.clear();
+ uint32_t _size79;
+ ::apache::thrift::protocol::TType _etype82;
+ xfer += iprot->readListBegin(_etype82, _size79);
+ this->experimentOutputs.resize(_size79);
+ uint32_t _i83;
+ for (_i83 = 0; _i83 < _size79; ++_i83)
+ {
+ xfer += this->experimentOutputs[_i83].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.experimentOutputs = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 15:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->experimentStatus.read(iprot);
+ this->__isset.experimentStatus = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 16:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->stateChangeList.clear();
+ uint32_t _size84;
+ ::apache::thrift::protocol::TType _etype87;
+ xfer += i
<TRUNCATED>
[4/6] Generated C++ Client SDK - AIRAVATA-1075
Posted by sm...@apache.org.
http://git-wip-us.apache.org/repos/asf/airavata/blob/77758cb9/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/Airavata.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/Airavata.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/Airavata.h
new file mode 100644
index 0000000..683c900
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/Airavata.h
@@ -0,0 +1,2714 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+#ifndef Airavata_H
+#define Airavata_H
+
+#include <thrift/TDispatchProcessor.h>
+#include "airavataAPI_types.h"
+
+namespace airavata { namespace api {
+
+class AiravataIf {
+ public:
+ virtual ~AiravataIf() {}
+ virtual void GetAPIVersion(std::string& _return) = 0;
+ virtual void createProject(std::string& _return, const ::Project& project, const std::string& userName) = 0;
+ virtual void updateProject(const ::Project& project) = 0;
+ virtual void getProject( ::Project& _return, const std::string& projectId) = 0;
+ virtual void getAllUserProjects(std::vector< ::Project> & _return, const std::string& userName) = 0;
+ virtual void getAllExperimentsInProject(std::vector< ::Experiment> & _return, const std::string& projectId) = 0;
+ virtual void getAllUserExperiments(std::vector< ::Experiment> & _return, const std::string& userName) = 0;
+ virtual void createExperiment(std::string& _return, const ::Experiment& experiment) = 0;
+ virtual void getExperiment( ::Experiment& _return, const std::string& airavataExperimentId) = 0;
+ virtual void updateExperiment(const std::string& airavataExperimentId, const ::Experiment& experiment) = 0;
+ virtual void updateExperimentConfiguration(const std::string& airavataExperimentId, const ::UserConfigurationData& userConfiguration) = 0;
+ virtual void updateResourceScheduleing(const std::string& airavataExperimentId, const ::ComputationalResourceScheduling& resourceScheduling) = 0;
+ virtual void launchExperiment(const std::string& airavataExperimentId, const std::string& airavataCredStoreToken) = 0;
+ virtual void getExperimentStatus( ::ExperimentStatus& _return, const std::string& airavataExperimentId) = 0;
+ virtual void getExperimentOutputs(std::vector< ::DataObjectType> & _return, const std::string& airavataExperimentId) = 0;
+ virtual void getJobStatuses(std::map<std::string, ::JobStatus> & _return, const std::string& airavataExperimentId) = 0;
+ virtual void cloneExperiment(std::string& _return, const std::string& airavataExperimentIdToBeCloned, const ::Experiment& updatedExperiment) = 0;
+ virtual void terminateExperiment(const std::string& airavataExperimentId) = 0;
+};
+
+class AiravataIfFactory {
+ public:
+ typedef AiravataIf Handler;
+
+ virtual ~AiravataIfFactory() {}
+
+ virtual AiravataIf* getHandler(const ::apache::thrift::TConnectionInfo& connInfo) = 0;
+ virtual void releaseHandler(AiravataIf* /* handler */) = 0;
+};
+
+class AiravataIfSingletonFactory : virtual public AiravataIfFactory {
+ public:
+ AiravataIfSingletonFactory(const boost::shared_ptr<AiravataIf>& iface) : iface_(iface) {}
+ virtual ~AiravataIfSingletonFactory() {}
+
+ virtual AiravataIf* getHandler(const ::apache::thrift::TConnectionInfo&) {
+ return iface_.get();
+ }
+ virtual void releaseHandler(AiravataIf* /* handler */) {}
+
+ protected:
+ boost::shared_ptr<AiravataIf> iface_;
+};
+
+class AiravataNull : virtual public AiravataIf {
+ public:
+ virtual ~AiravataNull() {}
+ void GetAPIVersion(std::string& /* _return */) {
+ return;
+ }
+ void createProject(std::string& /* _return */, const ::Project& /* project */, const std::string& /* userName */) {
+ return;
+ }
+ void updateProject(const ::Project& /* project */) {
+ return;
+ }
+ void getProject( ::Project& /* _return */, const std::string& /* projectId */) {
+ return;
+ }
+ void getAllUserProjects(std::vector< ::Project> & /* _return */, const std::string& /* userName */) {
+ return;
+ }
+ void getAllExperimentsInProject(std::vector< ::Experiment> & /* _return */, const std::string& /* projectId */) {
+ return;
+ }
+ void getAllUserExperiments(std::vector< ::Experiment> & /* _return */, const std::string& /* userName */) {
+ return;
+ }
+ void createExperiment(std::string& /* _return */, const ::Experiment& /* experiment */) {
+ return;
+ }
+ void getExperiment( ::Experiment& /* _return */, const std::string& /* airavataExperimentId */) {
+ return;
+ }
+ void updateExperiment(const std::string& /* airavataExperimentId */, const ::Experiment& /* experiment */) {
+ return;
+ }
+ void updateExperimentConfiguration(const std::string& /* airavataExperimentId */, const ::UserConfigurationData& /* userConfiguration */) {
+ return;
+ }
+ void updateResourceScheduleing(const std::string& /* airavataExperimentId */, const ::ComputationalResourceScheduling& /* resourceScheduling */) {
+ return;
+ }
+ void launchExperiment(const std::string& /* airavataExperimentId */, const std::string& /* airavataCredStoreToken */) {
+ return;
+ }
+ void getExperimentStatus( ::ExperimentStatus& /* _return */, const std::string& /* airavataExperimentId */) {
+ return;
+ }
+ void getExperimentOutputs(std::vector< ::DataObjectType> & /* _return */, const std::string& /* airavataExperimentId */) {
+ return;
+ }
+ void getJobStatuses(std::map<std::string, ::JobStatus> & /* _return */, const std::string& /* airavataExperimentId */) {
+ return;
+ }
+ void cloneExperiment(std::string& /* _return */, const std::string& /* airavataExperimentIdToBeCloned */, const ::Experiment& /* updatedExperiment */) {
+ return;
+ }
+ void terminateExperiment(const std::string& /* airavataExperimentId */) {
+ return;
+ }
+};
+
+
+class Airavata_GetAPIVersion_args {
+ public:
+
+ Airavata_GetAPIVersion_args() {
+ }
+
+ virtual ~Airavata_GetAPIVersion_args() throw() {}
+
+
+ bool operator == (const Airavata_GetAPIVersion_args & /* rhs */) const
+ {
+ return true;
+ }
+ bool operator != (const Airavata_GetAPIVersion_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Airavata_GetAPIVersion_args & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Airavata_GetAPIVersion_pargs {
+ public:
+
+
+ virtual ~Airavata_GetAPIVersion_pargs() throw() {}
+
+
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_GetAPIVersion_result__isset {
+ _Airavata_GetAPIVersion_result__isset() : success(false) {}
+ bool success;
+} _Airavata_GetAPIVersion_result__isset;
+
+class Airavata_GetAPIVersion_result {
+ public:
+
+ Airavata_GetAPIVersion_result() : success() {
+ }
+
+ virtual ~Airavata_GetAPIVersion_result() throw() {}
+
+ std::string success;
+
+ _Airavata_GetAPIVersion_result__isset __isset;
+
+ void __set_success(const std::string& val) {
+ success = val;
+ }
+
+ bool operator == (const Airavata_GetAPIVersion_result & rhs) const
+ {
+ if (!(success == rhs.success))
+ return false;
+ return true;
+ }
+ bool operator != (const Airavata_GetAPIVersion_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Airavata_GetAPIVersion_result & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_GetAPIVersion_presult__isset {
+ _Airavata_GetAPIVersion_presult__isset() : success(false) {}
+ bool success;
+} _Airavata_GetAPIVersion_presult__isset;
+
+class Airavata_GetAPIVersion_presult {
+ public:
+
+
+ virtual ~Airavata_GetAPIVersion_presult() throw() {}
+
+ std::string* success;
+
+ _Airavata_GetAPIVersion_presult__isset __isset;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Airavata_createProject_args {
+ public:
+
+ Airavata_createProject_args() : userName() {
+ }
+
+ virtual ~Airavata_createProject_args() throw() {}
+
+ ::Project project;
+ std::string userName;
+
+ void __set_project(const ::Project& val) {
+ project = val;
+ }
+
+ void __set_userName(const std::string& val) {
+ userName = val;
+ }
+
+ bool operator == (const Airavata_createProject_args & rhs) const
+ {
+ if (!(project == rhs.project))
+ return false;
+ if (!(userName == rhs.userName))
+ return false;
+ return true;
+ }
+ bool operator != (const Airavata_createProject_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Airavata_createProject_args & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Airavata_createProject_pargs {
+ public:
+
+
+ virtual ~Airavata_createProject_pargs() throw() {}
+
+ const ::Project* project;
+ const std::string* userName;
+
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_createProject_result__isset {
+ _Airavata_createProject_result__isset() : success(false), ire(false), ace(false), ase(false) {}
+ bool success;
+ bool ire;
+ bool ace;
+ bool ase;
+} _Airavata_createProject_result__isset;
+
+class Airavata_createProject_result {
+ public:
+
+ Airavata_createProject_result() : success() {
+ }
+
+ virtual ~Airavata_createProject_result() throw() {}
+
+ std::string success;
+ ::airavata::api::error::InvalidRequestException ire;
+ ::airavata::api::error::AiravataClientException ace;
+ ::airavata::api::error::AiravataSystemException ase;
+
+ _Airavata_createProject_result__isset __isset;
+
+ void __set_success(const std::string& val) {
+ success = val;
+ }
+
+ void __set_ire(const ::airavata::api::error::InvalidRequestException& val) {
+ ire = val;
+ }
+
+ void __set_ace(const ::airavata::api::error::AiravataClientException& val) {
+ ace = val;
+ }
+
+ void __set_ase(const ::airavata::api::error::AiravataSystemException& val) {
+ ase = val;
+ }
+
+ bool operator == (const Airavata_createProject_result & rhs) const
+ {
+ if (!(success == rhs.success))
+ return false;
+ if (!(ire == rhs.ire))
+ return false;
+ if (!(ace == rhs.ace))
+ return false;
+ if (!(ase == rhs.ase))
+ return false;
+ return true;
+ }
+ bool operator != (const Airavata_createProject_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Airavata_createProject_result & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_createProject_presult__isset {
+ _Airavata_createProject_presult__isset() : success(false), ire(false), ace(false), ase(false) {}
+ bool success;
+ bool ire;
+ bool ace;
+ bool ase;
+} _Airavata_createProject_presult__isset;
+
+class Airavata_createProject_presult {
+ public:
+
+
+ virtual ~Airavata_createProject_presult() throw() {}
+
+ std::string* success;
+ ::airavata::api::error::InvalidRequestException ire;
+ ::airavata::api::error::AiravataClientException ace;
+ ::airavata::api::error::AiravataSystemException ase;
+
+ _Airavata_createProject_presult__isset __isset;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Airavata_updateProject_args {
+ public:
+
+ Airavata_updateProject_args() {
+ }
+
+ virtual ~Airavata_updateProject_args() throw() {}
+
+ ::Project project;
+
+ void __set_project(const ::Project& val) {
+ project = val;
+ }
+
+ bool operator == (const Airavata_updateProject_args & rhs) const
+ {
+ if (!(project == rhs.project))
+ return false;
+ return true;
+ }
+ bool operator != (const Airavata_updateProject_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Airavata_updateProject_args & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Airavata_updateProject_pargs {
+ public:
+
+
+ virtual ~Airavata_updateProject_pargs() throw() {}
+
+ const ::Project* project;
+
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_updateProject_result__isset {
+ _Airavata_updateProject_result__isset() : ire(false), ace(false), ase(false) {}
+ bool ire;
+ bool ace;
+ bool ase;
+} _Airavata_updateProject_result__isset;
+
+class Airavata_updateProject_result {
+ public:
+
+ Airavata_updateProject_result() {
+ }
+
+ virtual ~Airavata_updateProject_result() throw() {}
+
+ ::airavata::api::error::InvalidRequestException ire;
+ ::airavata::api::error::AiravataClientException ace;
+ ::airavata::api::error::AiravataSystemException ase;
+
+ _Airavata_updateProject_result__isset __isset;
+
+ void __set_ire(const ::airavata::api::error::InvalidRequestException& val) {
+ ire = val;
+ }
+
+ void __set_ace(const ::airavata::api::error::AiravataClientException& val) {
+ ace = val;
+ }
+
+ void __set_ase(const ::airavata::api::error::AiravataSystemException& val) {
+ ase = val;
+ }
+
+ bool operator == (const Airavata_updateProject_result & rhs) const
+ {
+ if (!(ire == rhs.ire))
+ return false;
+ if (!(ace == rhs.ace))
+ return false;
+ if (!(ase == rhs.ase))
+ return false;
+ return true;
+ }
+ bool operator != (const Airavata_updateProject_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Airavata_updateProject_result & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_updateProject_presult__isset {
+ _Airavata_updateProject_presult__isset() : ire(false), ace(false), ase(false) {}
+ bool ire;
+ bool ace;
+ bool ase;
+} _Airavata_updateProject_presult__isset;
+
+class Airavata_updateProject_presult {
+ public:
+
+
+ virtual ~Airavata_updateProject_presult() throw() {}
+
+ ::airavata::api::error::InvalidRequestException ire;
+ ::airavata::api::error::AiravataClientException ace;
+ ::airavata::api::error::AiravataSystemException ase;
+
+ _Airavata_updateProject_presult__isset __isset;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Airavata_getProject_args {
+ public:
+
+ Airavata_getProject_args() : projectId() {
+ }
+
+ virtual ~Airavata_getProject_args() throw() {}
+
+ std::string projectId;
+
+ void __set_projectId(const std::string& val) {
+ projectId = val;
+ }
+
+ bool operator == (const Airavata_getProject_args & rhs) const
+ {
+ if (!(projectId == rhs.projectId))
+ return false;
+ return true;
+ }
+ bool operator != (const Airavata_getProject_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Airavata_getProject_args & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Airavata_getProject_pargs {
+ public:
+
+
+ virtual ~Airavata_getProject_pargs() throw() {}
+
+ const std::string* projectId;
+
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_getProject_result__isset {
+ _Airavata_getProject_result__isset() : success(false), ire(false), ace(false), ase(false) {}
+ bool success;
+ bool ire;
+ bool ace;
+ bool ase;
+} _Airavata_getProject_result__isset;
+
+class Airavata_getProject_result {
+ public:
+
+ Airavata_getProject_result() {
+ }
+
+ virtual ~Airavata_getProject_result() throw() {}
+
+ ::Project success;
+ ::airavata::api::error::InvalidRequestException ire;
+ ::airavata::api::error::AiravataClientException ace;
+ ::airavata::api::error::AiravataSystemException ase;
+
+ _Airavata_getProject_result__isset __isset;
+
+ void __set_success(const ::Project& val) {
+ success = val;
+ }
+
+ void __set_ire(const ::airavata::api::error::InvalidRequestException& val) {
+ ire = val;
+ }
+
+ void __set_ace(const ::airavata::api::error::AiravataClientException& val) {
+ ace = val;
+ }
+
+ void __set_ase(const ::airavata::api::error::AiravataSystemException& val) {
+ ase = val;
+ }
+
+ bool operator == (const Airavata_getProject_result & rhs) const
+ {
+ if (!(success == rhs.success))
+ return false;
+ if (!(ire == rhs.ire))
+ return false;
+ if (!(ace == rhs.ace))
+ return false;
+ if (!(ase == rhs.ase))
+ return false;
+ return true;
+ }
+ bool operator != (const Airavata_getProject_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Airavata_getProject_result & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_getProject_presult__isset {
+ _Airavata_getProject_presult__isset() : success(false), ire(false), ace(false), ase(false) {}
+ bool success;
+ bool ire;
+ bool ace;
+ bool ase;
+} _Airavata_getProject_presult__isset;
+
+class Airavata_getProject_presult {
+ public:
+
+
+ virtual ~Airavata_getProject_presult() throw() {}
+
+ ::Project* success;
+ ::airavata::api::error::InvalidRequestException ire;
+ ::airavata::api::error::AiravataClientException ace;
+ ::airavata::api::error::AiravataSystemException ase;
+
+ _Airavata_getProject_presult__isset __isset;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Airavata_getAllUserProjects_args {
+ public:
+
+ Airavata_getAllUserProjects_args() : userName() {
+ }
+
+ virtual ~Airavata_getAllUserProjects_args() throw() {}
+
+ std::string userName;
+
+ void __set_userName(const std::string& val) {
+ userName = val;
+ }
+
+ bool operator == (const Airavata_getAllUserProjects_args & rhs) const
+ {
+ if (!(userName == rhs.userName))
+ return false;
+ return true;
+ }
+ bool operator != (const Airavata_getAllUserProjects_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Airavata_getAllUserProjects_args & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Airavata_getAllUserProjects_pargs {
+ public:
+
+
+ virtual ~Airavata_getAllUserProjects_pargs() throw() {}
+
+ const std::string* userName;
+
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_getAllUserProjects_result__isset {
+ _Airavata_getAllUserProjects_result__isset() : success(false), ire(false), ace(false), ase(false) {}
+ bool success;
+ bool ire;
+ bool ace;
+ bool ase;
+} _Airavata_getAllUserProjects_result__isset;
+
+class Airavata_getAllUserProjects_result {
+ public:
+
+ Airavata_getAllUserProjects_result() {
+ }
+
+ virtual ~Airavata_getAllUserProjects_result() throw() {}
+
+ std::vector< ::Project> success;
+ ::airavata::api::error::InvalidRequestException ire;
+ ::airavata::api::error::AiravataClientException ace;
+ ::airavata::api::error::AiravataSystemException ase;
+
+ _Airavata_getAllUserProjects_result__isset __isset;
+
+ void __set_success(const std::vector< ::Project> & val) {
+ success = val;
+ }
+
+ void __set_ire(const ::airavata::api::error::InvalidRequestException& val) {
+ ire = val;
+ }
+
+ void __set_ace(const ::airavata::api::error::AiravataClientException& val) {
+ ace = val;
+ }
+
+ void __set_ase(const ::airavata::api::error::AiravataSystemException& val) {
+ ase = val;
+ }
+
+ bool operator == (const Airavata_getAllUserProjects_result & rhs) const
+ {
+ if (!(success == rhs.success))
+ return false;
+ if (!(ire == rhs.ire))
+ return false;
+ if (!(ace == rhs.ace))
+ return false;
+ if (!(ase == rhs.ase))
+ return false;
+ return true;
+ }
+ bool operator != (const Airavata_getAllUserProjects_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Airavata_getAllUserProjects_result & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_getAllUserProjects_presult__isset {
+ _Airavata_getAllUserProjects_presult__isset() : success(false), ire(false), ace(false), ase(false) {}
+ bool success;
+ bool ire;
+ bool ace;
+ bool ase;
+} _Airavata_getAllUserProjects_presult__isset;
+
+class Airavata_getAllUserProjects_presult {
+ public:
+
+
+ virtual ~Airavata_getAllUserProjects_presult() throw() {}
+
+ std::vector< ::Project> * success;
+ ::airavata::api::error::InvalidRequestException ire;
+ ::airavata::api::error::AiravataClientException ace;
+ ::airavata::api::error::AiravataSystemException ase;
+
+ _Airavata_getAllUserProjects_presult__isset __isset;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Airavata_getAllExperimentsInProject_args {
+ public:
+
+ Airavata_getAllExperimentsInProject_args() : projectId() {
+ }
+
+ virtual ~Airavata_getAllExperimentsInProject_args() throw() {}
+
+ std::string projectId;
+
+ void __set_projectId(const std::string& val) {
+ projectId = val;
+ }
+
+ bool operator == (const Airavata_getAllExperimentsInProject_args & rhs) const
+ {
+ if (!(projectId == rhs.projectId))
+ return false;
+ return true;
+ }
+ bool operator != (const Airavata_getAllExperimentsInProject_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Airavata_getAllExperimentsInProject_args & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Airavata_getAllExperimentsInProject_pargs {
+ public:
+
+
+ virtual ~Airavata_getAllExperimentsInProject_pargs() throw() {}
+
+ const std::string* projectId;
+
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_getAllExperimentsInProject_result__isset {
+ _Airavata_getAllExperimentsInProject_result__isset() : success(false), ire(false), ace(false), ase(false) {}
+ bool success;
+ bool ire;
+ bool ace;
+ bool ase;
+} _Airavata_getAllExperimentsInProject_result__isset;
+
+class Airavata_getAllExperimentsInProject_result {
+ public:
+
+ Airavata_getAllExperimentsInProject_result() {
+ }
+
+ virtual ~Airavata_getAllExperimentsInProject_result() throw() {}
+
+ std::vector< ::Experiment> success;
+ ::airavata::api::error::InvalidRequestException ire;
+ ::airavata::api::error::AiravataClientException ace;
+ ::airavata::api::error::AiravataSystemException ase;
+
+ _Airavata_getAllExperimentsInProject_result__isset __isset;
+
+ void __set_success(const std::vector< ::Experiment> & val) {
+ success = val;
+ }
+
+ void __set_ire(const ::airavata::api::error::InvalidRequestException& val) {
+ ire = val;
+ }
+
+ void __set_ace(const ::airavata::api::error::AiravataClientException& val) {
+ ace = val;
+ }
+
+ void __set_ase(const ::airavata::api::error::AiravataSystemException& val) {
+ ase = val;
+ }
+
+ bool operator == (const Airavata_getAllExperimentsInProject_result & rhs) const
+ {
+ if (!(success == rhs.success))
+ return false;
+ if (!(ire == rhs.ire))
+ return false;
+ if (!(ace == rhs.ace))
+ return false;
+ if (!(ase == rhs.ase))
+ return false;
+ return true;
+ }
+ bool operator != (const Airavata_getAllExperimentsInProject_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Airavata_getAllExperimentsInProject_result & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_getAllExperimentsInProject_presult__isset {
+ _Airavata_getAllExperimentsInProject_presult__isset() : success(false), ire(false), ace(false), ase(false) {}
+ bool success;
+ bool ire;
+ bool ace;
+ bool ase;
+} _Airavata_getAllExperimentsInProject_presult__isset;
+
+class Airavata_getAllExperimentsInProject_presult {
+ public:
+
+
+ virtual ~Airavata_getAllExperimentsInProject_presult() throw() {}
+
+ std::vector< ::Experiment> * success;
+ ::airavata::api::error::InvalidRequestException ire;
+ ::airavata::api::error::AiravataClientException ace;
+ ::airavata::api::error::AiravataSystemException ase;
+
+ _Airavata_getAllExperimentsInProject_presult__isset __isset;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Airavata_getAllUserExperiments_args {
+ public:
+
+ Airavata_getAllUserExperiments_args() : userName() {
+ }
+
+ virtual ~Airavata_getAllUserExperiments_args() throw() {}
+
+ std::string userName;
+
+ void __set_userName(const std::string& val) {
+ userName = val;
+ }
+
+ bool operator == (const Airavata_getAllUserExperiments_args & rhs) const
+ {
+ if (!(userName == rhs.userName))
+ return false;
+ return true;
+ }
+ bool operator != (const Airavata_getAllUserExperiments_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Airavata_getAllUserExperiments_args & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Airavata_getAllUserExperiments_pargs {
+ public:
+
+
+ virtual ~Airavata_getAllUserExperiments_pargs() throw() {}
+
+ const std::string* userName;
+
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_getAllUserExperiments_result__isset {
+ _Airavata_getAllUserExperiments_result__isset() : success(false), ire(false), ace(false), ase(false) {}
+ bool success;
+ bool ire;
+ bool ace;
+ bool ase;
+} _Airavata_getAllUserExperiments_result__isset;
+
+class Airavata_getAllUserExperiments_result {
+ public:
+
+ Airavata_getAllUserExperiments_result() {
+ }
+
+ virtual ~Airavata_getAllUserExperiments_result() throw() {}
+
+ std::vector< ::Experiment> success;
+ ::airavata::api::error::InvalidRequestException ire;
+ ::airavata::api::error::AiravataClientException ace;
+ ::airavata::api::error::AiravataSystemException ase;
+
+ _Airavata_getAllUserExperiments_result__isset __isset;
+
+ void __set_success(const std::vector< ::Experiment> & val) {
+ success = val;
+ }
+
+ void __set_ire(const ::airavata::api::error::InvalidRequestException& val) {
+ ire = val;
+ }
+
+ void __set_ace(const ::airavata::api::error::AiravataClientException& val) {
+ ace = val;
+ }
+
+ void __set_ase(const ::airavata::api::error::AiravataSystemException& val) {
+ ase = val;
+ }
+
+ bool operator == (const Airavata_getAllUserExperiments_result & rhs) const
+ {
+ if (!(success == rhs.success))
+ return false;
+ if (!(ire == rhs.ire))
+ return false;
+ if (!(ace == rhs.ace))
+ return false;
+ if (!(ase == rhs.ase))
+ return false;
+ return true;
+ }
+ bool operator != (const Airavata_getAllUserExperiments_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Airavata_getAllUserExperiments_result & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_getAllUserExperiments_presult__isset {
+ _Airavata_getAllUserExperiments_presult__isset() : success(false), ire(false), ace(false), ase(false) {}
+ bool success;
+ bool ire;
+ bool ace;
+ bool ase;
+} _Airavata_getAllUserExperiments_presult__isset;
+
+class Airavata_getAllUserExperiments_presult {
+ public:
+
+
+ virtual ~Airavata_getAllUserExperiments_presult() throw() {}
+
+ std::vector< ::Experiment> * success;
+ ::airavata::api::error::InvalidRequestException ire;
+ ::airavata::api::error::AiravataClientException ace;
+ ::airavata::api::error::AiravataSystemException ase;
+
+ _Airavata_getAllUserExperiments_presult__isset __isset;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Airavata_createExperiment_args {
+ public:
+
+ Airavata_createExperiment_args() {
+ }
+
+ virtual ~Airavata_createExperiment_args() throw() {}
+
+ ::Experiment experiment;
+
+ void __set_experiment(const ::Experiment& val) {
+ experiment = val;
+ }
+
+ bool operator == (const Airavata_createExperiment_args & rhs) const
+ {
+ if (!(experiment == rhs.experiment))
+ return false;
+ return true;
+ }
+ bool operator != (const Airavata_createExperiment_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Airavata_createExperiment_args & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Airavata_createExperiment_pargs {
+ public:
+
+
+ virtual ~Airavata_createExperiment_pargs() throw() {}
+
+ const ::Experiment* experiment;
+
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_createExperiment_result__isset {
+ _Airavata_createExperiment_result__isset() : success(false), ire(false), ace(false), ase(false) {}
+ bool success;
+ bool ire;
+ bool ace;
+ bool ase;
+} _Airavata_createExperiment_result__isset;
+
+class Airavata_createExperiment_result {
+ public:
+
+ Airavata_createExperiment_result() : success() {
+ }
+
+ virtual ~Airavata_createExperiment_result() throw() {}
+
+ std::string success;
+ ::airavata::api::error::InvalidRequestException ire;
+ ::airavata::api::error::AiravataClientException ace;
+ ::airavata::api::error::AiravataSystemException ase;
+
+ _Airavata_createExperiment_result__isset __isset;
+
+ void __set_success(const std::string& val) {
+ success = val;
+ }
+
+ void __set_ire(const ::airavata::api::error::InvalidRequestException& val) {
+ ire = val;
+ }
+
+ void __set_ace(const ::airavata::api::error::AiravataClientException& val) {
+ ace = val;
+ }
+
+ void __set_ase(const ::airavata::api::error::AiravataSystemException& val) {
+ ase = val;
+ }
+
+ bool operator == (const Airavata_createExperiment_result & rhs) const
+ {
+ if (!(success == rhs.success))
+ return false;
+ if (!(ire == rhs.ire))
+ return false;
+ if (!(ace == rhs.ace))
+ return false;
+ if (!(ase == rhs.ase))
+ return false;
+ return true;
+ }
+ bool operator != (const Airavata_createExperiment_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Airavata_createExperiment_result & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_createExperiment_presult__isset {
+ _Airavata_createExperiment_presult__isset() : success(false), ire(false), ace(false), ase(false) {}
+ bool success;
+ bool ire;
+ bool ace;
+ bool ase;
+} _Airavata_createExperiment_presult__isset;
+
+class Airavata_createExperiment_presult {
+ public:
+
+
+ virtual ~Airavata_createExperiment_presult() throw() {}
+
+ std::string* success;
+ ::airavata::api::error::InvalidRequestException ire;
+ ::airavata::api::error::AiravataClientException ace;
+ ::airavata::api::error::AiravataSystemException ase;
+
+ _Airavata_createExperiment_presult__isset __isset;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Airavata_getExperiment_args {
+ public:
+
+ Airavata_getExperiment_args() : airavataExperimentId() {
+ }
+
+ virtual ~Airavata_getExperiment_args() throw() {}
+
+ std::string airavataExperimentId;
+
+ void __set_airavataExperimentId(const std::string& val) {
+ airavataExperimentId = val;
+ }
+
+ bool operator == (const Airavata_getExperiment_args & rhs) const
+ {
+ if (!(airavataExperimentId == rhs.airavataExperimentId))
+ return false;
+ return true;
+ }
+ bool operator != (const Airavata_getExperiment_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Airavata_getExperiment_args & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Airavata_getExperiment_pargs {
+ public:
+
+
+ virtual ~Airavata_getExperiment_pargs() throw() {}
+
+ const std::string* airavataExperimentId;
+
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_getExperiment_result__isset {
+ _Airavata_getExperiment_result__isset() : success(false), ire(false), enf(false), ace(false), ase(false) {}
+ bool success;
+ bool ire;
+ bool enf;
+ bool ace;
+ bool ase;
+} _Airavata_getExperiment_result__isset;
+
+class Airavata_getExperiment_result {
+ public:
+
+ Airavata_getExperiment_result() {
+ }
+
+ virtual ~Airavata_getExperiment_result() throw() {}
+
+ ::Experiment success;
+ ::airavata::api::error::InvalidRequestException ire;
+ ::airavata::api::error::ExperimentNotFoundException enf;
+ ::airavata::api::error::AiravataClientException ace;
+ ::airavata::api::error::AiravataSystemException ase;
+
+ _Airavata_getExperiment_result__isset __isset;
+
+ void __set_success(const ::Experiment& val) {
+ success = val;
+ }
+
+ void __set_ire(const ::airavata::api::error::InvalidRequestException& val) {
+ ire = val;
+ }
+
+ void __set_enf(const ::airavata::api::error::ExperimentNotFoundException& val) {
+ enf = val;
+ }
+
+ void __set_ace(const ::airavata::api::error::AiravataClientException& val) {
+ ace = val;
+ }
+
+ void __set_ase(const ::airavata::api::error::AiravataSystemException& val) {
+ ase = val;
+ }
+
+ bool operator == (const Airavata_getExperiment_result & rhs) const
+ {
+ if (!(success == rhs.success))
+ return false;
+ if (!(ire == rhs.ire))
+ return false;
+ if (!(enf == rhs.enf))
+ return false;
+ if (!(ace == rhs.ace))
+ return false;
+ if (!(ase == rhs.ase))
+ return false;
+ return true;
+ }
+ bool operator != (const Airavata_getExperiment_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Airavata_getExperiment_result & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_getExperiment_presult__isset {
+ _Airavata_getExperiment_presult__isset() : success(false), ire(false), enf(false), ace(false), ase(false) {}
+ bool success;
+ bool ire;
+ bool enf;
+ bool ace;
+ bool ase;
+} _Airavata_getExperiment_presult__isset;
+
+class Airavata_getExperiment_presult {
+ public:
+
+
+ virtual ~Airavata_getExperiment_presult() throw() {}
+
+ ::Experiment* success;
+ ::airavata::api::error::InvalidRequestException ire;
+ ::airavata::api::error::ExperimentNotFoundException enf;
+ ::airavata::api::error::AiravataClientException ace;
+ ::airavata::api::error::AiravataSystemException ase;
+
+ _Airavata_getExperiment_presult__isset __isset;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Airavata_updateExperiment_args {
+ public:
+
+ Airavata_updateExperiment_args() : airavataExperimentId() {
+ }
+
+ virtual ~Airavata_updateExperiment_args() throw() {}
+
+ std::string airavataExperimentId;
+ ::Experiment experiment;
+
+ void __set_airavataExperimentId(const std::string& val) {
+ airavataExperimentId = val;
+ }
+
+ void __set_experiment(const ::Experiment& val) {
+ experiment = val;
+ }
+
+ bool operator == (const Airavata_updateExperiment_args & rhs) const
+ {
+ if (!(airavataExperimentId == rhs.airavataExperimentId))
+ return false;
+ if (!(experiment == rhs.experiment))
+ return false;
+ return true;
+ }
+ bool operator != (const Airavata_updateExperiment_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Airavata_updateExperiment_args & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Airavata_updateExperiment_pargs {
+ public:
+
+
+ virtual ~Airavata_updateExperiment_pargs() throw() {}
+
+ const std::string* airavataExperimentId;
+ const ::Experiment* experiment;
+
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_updateExperiment_result__isset {
+ _Airavata_updateExperiment_result__isset() : ire(false), enf(false), ace(false), ase(false) {}
+ bool ire;
+ bool enf;
+ bool ace;
+ bool ase;
+} _Airavata_updateExperiment_result__isset;
+
+class Airavata_updateExperiment_result {
+ public:
+
+ Airavata_updateExperiment_result() {
+ }
+
+ virtual ~Airavata_updateExperiment_result() throw() {}
+
+ ::airavata::api::error::InvalidRequestException ire;
+ ::airavata::api::error::ExperimentNotFoundException enf;
+ ::airavata::api::error::AiravataClientException ace;
+ ::airavata::api::error::AiravataSystemException ase;
+
+ _Airavata_updateExperiment_result__isset __isset;
+
+ void __set_ire(const ::airavata::api::error::InvalidRequestException& val) {
+ ire = val;
+ }
+
+ void __set_enf(const ::airavata::api::error::ExperimentNotFoundException& val) {
+ enf = val;
+ }
+
+ void __set_ace(const ::airavata::api::error::AiravataClientException& val) {
+ ace = val;
+ }
+
+ void __set_ase(const ::airavata::api::error::AiravataSystemException& val) {
+ ase = val;
+ }
+
+ bool operator == (const Airavata_updateExperiment_result & rhs) const
+ {
+ if (!(ire == rhs.ire))
+ return false;
+ if (!(enf == rhs.enf))
+ return false;
+ if (!(ace == rhs.ace))
+ return false;
+ if (!(ase == rhs.ase))
+ return false;
+ return true;
+ }
+ bool operator != (const Airavata_updateExperiment_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Airavata_updateExperiment_result & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_updateExperiment_presult__isset {
+ _Airavata_updateExperiment_presult__isset() : ire(false), enf(false), ace(false), ase(false) {}
+ bool ire;
+ bool enf;
+ bool ace;
+ bool ase;
+} _Airavata_updateExperiment_presult__isset;
+
+class Airavata_updateExperiment_presult {
+ public:
+
+
+ virtual ~Airavata_updateExperiment_presult() throw() {}
+
+ ::airavata::api::error::InvalidRequestException ire;
+ ::airavata::api::error::ExperimentNotFoundException enf;
+ ::airavata::api::error::AiravataClientException ace;
+ ::airavata::api::error::AiravataSystemException ase;
+
+ _Airavata_updateExperiment_presult__isset __isset;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Airavata_updateExperimentConfiguration_args {
+ public:
+
+ Airavata_updateExperimentConfiguration_args() : airavataExperimentId() {
+ }
+
+ virtual ~Airavata_updateExperimentConfiguration_args() throw() {}
+
+ std::string airavataExperimentId;
+ ::UserConfigurationData userConfiguration;
+
+ void __set_airavataExperimentId(const std::string& val) {
+ airavataExperimentId = val;
+ }
+
+ void __set_userConfiguration(const ::UserConfigurationData& val) {
+ userConfiguration = val;
+ }
+
+ bool operator == (const Airavata_updateExperimentConfiguration_args & rhs) const
+ {
+ if (!(airavataExperimentId == rhs.airavataExperimentId))
+ return false;
+ if (!(userConfiguration == rhs.userConfiguration))
+ return false;
+ return true;
+ }
+ bool operator != (const Airavata_updateExperimentConfiguration_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Airavata_updateExperimentConfiguration_args & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Airavata_updateExperimentConfiguration_pargs {
+ public:
+
+
+ virtual ~Airavata_updateExperimentConfiguration_pargs() throw() {}
+
+ const std::string* airavataExperimentId;
+ const ::UserConfigurationData* userConfiguration;
+
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Airavata_updateExperimentConfiguration_result {
+ public:
+
+ Airavata_updateExperimentConfiguration_result() {
+ }
+
+ virtual ~Airavata_updateExperimentConfiguration_result() throw() {}
+
+
+ bool operator == (const Airavata_updateExperimentConfiguration_result & /* rhs */) const
+ {
+ return true;
+ }
+ bool operator != (const Airavata_updateExperimentConfiguration_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Airavata_updateExperimentConfiguration_result & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Airavata_updateExperimentConfiguration_presult {
+ public:
+
+
+ virtual ~Airavata_updateExperimentConfiguration_presult() throw() {}
+
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Airavata_updateResourceScheduleing_args {
+ public:
+
+ Airavata_updateResourceScheduleing_args() : airavataExperimentId() {
+ }
+
+ virtual ~Airavata_updateResourceScheduleing_args() throw() {}
+
+ std::string airavataExperimentId;
+ ::ComputationalResourceScheduling resourceScheduling;
+
+ void __set_airavataExperimentId(const std::string& val) {
+ airavataExperimentId = val;
+ }
+
+ void __set_resourceScheduling(const ::ComputationalResourceScheduling& val) {
+ resourceScheduling = val;
+ }
+
+ bool operator == (const Airavata_updateResourceScheduleing_args & rhs) const
+ {
+ if (!(airavataExperimentId == rhs.airavataExperimentId))
+ return false;
+ if (!(resourceScheduling == rhs.resourceScheduling))
+ return false;
+ return true;
+ }
+ bool operator != (const Airavata_updateResourceScheduleing_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Airavata_updateResourceScheduleing_args & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Airavata_updateResourceScheduleing_pargs {
+ public:
+
+
+ virtual ~Airavata_updateResourceScheduleing_pargs() throw() {}
+
+ const std::string* airavataExperimentId;
+ const ::ComputationalResourceScheduling* resourceScheduling;
+
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Airavata_updateResourceScheduleing_result {
+ public:
+
+ Airavata_updateResourceScheduleing_result() {
+ }
+
+ virtual ~Airavata_updateResourceScheduleing_result() throw() {}
+
+
+ bool operator == (const Airavata_updateResourceScheduleing_result & /* rhs */) const
+ {
+ return true;
+ }
+ bool operator != (const Airavata_updateResourceScheduleing_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Airavata_updateResourceScheduleing_result & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Airavata_updateResourceScheduleing_presult {
+ public:
+
+
+ virtual ~Airavata_updateResourceScheduleing_presult() throw() {}
+
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Airavata_launchExperiment_args {
+ public:
+
+ Airavata_launchExperiment_args() : airavataExperimentId(), airavataCredStoreToken() {
+ }
+
+ virtual ~Airavata_launchExperiment_args() throw() {}
+
+ std::string airavataExperimentId;
+ std::string airavataCredStoreToken;
+
+ void __set_airavataExperimentId(const std::string& val) {
+ airavataExperimentId = val;
+ }
+
+ void __set_airavataCredStoreToken(const std::string& val) {
+ airavataCredStoreToken = val;
+ }
+
+ bool operator == (const Airavata_launchExperiment_args & rhs) const
+ {
+ if (!(airavataExperimentId == rhs.airavataExperimentId))
+ return false;
+ if (!(airavataCredStoreToken == rhs.airavataCredStoreToken))
+ return false;
+ return true;
+ }
+ bool operator != (const Airavata_launchExperiment_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Airavata_launchExperiment_args & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Airavata_launchExperiment_pargs {
+ public:
+
+
+ virtual ~Airavata_launchExperiment_pargs() throw() {}
+
+ const std::string* airavataExperimentId;
+ const std::string* airavataCredStoreToken;
+
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_launchExperiment_result__isset {
+ _Airavata_launchExperiment_result__isset() : ire(false), enf(false), ace(false), ase(false) {}
+ bool ire;
+ bool enf;
+ bool ace;
+ bool ase;
+} _Airavata_launchExperiment_result__isset;
+
+class Airavata_launchExperiment_result {
+ public:
+
+ Airavata_launchExperiment_result() {
+ }
+
+ virtual ~Airavata_launchExperiment_result() throw() {}
+
+ ::airavata::api::error::InvalidRequestException ire;
+ ::airavata::api::error::ExperimentNotFoundException enf;
+ ::airavata::api::error::AiravataClientException ace;
+ ::airavata::api::error::AiravataSystemException ase;
+
+ _Airavata_launchExperiment_result__isset __isset;
+
+ void __set_ire(const ::airavata::api::error::InvalidRequestException& val) {
+ ire = val;
+ }
+
+ void __set_enf(const ::airavata::api::error::ExperimentNotFoundException& val) {
+ enf = val;
+ }
+
+ void __set_ace(const ::airavata::api::error::AiravataClientException& val) {
+ ace = val;
+ }
+
+ void __set_ase(const ::airavata::api::error::AiravataSystemException& val) {
+ ase = val;
+ }
+
+ bool operator == (const Airavata_launchExperiment_result & rhs) const
+ {
+ if (!(ire == rhs.ire))
+ return false;
+ if (!(enf == rhs.enf))
+ return false;
+ if (!(ace == rhs.ace))
+ return false;
+ if (!(ase == rhs.ase))
+ return false;
+ return true;
+ }
+ bool operator != (const Airavata_launchExperiment_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Airavata_launchExperiment_result & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_launchExperiment_presult__isset {
+ _Airavata_launchExperiment_presult__isset() : ire(false), enf(false), ace(false), ase(false) {}
+ bool ire;
+ bool enf;
+ bool ace;
+ bool ase;
+} _Airavata_launchExperiment_presult__isset;
+
+class Airavata_launchExperiment_presult {
+ public:
+
+
+ virtual ~Airavata_launchExperiment_presult() throw() {}
+
+ ::airavata::api::error::InvalidRequestException ire;
+ ::airavata::api::error::ExperimentNotFoundException enf;
+ ::airavata::api::error::AiravataClientException ace;
+ ::airavata::api::error::AiravataSystemException ase;
+
+ _Airavata_launchExperiment_presult__isset __isset;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Airavata_getExperimentStatus_args {
+ public:
+
+ Airavata_getExperimentStatus_args() : airavataExperimentId() {
+ }
+
+ virtual ~Airavata_getExperimentStatus_args() throw() {}
+
+ std::string airavataExperimentId;
+
+ void __set_airavataExperimentId(const std::string& val) {
+ airavataExperimentId = val;
+ }
+
+ bool operator == (const Airavata_getExperimentStatus_args & rhs) const
+ {
+ if (!(airavataExperimentId == rhs.airavataExperimentId))
+ return false;
+ return true;
+ }
+ bool operator != (const Airavata_getExperimentStatus_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Airavata_getExperimentStatus_args & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Airavata_getExperimentStatus_pargs {
+ public:
+
+
+ virtual ~Airavata_getExperimentStatus_pargs() throw() {}
+
+ const std::string* airavataExperimentId;
+
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_getExperimentStatus_result__isset {
+ _Airavata_getExperimentStatus_result__isset() : success(false), ire(false), enf(false), ace(false), ase(false) {}
+ bool success;
+ bool ire;
+ bool enf;
+ bool ace;
+ bool ase;
+} _Airavata_getExperimentStatus_result__isset;
+
+class Airavata_getExperimentStatus_result {
+ public:
+
+ Airavata_getExperimentStatus_result() {
+ }
+
+ virtual ~Airavata_getExperimentStatus_result() throw() {}
+
+ ::ExperimentStatus success;
+ ::airavata::api::error::InvalidRequestException ire;
+ ::airavata::api::error::ExperimentNotFoundException enf;
+ ::airavata::api::error::AiravataClientException ace;
+ ::airavata::api::error::AiravataSystemException ase;
+
+ _Airavata_getExperimentStatus_result__isset __isset;
+
+ void __set_success(const ::ExperimentStatus& val) {
+ success = val;
+ }
+
+ void __set_ire(const ::airavata::api::error::InvalidRequestException& val) {
+ ire = val;
+ }
+
+ void __set_enf(const ::airavata::api::error::ExperimentNotFoundException& val) {
+ enf = val;
+ }
+
+ void __set_ace(const ::airavata::api::error::AiravataClientException& val) {
+ ace = val;
+ }
+
+ void __set_ase(const ::airavata::api::error::AiravataSystemException& val) {
+ ase = val;
+ }
+
+ bool operator == (const Airavata_getExperimentStatus_result & rhs) const
+ {
+ if (!(success == rhs.success))
+ return false;
+ if (!(ire == rhs.ire))
+ return false;
+ if (!(enf == rhs.enf))
+ return false;
+ if (!(ace == rhs.ace))
+ return false;
+ if (!(ase == rhs.ase))
+ return false;
+ return true;
+ }
+ bool operator != (const Airavata_getExperimentStatus_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Airavata_getExperimentStatus_result & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_getExperimentStatus_presult__isset {
+ _Airavata_getExperimentStatus_presult__isset() : success(false), ire(false), enf(false), ace(false), ase(false) {}
+ bool success;
+ bool ire;
+ bool enf;
+ bool ace;
+ bool ase;
+} _Airavata_getExperimentStatus_presult__isset;
+
+class Airavata_getExperimentStatus_presult {
+ public:
+
+
+ virtual ~Airavata_getExperimentStatus_presult() throw() {}
+
+ ::ExperimentStatus* success;
+ ::airavata::api::error::InvalidRequestException ire;
+ ::airavata::api::error::ExperimentNotFoundException enf;
+ ::airavata::api::error::AiravataClientException ace;
+ ::airavata::api::error::AiravataSystemException ase;
+
+ _Airavata_getExperimentStatus_presult__isset __isset;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Airavata_getExperimentOutputs_args {
+ public:
+
+ Airavata_getExperimentOutputs_args() : airavataExperimentId() {
+ }
+
+ virtual ~Airavata_getExperimentOutputs_args() throw() {}
+
+ std::string airavataExperimentId;
+
+ void __set_airavataExperimentId(const std::string& val) {
+ airavataExperimentId = val;
+ }
+
+ bool operator == (const Airavata_getExperimentOutputs_args & rhs) const
+ {
+ if (!(airavataExperimentId == rhs.airavataExperimentId))
+ return false;
+ return true;
+ }
+ bool operator != (const Airavata_getExperimentOutputs_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Airavata_getExperimentOutputs_args & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Airavata_getExperimentOutputs_pargs {
+ public:
+
+
+ virtual ~Airavata_getExperimentOutputs_pargs() throw() {}
+
+ const std::string* airavataExperimentId;
+
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_getExperimentOutputs_result__isset {
+ _Airavata_getExperimentOutputs_result__isset() : success(false) {}
+ bool success;
+} _Airavata_getExperimentOutputs_result__isset;
+
+class Airavata_getExperimentOutputs_result {
+ public:
+
+ Airavata_getExperimentOutputs_result() {
+ }
+
+ virtual ~Airavata_getExperimentOutputs_result() throw() {}
+
+ std::vector< ::DataObjectType> success;
+
+ _Airavata_getExperimentOutputs_result__isset __isset;
+
+ void __set_success(const std::vector< ::DataObjectType> & val) {
+ success = val;
+ }
+
+ bool operator == (const Airavata_getExperimentOutputs_result & rhs) const
+ {
+ if (!(success == rhs.success))
+ return false;
+ return true;
+ }
+ bool operator != (const Airavata_getExperimentOutputs_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Airavata_getExperimentOutputs_result & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_getExperimentOutputs_presult__isset {
+ _Airavata_getExperimentOutputs_presult__isset() : success(false) {}
+ bool success;
+} _Airavata_getExperimentOutputs_presult__isset;
+
+class Airavata_getExperimentOutputs_presult {
+ public:
+
+
+ virtual ~Airavata_getExperimentOutputs_presult() throw() {}
+
+ std::vector< ::DataObjectType> * success;
+
+ _Airavata_getExperimentOutputs_presult__isset __isset;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class Airavata_getJobStatuses_args {
+ public:
+
+ Airavata_getJobStatuses_args() : airavataExperimentId() {
+ }
+
+ virtual ~Airavata_getJobStatuses_args() throw() {}
+
+ std::string airavataExperimentId;
+
+ void __set_airavataExperimentId(const std::string& val) {
+ airavataExperimentId = val;
+ }
+
+ bool operator == (const Airavata_getJobStatuses_args & rhs) const
+ {
+ if (!(airavataExperimentId == rhs.airavataExperimentId))
+ return false;
+ return true;
+ }
+ bool operator != (const Airavata_getJobStatuses_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Airavata_getJobStatuses_args & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Airavata_getJobStatuses_pargs {
+ public:
+
+
+ virtual ~Airavata_getJobStatuses_pargs() throw() {}
+
+ const std::string* airavataExperimentId;
+
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_getJobStatuses_result__isset {
+ _Airavata_getJobStatuses_result__isset() : success(false) {}
+ bool success;
+} _Airavata_getJobStatuses_result__isset;
+
+class Airavata_getJobStatuses_result {
+ public:
+
+ Airavata_getJobStatuses_result() {
+ }
+
+ virtual ~Airavata_getJobStatuses_result() throw() {}
+
+ std::map<std::string, ::JobStatus> success;
+
+ _Airavata_getJobStatuses_result__isset __isset;
+
+ void __set_success(const std::map<std::string, ::JobStatus> & val) {
+ success = val;
+ }
+
+ bool operator == (const Airavata_getJobStatuses_result & rhs) const
+ {
+ if (!(success == rhs.success))
+ return false;
+ return true;
+ }
+ bool operator != (const Airavata_getJobStatuses_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Airavata_getJobStatuses_result & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_getJobStatuses_presult__isset {
+ _Airavata_getJobStatuses_presult__isset() : success(false) {}
+ bool success;
+} _Airavata_getJobStatuses_presult__isset;
+
+class Airavata_getJobStatuses_presult {
+ public:
+
+
+ virtual ~Airavata_getJobStatuses_presult() throw() {}
+
+ std::map<std::string, ::JobStatus> * success;
+
+ _Airavata_getJobStatuses_presult__isset __isset;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _Airavata_cloneExperiment_args__isset {
+ _Airavata_cloneExperiment_args__isset() : airavataExperimentIdToBeCloned(false), updatedExperiment(false) {}
+ bool airavataExperimentIdToBeCloned;
+ bool updatedExperiment;
+} _Airavata_cloneExperiment_args__isset;
+
+class Airavata_cloneExperiment_args {
+ public:
+
+ Airavata_cloneExperiment_args() : airavataExperimentIdToBeCloned() {
+ }
+
+ virtual ~Airavata_cloneExperiment_args() throw() {}
+
+ std::string airavataExperimentIdToBeCloned;
+ ::Experiment updatedExperiment;
+
+ _Airavata_cloneExperiment_args__isset __isset;
+
+ void __set_airavataExperimentIdToBeCloned(const std::string& val) {
+ airavataExperimentIdToBeCloned = val;
+ }
+
+ void __set_updatedExperiment(const ::Experiment& val) {
+ updatedExperiment = val;
+ }
+
+ bool operator == (const Airavata_cloneExperiment_args & rhs) const
+ {
+ if (!(airavataExperimentIdToBeCloned == rhs.airavataExperimentIdToBeCloned))
+ return false;
+ if (!(updatedExperiment == rhs.updatedExperiment))
+ return false;
+ return true;
+ }
+ bool operator != (const Airavata_cloneExperiment_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Airavata_cloneExperiment_args & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Airavata_cloneExperiment_pargs {
+ public:
+
+
+ virtual ~Airavata_cloneExperiment_pargs() throw() {}
+
+ const std::string* airavataExperimentIdToBeCloned;
+ const ::Experiment* updatedExperiment;
+
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_cloneExperiment_result__isset {
+ _Airavata_cloneExperiment_result__isset() : success(false), ire(false), enf(false), ace(false), ase(false) {}
+ bool success;
+ bool ire;
+ bool enf;
+ bool ace;
+ bool ase;
+} _Airavata_cloneExperiment_result__isset;
+
+class Airavata_cloneExperiment_result {
+ public:
+
+ Airavata_cloneExperiment_result() : success() {
+ }
+
+ virtual ~Airavata_cloneExperiment_result() throw() {}
+
+ std::string success;
+ ::airavata::api::error::InvalidRequestException ire;
+ ::airavata::api::error::ExperimentNotFoundException enf;
+ ::airavata::api::error::AiravataClientException ace;
+ ::airavata::api::error::AiravataSystemException ase;
+
+ _Airavata_cloneExperiment_result__isset __isset;
+
+ void __set_success(const std::string& val) {
+ success = val;
+ }
+
+ void __set_ire(const ::airavata::api::error::InvalidRequestException& val) {
+ ire = val;
+ }
+
+ void __set_enf(const ::airavata::api::error::ExperimentNotFoundException& val) {
+ enf = val;
+ }
+
+ void __set_ace(const ::airavata::api::error::AiravataClientException& val) {
+ ace = val;
+ }
+
+ void __set_ase(const ::airavata::api::error::AiravataSystemException& val) {
+ ase = val;
+ }
+
+ bool operator == (const Airavata_cloneExperiment_result & rhs) const
+ {
+ if (!(success == rhs.success))
+ return false;
+ if (!(ire == rhs.ire))
+ return false;
+ if (!(enf == rhs.enf))
+ return false;
+ if (!(ace == rhs.ace))
+ return false;
+ if (!(ase == rhs.ase))
+ return false;
+ return true;
+ }
+ bool operator != (const Airavata_cloneExperiment_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Airavata_cloneExperiment_result & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_cloneExperiment_presult__isset {
+ _Airavata_cloneExperiment_presult__isset() : success(false), ire(false), enf(false), ace(false), ase(false) {}
+ bool success;
+ bool ire;
+ bool enf;
+ bool ace;
+ bool ase;
+} _Airavata_cloneExperiment_presult__isset;
+
+class Airavata_cloneExperiment_presult {
+ public:
+
+
+ virtual ~Airavata_cloneExperiment_presult() throw() {}
+
+ std::string* success;
+ ::airavata::api::error::InvalidRequestException ire;
+ ::airavata::api::error::ExperimentNotFoundException enf;
+ ::airavata::api::error::AiravataClientException ace;
+ ::airavata::api::error::AiravataSystemException ase;
+
+ _Airavata_cloneExperiment_presult__isset __isset;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _Airavata_terminateExperiment_args__isset {
+ _Airavata_terminateExperiment_args__isset() : airavataExperimentId(false) {}
+ bool airavataExperimentId;
+} _Airavata_terminateExperiment_args__isset;
+
+class Airavata_terminateExperiment_args {
+ public:
+
+ Airavata_terminateExperiment_args() : airavataExperimentId() {
+ }
+
+ virtual ~Airavata_terminateExperiment_args() throw() {}
+
+ std::string airavataExperimentId;
+
+ _Airavata_terminateExperiment_args__isset __isset;
+
+ void __set_airavataExperimentId(const std::string& val) {
+ airavataExperimentId = val;
+ }
+
+ bool operator == (const Airavata_terminateExperiment_args & rhs) const
+ {
+ if (!(airavataExperimentId == rhs.airavataExperimentId))
+ return false;
+ return true;
+ }
+ bool operator != (const Airavata_terminateExperiment_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Airavata_terminateExperiment_args & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Airavata_terminateExperiment_pargs {
+ public:
+
+
+ virtual ~Airavata_terminateExperiment_pargs() throw() {}
+
+ const std::string* airavataExperimentId;
+
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_terminateExperiment_result__isset {
+ _Airavata_terminateExperiment_result__isset() : ire(false), enf(false), ace(false), ase(false) {}
+ bool ire;
+ bool enf;
+ bool ace;
+ bool ase;
+} _Airavata_terminateExperiment_result__isset;
+
+class Airavata_terminateExperiment_result {
+ public:
+
+ Airavata_terminateExperiment_result() {
+ }
+
+ virtual ~Airavata_terminateExperiment_result() throw() {}
+
+ ::airavata::api::error::InvalidRequestException ire;
+ ::airavata::api::error::ExperimentNotFoundException enf;
+ ::airavata::api::error::AiravataClientException ace;
+ ::airavata::api::error::AiravataSystemException ase;
+
+ _Airavata_terminateExperiment_result__isset __isset;
+
+ void __set_ire(const ::airavata::api::error::InvalidRequestException& val) {
+ ire = val;
+ }
+
+ void __set_enf(const ::airavata::api::error::ExperimentNotFoundException& val) {
+ enf = val;
+ }
+
+ void __set_ace(const ::airavata::api::error::AiravataClientException& val) {
+ ace = val;
+ }
+
+ void __set_ase(const ::airavata::api::error::AiravataSystemException& val) {
+ ase = val;
+ }
+
+ bool operator == (const Airavata_terminateExperiment_result & rhs) const
+ {
+ if (!(ire == rhs.ire))
+ return false;
+ if (!(enf == rhs.enf))
+ return false;
+ if (!(ace == rhs.ace))
+ return false;
+ if (!(ase == rhs.ase))
+ return false;
+ return true;
+ }
+ bool operator != (const Airavata_terminateExperiment_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Airavata_terminateExperiment_result & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Airavata_terminateExperiment_presult__isset {
+ _Airavata_terminateExperiment_presult__isset() : ire(false), enf(false), ace(false), ase(false) {}
+ bool ire;
+ bool enf;
+ bool ace;
+ bool ase;
+} _Airavata_terminateExperiment_presult__isset;
+
+class Airavata_terminateExperiment_presult {
+ public:
+
+
+ virtual ~Airavata_terminateExperiment_presult() throw() {}
+
+ ::airavata::api::error::InvalidRequestException ire;
+ ::airavata::api::error::ExperimentNotFoundException enf;
+ ::airavata::api::error::AiravataClientException ace;
+ ::airavata::api::error::AiravataSystemException ase;
+
+ _Airavata_terminateExperiment_presult__isset __isset;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+class AiravataClient : virtual public AiravataIf {
+ public:
+ AiravataClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) :
+ piprot_(prot),
+ poprot_(prot) {
+ iprot_ = prot.get();
+ oprot_ = prot.get();
+ }
+ AiravataClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, boost::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) :
+ piprot_(iprot),
+ poprot_(oprot) {
+ iprot_ = iprot.get();
+ oprot_ = oprot.get();
+ }
+ boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() {
+ return piprot_;
+ }
+ boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() {
+ return poprot_;
+ }
+ void GetAPIVersion(std::string& _return);
+ void send_GetAPIVersion();
+ void recv_GetAPIVersion(std::string& _return);
+ void createProject(std::string& _return, const ::Project& project, const std::string& userName);
+ void send_createProject(const ::Project& project, const std::string& userName);
+ void recv_createProject(std::string& _return);
+ void updateProject(const ::Project& project);
+ void send_updateProject(const ::Project& project);
+ void recv_updateProject();
+ void getProject( ::Project& _return, const std::string& projectId);
+ void send_getProject(const std::string& projectId);
+ void recv_getProject( ::Project& _return);
+ void getAllUserProjects(std::vector< ::Project> & _return, const std::string& userName);
+ void send_getAllUserProjects(const std::string& userName);
+ void recv_getAllUserProjects(std::vector< ::Project> & _return);
+ void getAllExperimentsInProject(std::vector< ::Experiment> & _return, const std::string& projectId);
+ void send_getAllExperimentsInProject(const std::string& projectId);
+ void recv_getAllExperimentsInProject(std::vector< ::Experiment> & _return);
+ void getAllUserExperiments(std::vector< ::Experiment> & _return, const std::string& userName);
+ void send_getAllUserExperiments(const std::string& userName);
+ void recv_getAllUserExperiments(std::vector< ::Experiment> & _return);
+ void createExperiment(std::string& _return, const ::Experiment& experiment);
+ void send_createExperiment(const ::Experiment& experiment);
+ void recv_createExperiment(std::string& _return);
+ void getExperiment( ::Experiment& _return, const std::string& airavataExperimentId);
+ void send_getExperiment(const std::string& airavataExperimentId);
+ void recv_getExperiment( ::Experiment& _return);
+ void updateExperiment(const std::string& airavataExperimentId, const ::Experiment& experiment);
+ void send_updateExperiment(const std::string& airavataExperimentId, const ::Experiment& experiment);
+ void recv_updateExperiment();
+ void updateExperimentConfiguration(const std::string& airavataExperimentId, const ::UserConfigurationData& userConfiguration);
+ void send_updateExperimentConfiguration(const std::string& airavataExperimentId, const ::UserConfigurationData& userConfiguration);
+ void recv_updateExperimentConfiguration();
+ void updateResourceScheduleing(const std::string& airavataExperimentId, const ::ComputationalResourceScheduling& resourceScheduling);
+ void send_updateResourceScheduleing(const std::string& airavataExperimentId, const ::ComputationalResourceScheduling& resourceScheduling);
+ void recv_updateResourceScheduleing();
+ void launchExperiment(const std::string& airavataExperimentId, const std::string& airavataCredStoreToken);
+ void send_launchExperiment(const std::string& airavataExperimentId, const std::string& airavataCredStoreToken);
+ void recv_launchExperiment();
+ void getExperimentStatus( ::ExperimentStatus& _return, const std::string& airavataExperimentId);
+ void send_getExperimentStatus(const std::string& airavataExperimentId);
+ void recv_getExperimentStatus( ::ExperimentStatus& _return);
+ void getExperimentOutputs(std::vector< ::DataObjectType> & _return, const std::string& airavataExperimentId);
+ void send_getExperimentOutputs(const std::string& airavataExperimentId);
+ void recv_getExperimentOutputs(std::vector< ::DataObjectType> & _return);
+ void getJobStatuses(std::map<std::string, ::JobStatus> & _return, const std::string& airavataExperimentId);
+ void send_getJobStatuses(const std::string& airavataExperimentId);
+ void recv_getJobStatuses(std::map<std::string, ::JobStatus> & _return);
+ void cloneExperiment(std::string& _return, const std::string& airavataExperimentIdToBeCloned, const ::Experiment& updatedExperiment);
+ void send_cloneExperiment(const std::string& airavataExperimentIdToBeCloned, const ::Experiment& updatedExperiment);
+ void recv_cloneExperiment(std::string& _return);
+ void terminateExperiment(const std::string& airavataExperimentId);
+ void send_terminateExperiment(const std::string& airavataExperimentId);
+ void recv_terminateExperiment();
+ protected:
+ boost::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_;
+ boost::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_;
+ ::apache::thrift::protocol::TProtocol* iprot_;
+ ::apache::thrift::protocol::TProtocol* oprot_;
+};
+
+class AiravataProcessor : public ::apache::thrift::TDispatchProcessor {
+ protected:
+ boost::shared_ptr<AiravataIf> iface_;
+ virtual bool dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext);
+ private:
+ typedef void (AiravataProcessor::*ProcessFunction)(int32_t, ::apache::thrift::protocol::TProtocol*, ::apache::thrift::protocol::TProtocol*, void*);
+ typedef std::map<std::string, ProcessFunction> ProcessMap;
+ ProcessMap processMap_;
+ void process_GetAPIVersion(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+ void process_createProject(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+ void process_updateProject(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+ void process_getProject(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+ void process_getAllUserProjects(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+ void process_getAllExperimentsInProject(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+ void process_getAllUserExperiments(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+ void process_createExperiment(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+ void process_getExperiment(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+ void process_updateExperiment(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+ void process_updateExperimentConfiguration(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+ void process_updateResourceScheduleing(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+ void process_launchExperiment(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+ void process_getExperimentStatus(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+ void process_getExperimentOutputs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+ void process_getJobStatuses(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+ void process_cloneExperiment(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+ void process_terminateExperiment(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+ public:
+ AiravataProcessor(boost::shared_ptr<AiravataIf> iface) :
+ iface_(iface) {
+ processMap_["GetAPIVersion"] = &AiravataProcessor::process_GetAPIVersion;
+ processMap_["createProject"] = &AiravataProcessor::process_createProject;
+ processMap_["updateProject"] = &AiravataProcessor::process_updateProject;
+ processMap_["getProject"] = &AiravataProcessor::process_getProject;
+ processMap_["getAllUserProjects"] = &AiravataProcessor::process_getAllUserProjects;
+ processMap_["getAllExperimentsInProject"] = &AiravataProcessor::process_getAllExperimentsInProject;
+ processMap_["getAllUserExperiments"] = &AiravataProcessor::process_getAllUserExperiments;
+ processMap_["createExperiment"] = &AiravataProcessor::process_createExperiment;
+ processMap_["getExperiment"] = &AiravataProcessor::process_getExperiment;
+ processMap_["updateExperiment"] = &AiravataProcessor::process_updateExperiment;
+ processMap_["updateExperimentConfiguration"] = &AiravataProcessor::process_updateExperimentConfiguration;
+ processMap_["updateResourceScheduleing"] = &AiravataProcessor::process_updateResourceScheduleing;
+ processMap_["launchExperiment"] = &AiravataProcessor::process_launchExperiment;
+ processMap_["getExperimentStatus"] = &AiravataProcessor::process_getExperimentStatus;
+ processMap_["getExperimentOutputs"] = &AiravataProcessor::process_getExperimentOutputs;
+ processMap_["getJobStatuses"] = &AiravataProcessor::process_getJobStatuses;
+ processMap_["cloneExperiment"] = &AiravataProcessor::process_cloneExperiment;
+ processMap_["terminateExperiment"] = &AiravataProcessor::process_terminateExperiment;
+ }
+
+ virtual ~AiravataProcessor() {}
+};
+
+class AiravataProcessorFactory : public ::apache::thrift::TProcessorFactory {
+ public:
+ AiravataProcessorFactory(const ::boost::shared_ptr< AiravataIfFactory >& handlerFactory) :
+ handlerFactory_(handlerFactory) {}
+
+ ::boost::shared_ptr< ::apache::thrift::TProcessor > getProcessor(const ::apache::thrift::TConnectionInfo& connInfo);
+
+ protected:
+ ::boost::shared_ptr< AiravataIfFactory > handlerFactory_;
+};
+
+class AiravataMultiface : virtual public AiravataIf {
+ public:
+ AiravataMultiface(std::vector<boost::shared_ptr<AiravataIf> >& ifaces) : ifaces_(ifaces) {
+ }
+ virtual ~AiravataMultiface() {}
+ protected:
+ std::vector<boost::shared_ptr<AiravataIf> > ifaces_;
+ AiravataMultiface() {}
+ void add(boost::shared_ptr<AiravataIf> iface) {
+ ifaces_.push_back(iface);
+ }
+ public:
+ void GetAPIVersion(std::string& _return) {
+ size_t sz = ifaces_.size();
+ size_t i = 0;
+ for (; i < (sz - 1); ++i) {
+ ifaces_[i]->GetAPIVersion(_return);
+ }
+ ifaces_[i]->GetAPIVersion(_return);
+ return;
+ }
+
+ void createProject(std::string& _return, const ::Project& project, const std::string& userName) {
+ size_t sz = ifaces_.size();
+ size_t i = 0;
+ for (; i < (sz - 1); ++i) {
+ ifaces_[i]->createProject(_return, project, userName);
+ }
+ ifaces_[i]->createProject(_return, project, userName);
+ return;
+ }
+
+ void updateProject(const ::Project& project) {
+ size_t sz = ifaces_.size();
+ size_t i = 0;
+ for (; i < (sz - 1); ++i) {
+ ifaces_[i]->updateProject(project);
+ }
+ ifaces_[i]->updateProject(project);
+ }
+
+ void getProject( ::Project& _return, const std::string& projectId) {
+ size_t sz = ifaces_.size();
+ size_t i = 0;
+ for (; i < (sz - 1); ++i) {
+ ifaces_[i]->getProject(_return, projectId);
+ }
+ ifaces_[i]->getProject(_return, projectId);
+ return;
+ }
+
+ void getAllUserProjects(std::vector< ::Project> & _return, const std::string& userName) {
+ size_t sz = ifaces_.size();
+ size_t i = 0;
+ for (; i < (sz - 1); ++i) {
+ ifaces_[i]->getAllUserProjects(_return, userName);
+ }
+ ifaces_[i]->getAllUserProjects(_return, userName);
+ return;
+ }
+
+ void getAllExperimentsInProject(std::vector< ::Experiment> & _return, const std::string& projectId) {
+ size_t sz = ifaces_.size();
+ size_t i = 0;
+ for (; i < (sz - 1); ++i) {
+ ifaces_[i]->getAllExperimentsInProject(_return, projectId);
+ }
+ ifaces_[i]->getAllExperimentsInProject(_return, projectId);
+ return;
+ }
+
+ void getAllUserExperiments(std::vector< ::Experiment> & _return, const std::string& userName) {
+ size_t sz = ifaces_.size();
+ size_t i = 0;
+ for (; i < (sz - 1); ++i) {
+ ifaces_[i]->getAllUserExperiments(_return, userName);
+ }
+ ifaces_[i]->getAllUserExperiments(_return, userName);
+ return;
+ }
+
+ void createExperiment(std::string& _return, const ::Experiment& experiment) {
+ size_t sz = ifaces_.size();
+ size_t i = 0;
+ for (; i < (sz - 1); ++i) {
+ ifaces_[i]->createExperiment(_return, experiment);
+ }
+ ifaces_[i]->createExperiment(_return, experiment);
+ return;
+ }
+
+ void getExperiment( ::Experiment& _return, const std::string& airavataExperimentId) {
+ size_t sz = ifaces_.size();
+ size_t i = 0;
+ for (; i < (sz - 1); ++i) {
+ ifaces_[i]->getExperiment(_return, airavataExperimentId);
+ }
+ ifaces_[i]->getExperiment(_return, airavataExperimentId);
+ return;
+ }
+
+ void updateExperiment(const std::string& airavataExperimentId, const ::Experiment& experiment) {
+ size_t sz = ifaces_.size();
+ size_t i = 0;
+ for (; i < (sz - 1); ++i) {
+ ifaces_[i]->updateExperiment(airavataExperimentId, experiment);
+ }
+ ifaces_[i]->updateExperiment(airavataExperimentId, experiment);
+ }
+
+ void updateExperimentConfiguration(const std::string& airavataExperimentId, const ::UserConfigurationData& userConfiguration) {
+ size_t sz = ifaces_.size();
+ size_t i = 0;
+ for (; i < (sz - 1); ++i) {
+ ifaces_[i]->updateExperimentConfiguration(airavataExperimentId, userConfiguration);
+ }
+ ifaces_[i]->updateExperimentConfiguration(airavataExperimentId, userConfiguration);
+ }
+
+ void updateResourceScheduleing(const std::string& airavataExperimentId, const ::ComputationalResourceScheduling& resourceScheduling) {
+ size_t sz = ifaces_.size();
+ size_t i = 0;
+ for (; i < (sz - 1); ++i) {
+ ifaces_[i]->updateResourceScheduleing(airavataExperimentId, resourceScheduling);
+ }
+ ifaces_[i]->updateResourceScheduleing(airavataExperimentId, resourceScheduling);
+ }
+
+ void launchExperiment(const std::string& airavataExperimentId, const std::string& airavataCredStoreToken) {
+ size_t sz = ifaces_.size();
+ size_t i = 0;
+ for (; i < (sz - 1); ++i) {
+ ifaces_[i]->launchExperiment(airavataExperimentId, airavataCredStoreToken);
+ }
+ ifaces_[i]->launchExperiment(airavataExperimentId, airavataCredStoreToken);
+ }
+
+ void getExperimentStatus( ::ExperimentStatus& _return, const std::string& airavataExperimentId) {
+ size_t sz = ifaces_.size();
+ size_t i = 0;
+ for (; i < (sz - 1); ++i) {
+ ifaces_[i]->getExperimentStatus(_return, airavataExperimentId);
+ }
+ ifaces_[i]->getExperimentStatus(_return, airavataExperimentId);
+ return;
+ }
+
+ void getExperimentOutputs(std::vector< ::DataObjectType> & _return, const std::string& airavataExperimentId) {
+ size_t sz = ifaces_.size();
+ size_t i = 0;
+ for (; i < (sz - 1); ++i) {
+ ifaces_[i]->getExperimentOutputs(_return, airavataExperimentId);
+ }
+ ifaces_[i]->getExperimentOutputs(_return, airavataExperimentId);
+ return;
+ }
+
+ void getJobStatuses(std::map<std::string, ::JobStatus> & _return, const std::string& airavataExperimentId) {
+ size_t sz = ifaces_.size();
+ size_t i = 0;
+ for (; i < (sz - 1); ++i) {
+ ifaces_[i]->getJobStatuses(_return, airavataExperimentId);
+ }
+ ifaces_[i]->getJobStatuses(_return, airavataExperimentId);
+ return;
+ }
+
+ void cloneExperiment(std::string& _return, const std::string& airavataExperimentIdToBeCloned, const ::Experiment& updatedExperiment) {
+ size_t sz = ifaces_.size();
+ size_t i = 0;
+ for (; i < (sz - 1); ++i) {
+ ifaces_[i]->cloneExperiment(_return, airavataExperimentIdToBeCloned, updatedExperiment);
+ }
+ ifaces_[i]->cloneExperiment(_return, airavataExperimentIdToBeCloned, updatedExperiment);
+ return;
+ }
+
+ void terminateExperiment(const std::string& airavataExperimentId) {
+ size_t sz = ifaces_.size();
+ size_t i = 0;
+ for (; i < (sz - 1); ++i) {
+ ifaces_[i]->terminateExperiment(airavataExperimentId);
+ }
+ ifaces_[i]->terminateExperiment(airavataExperimentId);
+ }
+
+};
+
+}} // namespace
+
+#endif
http://git-wip-us.apache.org/repos/asf/airavata/blob/77758cb9/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/Airavata_server.skeleton.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/Airavata_server.skeleton.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/Airavata_server.skeleton.cpp
new file mode 100644
index 0000000..ed071e6
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/Airavata_server.skeleton.cpp
@@ -0,0 +1,129 @@
+// This autogenerated skeleton file illustrates how to build a server.
+// You should copy it to another filename to avoid overwriting it.
+
+#include "Airavata.h"
+#include <thrift/protocol/TBinaryProtocol.h>
+#include <thrift/server/TSimpleServer.h>
+#include <thrift/transport/TServerSocket.h>
+#include <thrift/transport/TBufferTransports.h>
+
+using namespace ::apache::thrift;
+using namespace ::apache::thrift::protocol;
+using namespace ::apache::thrift::transport;
+using namespace ::apache::thrift::server;
+
+using boost::shared_ptr;
+
+using namespace ::airavata::api;
+
+class AiravataHandler : virtual public AiravataIf {
+ public:
+ AiravataHandler() {
+ // Your initialization goes here
+ }
+
+ void GetAPIVersion(std::string& _return) {
+ // Your implementation goes here
+ printf("GetAPIVersion\n");
+ }
+
+ void createProject(std::string& _return, const ::Project& project, const std::string& userName) {
+ // Your implementation goes here
+ printf("createProject\n");
+ }
+
+ void updateProject(const ::Project& project) {
+ // Your implementation goes here
+ printf("updateProject\n");
+ }
+
+ void getProject( ::Project& _return, const std::string& projectId) {
+ // Your implementation goes here
+ printf("getProject\n");
+ }
+
+ void getAllUserProjects(std::vector< ::Project> & _return, const std::string& userName) {
+ // Your implementation goes here
+ printf("getAllUserProjects\n");
+ }
+
+ void getAllExperimentsInProject(std::vector< ::Experiment> & _return, const std::string& projectId) {
+ // Your implementation goes here
+ printf("getAllExperimentsInProject\n");
+ }
+
+ void getAllUserExperiments(std::vector< ::Experiment> & _return, const std::string& userName) {
+ // Your implementation goes here
+ printf("getAllUserExperiments\n");
+ }
+
+ void createExperiment(std::string& _return, const ::Experiment& experiment) {
+ // Your implementation goes here
+ printf("createExperiment\n");
+ }
+
+ void getExperiment( ::Experiment& _return, const std::string& airavataExperimentId) {
+ // Your implementation goes here
+ printf("getExperiment\n");
+ }
+
+ void updateExperiment(const std::string& airavataExperimentId, const ::Experiment& experiment) {
+ // Your implementation goes here
+ printf("updateExperiment\n");
+ }
+
+ void updateExperimentConfiguration(const std::string& airavataExperimentId, const ::UserConfigurationData& userConfiguration) {
+ // Your implementation goes here
+ printf("updateExperimentConfiguration\n");
+ }
+
+ void updateResourceScheduleing(const std::string& airavataExperimentId, const ::ComputationalResourceScheduling& resourceScheduling) {
+ // Your implementation goes here
+ printf("updateResourceScheduleing\n");
+ }
+
+ void launchExperiment(const std::string& airavataExperimentId, const std::string& airavataCredStoreToken) {
+ // Your implementation goes here
+ printf("launchExperiment\n");
+ }
+
+ void getExperimentStatus( ::ExperimentStatus& _return, const std::string& airavataExperimentId) {
+ // Your implementation goes here
+ printf("getExperimentStatus\n");
+ }
+
+ void getExperimentOutputs(std::vector< ::DataObjectType> & _return, const std::string& airavataExperimentId) {
+ // Your implementation goes here
+ printf("getExperimentOutputs\n");
+ }
+
+ void getJobStatuses(std::map<std::string, ::JobStatus> & _return, const std::string& airavataExperimentId) {
+ // Your implementation goes here
+ printf("getJobStatuses\n");
+ }
+
+ void cloneExperiment(std::string& _return, const std::string& airavataExperimentIdToBeCloned, const ::Experiment& updatedExperiment) {
+ // Your implementation goes here
+ printf("cloneExperiment\n");
+ }
+
+ void terminateExperiment(const std::string& airavataExperimentId) {
+ // Your implementation goes here
+ printf("terminateExperiment\n");
+ }
+
+};
+
+int main(int argc, char **argv) {
+ int port = 9090;
+ shared_ptr<AiravataHandler> handler(new AiravataHandler());
+ shared_ptr<TProcessor> processor(new AiravataProcessor(handler));
+ shared_ptr<TServerTransport> serverTransport(new TServerSocket(port));
+ shared_ptr<TTransportFactory> transportFactory(new TBufferedTransportFactory());
+ shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory());
+
+ TSimpleServer server(processor, serverTransport, transportFactory, protocolFactory);
+ server.serve();
+ return 0;
+}
+
http://git-wip-us.apache.org/repos/asf/airavata/blob/77758cb9/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/airavataAPI_constants.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/airavataAPI_constants.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/airavataAPI_constants.cpp
new file mode 100644
index 0000000..4f61277
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/airavataAPI_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 "airavataAPI_constants.h"
+
+namespace airavata { namespace api {
+
+const airavataAPIConstants g_airavataAPI_constants;
+
+airavataAPIConstants::airavataAPIConstants() {
+ AIRAVATA_API_VERSION = "0.12.0";
+
+}
+
+}} // namespace
+
http://git-wip-us.apache.org/repos/asf/airavata/blob/77758cb9/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/airavataAPI_constants.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/airavataAPI_constants.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/airavataAPI_constants.h
new file mode 100644
index 0000000..bbe3692
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/airavataAPI_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 airavataAPI_CONSTANTS_H
+#define airavataAPI_CONSTANTS_H
+
+#include "airavataAPI_types.h"
+
+namespace airavata { namespace api {
+
+class airavataAPIConstants {
+ public:
+ airavataAPIConstants();
+
+ std::string AIRAVATA_API_VERSION;
+};
+
+extern const airavataAPIConstants g_airavataAPI_constants;
+
+}} // namespace
+
+#endif
[5/6] Generated C++ Client SDK - AIRAVATA-1075
Posted by sm...@apache.org.
http://git-wip-us.apache.org/repos/asf/airavata/blob/77758cb9/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/Airavata.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/Airavata.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/Airavata.cpp
new file mode 100644
index 0000000..3bd2fc4
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/Airavata.cpp
@@ -0,0 +1,6268 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+#include "Airavata.h"
+
+namespace airavata { namespace api {
+
+uint32_t Airavata_GetAPIVersion_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ xfer += iprot->skip(ftype);
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Airavata_GetAPIVersion_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Airavata_GetAPIVersion_args");
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_GetAPIVersion_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Airavata_GetAPIVersion_pargs");
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_GetAPIVersion_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 0:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->success);
+ this->__isset.success = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Airavata_GetAPIVersion_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+ uint32_t xfer = 0;
+
+ xfer += oprot->writeStructBegin("Airavata_GetAPIVersion_result");
+
+ if (this->__isset.success) {
+ xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRING, 0);
+ xfer += oprot->writeString(this->success);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_GetAPIVersion_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 0:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString((*(this->success)));
+ this->__isset.success = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Airavata_createProject_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_project = false;
+ 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_STRUCT) {
+ xfer += this->project.read(iprot);
+ isset_project = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->userName);
+ isset_userName = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_project)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_userName)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t Airavata_createProject_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Airavata_createProject_args");
+
+ xfer += oprot->writeFieldBegin("project", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->project.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("userName", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->userName);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_createProject_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Airavata_createProject_pargs");
+
+ xfer += oprot->writeFieldBegin("project", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += (*(this->project)).write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("userName", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString((*(this->userName)));
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_createProject_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 0:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->success);
+ this->__isset.success = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ire.read(iprot);
+ this->__isset.ire = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ace.read(iprot);
+ this->__isset.ace = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ase.read(iprot);
+ this->__isset.ase = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Airavata_createProject_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+ uint32_t xfer = 0;
+
+ xfer += oprot->writeStructBegin("Airavata_createProject_result");
+
+ if (this->__isset.success) {
+ xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRING, 0);
+ xfer += oprot->writeString(this->success);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.ire) {
+ xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->ire.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.ace) {
+ xfer += oprot->writeFieldBegin("ace", ::apache::thrift::protocol::T_STRUCT, 2);
+ xfer += this->ace.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.ase) {
+ xfer += oprot->writeFieldBegin("ase", ::apache::thrift::protocol::T_STRUCT, 3);
+ xfer += this->ase.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_createProject_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 0:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString((*(this->success)));
+ this->__isset.success = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ire.read(iprot);
+ this->__isset.ire = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ace.read(iprot);
+ this->__isset.ace = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ase.read(iprot);
+ this->__isset.ase = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Airavata_updateProject_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_project = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->project.read(iprot);
+ isset_project = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_project)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t Airavata_updateProject_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Airavata_updateProject_args");
+
+ xfer += oprot->writeFieldBegin("project", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->project.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_updateProject_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Airavata_updateProject_pargs");
+
+ xfer += oprot->writeFieldBegin("project", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += (*(this->project)).write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_updateProject_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ire.read(iprot);
+ this->__isset.ire = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ace.read(iprot);
+ this->__isset.ace = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ase.read(iprot);
+ this->__isset.ase = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Airavata_updateProject_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+ uint32_t xfer = 0;
+
+ xfer += oprot->writeStructBegin("Airavata_updateProject_result");
+
+ if (this->__isset.ire) {
+ xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->ire.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.ace) {
+ xfer += oprot->writeFieldBegin("ace", ::apache::thrift::protocol::T_STRUCT, 2);
+ xfer += this->ace.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.ase) {
+ xfer += oprot->writeFieldBegin("ase", ::apache::thrift::protocol::T_STRUCT, 3);
+ xfer += this->ase.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_updateProject_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ire.read(iprot);
+ this->__isset.ire = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ace.read(iprot);
+ this->__isset.ace = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ase.read(iprot);
+ this->__isset.ase = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Airavata_getProject_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_projectId = 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;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_projectId)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t Airavata_getProject_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Airavata_getProject_args");
+
+ xfer += oprot->writeFieldBegin("projectId", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->projectId);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_getProject_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Airavata_getProject_pargs");
+
+ xfer += oprot->writeFieldBegin("projectId", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString((*(this->projectId)));
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_getProject_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 0:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->success.read(iprot);
+ this->__isset.success = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ire.read(iprot);
+ this->__isset.ire = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ace.read(iprot);
+ this->__isset.ace = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ase.read(iprot);
+ this->__isset.ase = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Airavata_getProject_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+ uint32_t xfer = 0;
+
+ xfer += oprot->writeStructBegin("Airavata_getProject_result");
+
+ if (this->__isset.success) {
+ xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0);
+ xfer += this->success.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.ire) {
+ xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->ire.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.ace) {
+ xfer += oprot->writeFieldBegin("ace", ::apache::thrift::protocol::T_STRUCT, 2);
+ xfer += this->ace.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.ase) {
+ xfer += oprot->writeFieldBegin("ase", ::apache::thrift::protocol::T_STRUCT, 3);
+ xfer += this->ase.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_getProject_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 0:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += (*(this->success)).read(iprot);
+ this->__isset.success = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ire.read(iprot);
+ this->__isset.ire = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ace.read(iprot);
+ this->__isset.ace = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ase.read(iprot);
+ this->__isset.ase = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Airavata_getAllUserProjects_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_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;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_userName)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t Airavata_getAllUserProjects_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Airavata_getAllUserProjects_args");
+
+ xfer += oprot->writeFieldBegin("userName", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->userName);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_getAllUserProjects_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Airavata_getAllUserProjects_pargs");
+
+ xfer += oprot->writeFieldBegin("userName", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString((*(this->userName)));
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_getAllUserProjects_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 0:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->success.clear();
+ uint32_t _size0;
+ ::apache::thrift::protocol::TType _etype3;
+ xfer += iprot->readListBegin(_etype3, _size0);
+ this->success.resize(_size0);
+ uint32_t _i4;
+ for (_i4 = 0; _i4 < _size0; ++_i4)
+ {
+ xfer += this->success[_i4].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.success = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ire.read(iprot);
+ this->__isset.ire = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ace.read(iprot);
+ this->__isset.ace = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ase.read(iprot);
+ this->__isset.ase = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Airavata_getAllUserProjects_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+ uint32_t xfer = 0;
+
+ xfer += oprot->writeStructBegin("Airavata_getAllUserProjects_result");
+
+ if (this->__isset.success) {
+ xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
+ std::vector< ::Project> ::const_iterator _iter5;
+ for (_iter5 = this->success.begin(); _iter5 != this->success.end(); ++_iter5)
+ {
+ xfer += (*_iter5).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.ire) {
+ xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->ire.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.ace) {
+ xfer += oprot->writeFieldBegin("ace", ::apache::thrift::protocol::T_STRUCT, 2);
+ xfer += this->ace.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.ase) {
+ xfer += oprot->writeFieldBegin("ase", ::apache::thrift::protocol::T_STRUCT, 3);
+ xfer += this->ase.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_getAllUserProjects_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 0:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ (*(this->success)).clear();
+ uint32_t _size6;
+ ::apache::thrift::protocol::TType _etype9;
+ xfer += iprot->readListBegin(_etype9, _size6);
+ (*(this->success)).resize(_size6);
+ uint32_t _i10;
+ for (_i10 = 0; _i10 < _size6; ++_i10)
+ {
+ xfer += (*(this->success))[_i10].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.success = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ire.read(iprot);
+ this->__isset.ire = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ace.read(iprot);
+ this->__isset.ace = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ase.read(iprot);
+ this->__isset.ase = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Airavata_getAllExperimentsInProject_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_projectId = 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;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_projectId)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t Airavata_getAllExperimentsInProject_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Airavata_getAllExperimentsInProject_args");
+
+ xfer += oprot->writeFieldBegin("projectId", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->projectId);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_getAllExperimentsInProject_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Airavata_getAllExperimentsInProject_pargs");
+
+ xfer += oprot->writeFieldBegin("projectId", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString((*(this->projectId)));
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_getAllExperimentsInProject_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 0:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->success.clear();
+ uint32_t _size11;
+ ::apache::thrift::protocol::TType _etype14;
+ xfer += iprot->readListBegin(_etype14, _size11);
+ this->success.resize(_size11);
+ uint32_t _i15;
+ for (_i15 = 0; _i15 < _size11; ++_i15)
+ {
+ xfer += this->success[_i15].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.success = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ire.read(iprot);
+ this->__isset.ire = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ace.read(iprot);
+ this->__isset.ace = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ase.read(iprot);
+ this->__isset.ase = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Airavata_getAllExperimentsInProject_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+ uint32_t xfer = 0;
+
+ xfer += oprot->writeStructBegin("Airavata_getAllExperimentsInProject_result");
+
+ if (this->__isset.success) {
+ xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
+ std::vector< ::Experiment> ::const_iterator _iter16;
+ for (_iter16 = this->success.begin(); _iter16 != this->success.end(); ++_iter16)
+ {
+ xfer += (*_iter16).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.ire) {
+ xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->ire.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.ace) {
+ xfer += oprot->writeFieldBegin("ace", ::apache::thrift::protocol::T_STRUCT, 2);
+ xfer += this->ace.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.ase) {
+ xfer += oprot->writeFieldBegin("ase", ::apache::thrift::protocol::T_STRUCT, 3);
+ xfer += this->ase.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_getAllExperimentsInProject_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 0:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ (*(this->success)).clear();
+ uint32_t _size17;
+ ::apache::thrift::protocol::TType _etype20;
+ xfer += iprot->readListBegin(_etype20, _size17);
+ (*(this->success)).resize(_size17);
+ uint32_t _i21;
+ for (_i21 = 0; _i21 < _size17; ++_i21)
+ {
+ xfer += (*(this->success))[_i21].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.success = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ire.read(iprot);
+ this->__isset.ire = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ace.read(iprot);
+ this->__isset.ace = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ase.read(iprot);
+ this->__isset.ase = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Airavata_getAllUserExperiments_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_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;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_userName)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t Airavata_getAllUserExperiments_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Airavata_getAllUserExperiments_args");
+
+ xfer += oprot->writeFieldBegin("userName", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->userName);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_getAllUserExperiments_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Airavata_getAllUserExperiments_pargs");
+
+ xfer += oprot->writeFieldBegin("userName", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString((*(this->userName)));
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_getAllUserExperiments_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 0:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->success.clear();
+ uint32_t _size22;
+ ::apache::thrift::protocol::TType _etype25;
+ xfer += iprot->readListBegin(_etype25, _size22);
+ this->success.resize(_size22);
+ uint32_t _i26;
+ for (_i26 = 0; _i26 < _size22; ++_i26)
+ {
+ xfer += this->success[_i26].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.success = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ire.read(iprot);
+ this->__isset.ire = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ace.read(iprot);
+ this->__isset.ace = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ase.read(iprot);
+ this->__isset.ase = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Airavata_getAllUserExperiments_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+ uint32_t xfer = 0;
+
+ xfer += oprot->writeStructBegin("Airavata_getAllUserExperiments_result");
+
+ if (this->__isset.success) {
+ xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
+ std::vector< ::Experiment> ::const_iterator _iter27;
+ for (_iter27 = this->success.begin(); _iter27 != this->success.end(); ++_iter27)
+ {
+ xfer += (*_iter27).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.ire) {
+ xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->ire.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.ace) {
+ xfer += oprot->writeFieldBegin("ace", ::apache::thrift::protocol::T_STRUCT, 2);
+ xfer += this->ace.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.ase) {
+ xfer += oprot->writeFieldBegin("ase", ::apache::thrift::protocol::T_STRUCT, 3);
+ xfer += this->ase.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_getAllUserExperiments_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 0:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ (*(this->success)).clear();
+ uint32_t _size28;
+ ::apache::thrift::protocol::TType _etype31;
+ xfer += iprot->readListBegin(_etype31, _size28);
+ (*(this->success)).resize(_size28);
+ uint32_t _i32;
+ for (_i32 = 0; _i32 < _size28; ++_i32)
+ {
+ xfer += (*(this->success))[_i32].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.success = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ire.read(iprot);
+ this->__isset.ire = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ace.read(iprot);
+ this->__isset.ace = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ase.read(iprot);
+ this->__isset.ase = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Airavata_createExperiment_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_experiment = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->experiment.read(iprot);
+ isset_experiment = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_experiment)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t Airavata_createExperiment_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Airavata_createExperiment_args");
+
+ xfer += oprot->writeFieldBegin("experiment", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->experiment.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_createExperiment_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Airavata_createExperiment_pargs");
+
+ xfer += oprot->writeFieldBegin("experiment", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += (*(this->experiment)).write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_createExperiment_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 0:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->success);
+ this->__isset.success = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ire.read(iprot);
+ this->__isset.ire = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ace.read(iprot);
+ this->__isset.ace = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ase.read(iprot);
+ this->__isset.ase = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Airavata_createExperiment_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+ uint32_t xfer = 0;
+
+ xfer += oprot->writeStructBegin("Airavata_createExperiment_result");
+
+ if (this->__isset.success) {
+ xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRING, 0);
+ xfer += oprot->writeString(this->success);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.ire) {
+ xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->ire.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.ace) {
+ xfer += oprot->writeFieldBegin("ace", ::apache::thrift::protocol::T_STRUCT, 2);
+ xfer += this->ace.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.ase) {
+ xfer += oprot->writeFieldBegin("ase", ::apache::thrift::protocol::T_STRUCT, 3);
+ xfer += this->ase.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_createExperiment_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 0:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString((*(this->success)));
+ this->__isset.success = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ire.read(iprot);
+ this->__isset.ire = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ace.read(iprot);
+ this->__isset.ace = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ase.read(iprot);
+ this->__isset.ase = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Airavata_getExperiment_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_airavataExperimentId = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->airavataExperimentId);
+ isset_airavataExperimentId = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_airavataExperimentId)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t Airavata_getExperiment_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Airavata_getExperiment_args");
+
+ xfer += oprot->writeFieldBegin("airavataExperimentId", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->airavataExperimentId);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_getExperiment_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Airavata_getExperiment_pargs");
+
+ xfer += oprot->writeFieldBegin("airavataExperimentId", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString((*(this->airavataExperimentId)));
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_getExperiment_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 0:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->success.read(iprot);
+ this->__isset.success = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ire.read(iprot);
+ this->__isset.ire = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->enf.read(iprot);
+ this->__isset.enf = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ace.read(iprot);
+ this->__isset.ace = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ase.read(iprot);
+ this->__isset.ase = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Airavata_getExperiment_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+ uint32_t xfer = 0;
+
+ xfer += oprot->writeStructBegin("Airavata_getExperiment_result");
+
+ if (this->__isset.success) {
+ xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0);
+ xfer += this->success.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.ire) {
+ xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->ire.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.enf) {
+ xfer += oprot->writeFieldBegin("enf", ::apache::thrift::protocol::T_STRUCT, 2);
+ xfer += this->enf.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.ace) {
+ xfer += oprot->writeFieldBegin("ace", ::apache::thrift::protocol::T_STRUCT, 3);
+ xfer += this->ace.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.ase) {
+ xfer += oprot->writeFieldBegin("ase", ::apache::thrift::protocol::T_STRUCT, 4);
+ xfer += this->ase.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_getExperiment_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 0:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += (*(this->success)).read(iprot);
+ this->__isset.success = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ire.read(iprot);
+ this->__isset.ire = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->enf.read(iprot);
+ this->__isset.enf = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ace.read(iprot);
+ this->__isset.ace = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ase.read(iprot);
+ this->__isset.ase = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Airavata_updateExperiment_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_airavataExperimentId = false;
+ bool isset_experiment = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->airavataExperimentId);
+ isset_airavataExperimentId = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->experiment.read(iprot);
+ isset_experiment = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_airavataExperimentId)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_experiment)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t Airavata_updateExperiment_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Airavata_updateExperiment_args");
+
+ xfer += oprot->writeFieldBegin("airavataExperimentId", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->airavataExperimentId);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("experiment", ::apache::thrift::protocol::T_STRUCT, 2);
+ xfer += this->experiment.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_updateExperiment_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Airavata_updateExperiment_pargs");
+
+ xfer += oprot->writeFieldBegin("airavataExperimentId", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString((*(this->airavataExperimentId)));
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("experiment", ::apache::thrift::protocol::T_STRUCT, 2);
+ xfer += (*(this->experiment)).write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_updateExperiment_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ire.read(iprot);
+ this->__isset.ire = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->enf.read(iprot);
+ this->__isset.enf = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ace.read(iprot);
+ this->__isset.ace = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ase.read(iprot);
+ this->__isset.ase = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Airavata_updateExperiment_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+ uint32_t xfer = 0;
+
+ xfer += oprot->writeStructBegin("Airavata_updateExperiment_result");
+
+ if (this->__isset.ire) {
+ xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->ire.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.enf) {
+ xfer += oprot->writeFieldBegin("enf", ::apache::thrift::protocol::T_STRUCT, 2);
+ xfer += this->enf.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.ace) {
+ xfer += oprot->writeFieldBegin("ace", ::apache::thrift::protocol::T_STRUCT, 3);
+ xfer += this->ace.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.ase) {
+ xfer += oprot->writeFieldBegin("ase", ::apache::thrift::protocol::T_STRUCT, 4);
+ xfer += this->ase.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_updateExperiment_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ire.read(iprot);
+ this->__isset.ire = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->enf.read(iprot);
+ this->__isset.enf = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ace.read(iprot);
+ this->__isset.ace = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ase.read(iprot);
+ this->__isset.ase = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Airavata_updateExperimentConfiguration_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_airavataExperimentId = false;
+ bool isset_userConfiguration = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->airavataExperimentId);
+ isset_airavataExperimentId = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->userConfiguration.read(iprot);
+ isset_userConfiguration = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_airavataExperimentId)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_userConfiguration)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t Airavata_updateExperimentConfiguration_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Airavata_updateExperimentConfiguration_args");
+
+ xfer += oprot->writeFieldBegin("airavataExperimentId", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->airavataExperimentId);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("userConfiguration", ::apache::thrift::protocol::T_STRUCT, 2);
+ xfer += this->userConfiguration.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_updateExperimentConfiguration_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Airavata_updateExperimentConfiguration_pargs");
+
+ xfer += oprot->writeFieldBegin("airavataExperimentId", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString((*(this->airavataExperimentId)));
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("userConfiguration", ::apache::thrift::protocol::T_STRUCT, 2);
+ xfer += (*(this->userConfiguration)).write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_updateExperimentConfiguration_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ xfer += iprot->skip(ftype);
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Airavata_updateExperimentConfiguration_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+ uint32_t xfer = 0;
+
+ xfer += oprot->writeStructBegin("Airavata_updateExperimentConfiguration_result");
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_updateExperimentConfiguration_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ xfer += iprot->skip(ftype);
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Airavata_updateResourceScheduleing_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_airavataExperimentId = false;
+ bool isset_resourceScheduling = 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->airavataExperimentId);
+ isset_airavataExperimentId = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->resourceScheduling.read(iprot);
+ isset_resourceScheduling = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_airavataExperimentId)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_resourceScheduling)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t Airavata_updateResourceScheduleing_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Airavata_updateResourceScheduleing_args");
+
+ xfer += oprot->writeFieldBegin("airavataExperimentId", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->airavataExperimentId);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("resourceScheduling", ::apache::thrift::protocol::T_STRUCT, 2);
+ xfer += this->resourceScheduling.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_updateResourceScheduleing_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Airavata_updateResourceScheduleing_pargs");
+
+ xfer += oprot->writeFieldBegin("airavataExperimentId", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString((*(this->airavataExperimentId)));
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("resourceScheduling", ::apache::thrift::protocol::T_STRUCT, 2);
+ xfer += (*(this->resourceScheduling)).write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_updateResourceScheduleing_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ xfer += iprot->skip(ftype);
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Airavata_updateResourceScheduleing_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+ uint32_t xfer = 0;
+
+ xfer += oprot->writeStructBegin("Airavata_updateResourceScheduleing_result");
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_updateResourceScheduleing_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ xfer += iprot->skip(ftype);
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Airavata_launchExperiment_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_airavataExperimentId = false;
+ bool isset_airavataCredStoreToken = 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->airavataExperimentId);
+ isset_airavataExperimentId = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->airavataCredStoreToken);
+ isset_airavataCredStoreToken = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_airavataExperimentId)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_airavataCredStoreToken)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t Airavata_launchExperiment_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Airavata_launchExperiment_args");
+
+ xfer += oprot->writeFieldBegin("airavataExperimentId", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->airavataExperimentId);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("airavataCredStoreToken", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->airavataCredStoreToken);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_launchExperiment_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Airavata_launchExperiment_pargs");
+
+ xfer += oprot->writeFieldBegin("airavataExperimentId", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString((*(this->airavataExperimentId)));
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("airavataCredStoreToken", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString((*(this->airavataCredStoreToken)));
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_launchExperiment_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ire.read(iprot);
+ this->__isset.ire = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->enf.read(iprot);
+ this->__isset.enf = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ace.read(iprot);
+ this->__isset.ace = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ase.read(iprot);
+ this->__isset.ase = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Airavata_launchExperiment_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+ uint32_t xfer = 0;
+
+ xfer += oprot->writeStructBegin("Airavata_launchExperiment_result");
+
+ if (this->__isset.ire) {
+ xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->ire.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.enf) {
+ xfer += oprot->writeFieldBegin("enf", ::apache::thrift::protocol::T_STRUCT, 2);
+ xfer += this->enf.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.ace) {
+ xfer += oprot->writeFieldBegin("ace", ::apache::thrift::protocol::T_STRUCT, 3);
+ xfer += this->ace.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.ase) {
+ xfer += oprot->writeFieldBegin("ase", ::apache::thrift::protocol::T_STRUCT, 4);
+ xfer += this->ase.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_launchExperiment_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ire.read(iprot);
+ this->__isset.ire = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->enf.read(iprot);
+ this->__isset.enf = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ace.read(iprot);
+ this->__isset.ace = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ase.read(iprot);
+ this->__isset.ase = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Airavata_getExperimentStatus_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_airavataExperimentId = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->airavataExperimentId);
+ isset_airavataExperimentId = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_airavataExperimentId)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t Airavata_getExperimentStatus_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Airavata_getExperimentStatus_args");
+
+ xfer += oprot->writeFieldBegin("airavataExperimentId", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->airavataExperimentId);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_getExperimentStatus_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Airavata_getExperimentStatus_pargs");
+
+ xfer += oprot->writeFieldBegin("airavataExperimentId", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString((*(this->airavataExperimentId)));
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_getExperimentStatus_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 0:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->success.read(iprot);
+ this->__isset.success = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ire.read(iprot);
+ this->__isset.ire = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->enf.read(iprot);
+ this->__isset.enf = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ace.read(iprot);
+ this->__isset.ace = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ase.read(iprot);
+ this->__isset.ase = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Airavata_getExperimentStatus_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+ uint32_t xfer = 0;
+
+ xfer += oprot->writeStructBegin("Airavata_getExperimentStatus_result");
+
+ if (this->__isset.success) {
+ xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0);
+ xfer += this->success.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.ire) {
+ xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->ire.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.enf) {
+ xfer += oprot->writeFieldBegin("enf", ::apache::thrift::protocol::T_STRUCT, 2);
+ xfer += this->enf.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.ace) {
+ xfer += oprot->writeFieldBegin("ace", ::apache::thrift::protocol::T_STRUCT, 3);
+ xfer += this->ace.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.ase) {
+ xfer += oprot->writeFieldBegin("ase", ::apache::thrift::protocol::T_STRUCT, 4);
+ xfer += this->ase.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_getExperimentStatus_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 0:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += (*(this->success)).read(iprot);
+ this->__isset.success = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ire.read(iprot);
+ this->__isset.ire = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->enf.read(iprot);
+ this->__isset.enf = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ace.read(iprot);
+ this->__isset.ace = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->ase.read(iprot);
+ this->__isset.ase = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Airavata_getExperimentOutputs_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t
<TRUNCATED>
[6/6] git commit: Generated C++ Client SDK - AIRAVATA-1075
Posted by sm...@apache.org.
Generated C++ Client SDK - AIRAVATA-1075
Project: http://git-wip-us.apache.org/repos/asf/airavata/repo
Commit: http://git-wip-us.apache.org/repos/asf/airavata/commit/77758cb9
Tree: http://git-wip-us.apache.org/repos/asf/airavata/tree/77758cb9
Diff: http://git-wip-us.apache.org/repos/asf/airavata/diff/77758cb9
Branch: refs/heads/master
Commit: 77758cb9f246d787393e02b6179ad0140f9db6c9
Parents: 576729b
Author: Suresh Marru <sm...@apache.org>
Authored: Wed Mar 12 14:01:42 2014 -0400
Committer: Suresh Marru <sm...@apache.org>
Committed: Wed Mar 12 14:01:42 2014 -0400
----------------------------------------------------------------------
.../airavata-cpp-sdk/README | 7 +
.../airavata-stubs/Airavata.cpp | 6268 ++++++++++++++++++
.../airavata-cpp-sdk/airavata-stubs/Airavata.h | 2714 ++++++++
.../airavata-stubs/Airavata_server.skeleton.cpp | 129 +
.../airavata-stubs/airavataAPI_constants.cpp | 19 +
.../airavata-stubs/airavataAPI_constants.h | 25 +
.../airavata-stubs/airavataAPI_types.cpp | 13 +
.../airavata-stubs/airavataAPI_types.h | 26 +
.../airavataDataModel_constants.cpp | 17 +
.../airavataDataModel_constants.h | 24 +
.../airavata-stubs/airavataDataModel_types.cpp | 13 +
.../airavata-stubs/airavataDataModel_types.h | 23 +
.../airavata-stubs/airavataErrors_constants.cpp | 17 +
.../airavata-stubs/airavataErrors_constants.h | 24 +
.../airavata-stubs/airavataErrors_types.cpp | 511 ++
.../airavata-stubs/airavataErrors_types.h | 341 +
.../experimentModel_constants.cpp | 23 +
.../airavata-stubs/experimentModel_constants.h | 27 +
.../airavata-stubs/experimentModel_types.cpp | 2867 ++++++++
.../airavata-stubs/experimentModel_types.h | 1801 +++++
.../airavata-stubs/workspaceModel_constants.cpp | 17 +
.../airavata-stubs/workspaceModel_constants.h | 24 +
.../airavata-stubs/workspaceModel_types.cpp | 464 ++
.../airavata-stubs/workspaceModel_types.h | 273 +
airavata-api/generate-thrift-files.sh | 39 +-
modules/gfac/gfac-core/README.txt | 1 -
26 files changed, 15699 insertions(+), 8 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/airavata/blob/77758cb9/airavata-api/airavata-client-sdks/airavata-cpp-sdk/README
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/README b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/README
new file mode 100644
index 0000000..e4a4864
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/README
@@ -0,0 +1,7 @@
+Apache Airavata Thrift C++ Software Development Kit.
+
+Prerequisites:
+Since C++ thrift libraries are platform dependent, we encourage you to compile apache thrift locally.
+
+Conveniance Binaries:
+Airavata will bundle conveniance binaries, but again we encourage to build from source.
\ No newline at end of file
[3/6] Generated C++ Client SDK - AIRAVATA-1075
Posted by sm...@apache.org.
http://git-wip-us.apache.org/repos/asf/airavata/blob/77758cb9/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/airavataAPI_types.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/airavataAPI_types.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/airavataAPI_types.cpp
new file mode 100644
index 0000000..00822cd
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/airavataAPI_types.cpp
@@ -0,0 +1,13 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+#include "airavataAPI_types.h"
+
+#include <algorithm>
+
+namespace airavata { namespace api {
+
+}} // namespace
http://git-wip-us.apache.org/repos/asf/airavata/blob/77758cb9/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/airavataAPI_types.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/airavataAPI_types.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/airavataAPI_types.h
new file mode 100644
index 0000000..3fab592
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/airavataAPI_types.h
@@ -0,0 +1,26 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+#ifndef airavataAPI_TYPES_H
+#define airavataAPI_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 "airavataErrors_types.h"
+#include "airavataDataModel_types.h"
+#include "experimentModel_types.h"
+#include "workspaceModel_types.h"
+
+
+namespace airavata { namespace api {
+
+}} // namespace
+
+#endif
http://git-wip-us.apache.org/repos/asf/airavata/blob/77758cb9/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/airavataDataModel_constants.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/airavataDataModel_constants.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/airavataDataModel_constants.cpp
new file mode 100644
index 0000000..934ab94
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/airavataDataModel_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 "airavataDataModel_constants.h"
+
+
+
+const airavataDataModelConstants g_airavataDataModel_constants;
+
+airavataDataModelConstants::airavataDataModelConstants() {
+}
+
+
+
http://git-wip-us.apache.org/repos/asf/airavata/blob/77758cb9/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/airavataDataModel_constants.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/airavataDataModel_constants.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/airavataDataModel_constants.h
new file mode 100644
index 0000000..e7de9f3
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/airavataDataModel_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 airavataDataModel_CONSTANTS_H
+#define airavataDataModel_CONSTANTS_H
+
+#include "airavataDataModel_types.h"
+
+
+
+class airavataDataModelConstants {
+ public:
+ airavataDataModelConstants();
+
+};
+
+extern const airavataDataModelConstants g_airavataDataModel_constants;
+
+
+
+#endif
http://git-wip-us.apache.org/repos/asf/airavata/blob/77758cb9/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/airavataDataModel_types.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/airavataDataModel_types.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/airavataDataModel_types.cpp
new file mode 100644
index 0000000..c9492d8
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/airavataDataModel_types.cpp
@@ -0,0 +1,13 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+#include "airavataDataModel_types.h"
+
+#include <algorithm>
+
+
+
+
http://git-wip-us.apache.org/repos/asf/airavata/blob/77758cb9/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/airavataDataModel_types.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/airavataDataModel_types.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/airavataDataModel_types.h
new file mode 100644
index 0000000..addaf4b
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/airavataDataModel_types.h
@@ -0,0 +1,23 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+#ifndef airavataDataModel_TYPES_H
+#define airavataDataModel_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 "workspaceModel_types.h"
+
+
+
+
+
+
+#endif
http://git-wip-us.apache.org/repos/asf/airavata/blob/77758cb9/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/airavataErrors_constants.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/airavataErrors_constants.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/airavataErrors_constants.cpp
new file mode 100644
index 0000000..be2d0cb
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/airavataErrors_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 "airavataErrors_constants.h"
+
+namespace airavata { namespace api { namespace error {
+
+const airavataErrorsConstants g_airavataErrors_constants;
+
+airavataErrorsConstants::airavataErrorsConstants() {
+}
+
+}}} // namespace
+
http://git-wip-us.apache.org/repos/asf/airavata/blob/77758cb9/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/airavataErrors_constants.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/airavataErrors_constants.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/airavataErrors_constants.h
new file mode 100644
index 0000000..b9823c0
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/airavataErrors_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 airavataErrors_CONSTANTS_H
+#define airavataErrors_CONSTANTS_H
+
+#include "airavataErrors_types.h"
+
+namespace airavata { namespace api { namespace error {
+
+class airavataErrorsConstants {
+ public:
+ airavataErrorsConstants();
+
+};
+
+extern const airavataErrorsConstants g_airavataErrors_constants;
+
+}}} // namespace
+
+#endif
http://git-wip-us.apache.org/repos/asf/airavata/blob/77758cb9/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/airavataErrors_types.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/airavataErrors_types.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/airavataErrors_types.cpp
new file mode 100644
index 0000000..e52eab2
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/airavataErrors_types.cpp
@@ -0,0 +1,511 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+#include "airavataErrors_types.h"
+
+#include <algorithm>
+
+namespace airavata { namespace api { namespace error {
+
+int _kAiravataErrorTypeValues[] = {
+ AiravataErrorType::UNKNOWN,
+ AiravataErrorType::PERMISSION_DENIED,
+ AiravataErrorType::INTERNAL_ERROR,
+ AiravataErrorType::AUTHENTICATION_FAILURE,
+ AiravataErrorType::INVALID_AUTHORIZATION,
+ AiravataErrorType::AUTHORIZATION_EXPIRED,
+ AiravataErrorType::UNKNOWN_GATEWAY_ID,
+ AiravataErrorType::UNSUPPORTED_OPERATION
+};
+const char* _kAiravataErrorTypeNames[] = {
+ "UNKNOWN",
+ "PERMISSION_DENIED",
+ "INTERNAL_ERROR",
+ "AUTHENTICATION_FAILURE",
+ "INVALID_AUTHORIZATION",
+ "AUTHORIZATION_EXPIRED",
+ "UNKNOWN_GATEWAY_ID",
+ "UNSUPPORTED_OPERATION"
+};
+const std::map<int, const char*> _AiravataErrorType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(8, _kAiravataErrorTypeValues, _kAiravataErrorTypeNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
+
+const char* ExperimentNotFoundException::ascii_fingerprint = "D0297FC5011701BD87898CC36146A565";
+const uint8_t ExperimentNotFoundException::binary_fingerprint[16] = {0xD0,0x29,0x7F,0xC5,0x01,0x17,0x01,0xBD,0x87,0x89,0x8C,0xC3,0x61,0x46,0xA5,0x65};
+
+uint32_t ExperimentNotFoundException::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->identifier);
+ this->__isset.identifier = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->key);
+ this->__isset.key = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t ExperimentNotFoundException::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ExperimentNotFoundException");
+
+ if (this->__isset.identifier) {
+ xfer += oprot->writeFieldBegin("identifier", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->identifier);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.key) {
+ xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->key);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(ExperimentNotFoundException &a, ExperimentNotFoundException &b) {
+ using ::std::swap;
+ swap(a.identifier, b.identifier);
+ swap(a.key, b.key);
+ swap(a.__isset, b.__isset);
+}
+
+const char* InvalidRequestException::ascii_fingerprint = "EFB929595D312AC8F305D5A794CFEDA1";
+const uint8_t InvalidRequestException::binary_fingerprint[16] = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
+
+uint32_t InvalidRequestException::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_message = 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->message);
+ isset_message = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_message)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t InvalidRequestException::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("InvalidRequestException");
+
+ xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->message);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(InvalidRequestException &a, InvalidRequestException &b) {
+ using ::std::swap;
+ swap(a.message, b.message);
+}
+
+const char* TimedOutException::ascii_fingerprint = "99914B932BD37A50B983C5E7C90AE93B";
+const uint8_t TimedOutException::binary_fingerprint[16] = {0x99,0x91,0x4B,0x93,0x2B,0xD3,0x7A,0x50,0xB9,0x83,0xC5,0xE7,0xC9,0x0A,0xE9,0x3B};
+
+uint32_t TimedOutException::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ xfer += iprot->skip(ftype);
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t TimedOutException::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("TimedOutException");
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(TimedOutException &a, TimedOutException &b) {
+ using ::std::swap;
+ (void) a;
+ (void) b;
+}
+
+const char* AuthenticationException::ascii_fingerprint = "EFB929595D312AC8F305D5A794CFEDA1";
+const uint8_t AuthenticationException::binary_fingerprint[16] = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
+
+uint32_t AuthenticationException::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_message = 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->message);
+ isset_message = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_message)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t AuthenticationException::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("AuthenticationException");
+
+ xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->message);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(AuthenticationException &a, AuthenticationException &b) {
+ using ::std::swap;
+ swap(a.message, b.message);
+}
+
+const char* AuthorizationException::ascii_fingerprint = "EFB929595D312AC8F305D5A794CFEDA1";
+const uint8_t AuthorizationException::binary_fingerprint[16] = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
+
+uint32_t AuthorizationException::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_message = 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->message);
+ isset_message = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_message)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t AuthorizationException::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("AuthorizationException");
+
+ xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->message);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(AuthorizationException &a, AuthorizationException &b) {
+ using ::std::swap;
+ swap(a.message, b.message);
+}
+
+const char* AiravataClientException::ascii_fingerprint = "24652790C81ECE22B629CB60A19F1E93";
+const uint8_t AiravataClientException::binary_fingerprint[16] = {0x24,0x65,0x27,0x90,0xC8,0x1E,0xCE,0x22,0xB6,0x29,0xCB,0x60,0xA1,0x9F,0x1E,0x93};
+
+uint32_t AiravataClientException::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_airavataErrorType = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ int32_t ecast0;
+ xfer += iprot->readI32(ecast0);
+ this->airavataErrorType = (AiravataErrorType::type)ecast0;
+ isset_airavataErrorType = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->parameter);
+ this->__isset.parameter = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_airavataErrorType)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t AiravataClientException::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("AiravataClientException");
+
+ xfer += oprot->writeFieldBegin("airavataErrorType", ::apache::thrift::protocol::T_I32, 1);
+ xfer += oprot->writeI32((int32_t)this->airavataErrorType);
+ xfer += oprot->writeFieldEnd();
+
+ if (this->__isset.parameter) {
+ xfer += oprot->writeFieldBegin("parameter", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->parameter);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(AiravataClientException &a, AiravataClientException &b) {
+ using ::std::swap;
+ swap(a.airavataErrorType, b.airavataErrorType);
+ swap(a.parameter, b.parameter);
+ swap(a.__isset, b.__isset);
+}
+
+const char* AiravataSystemException::ascii_fingerprint = "24652790C81ECE22B629CB60A19F1E93";
+const uint8_t AiravataSystemException::binary_fingerprint[16] = {0x24,0x65,0x27,0x90,0xC8,0x1E,0xCE,0x22,0xB6,0x29,0xCB,0x60,0xA1,0x9F,0x1E,0x93};
+
+uint32_t AiravataSystemException::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_airavataErrorType = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ int32_t ecast1;
+ xfer += iprot->readI32(ecast1);
+ this->airavataErrorType = (AiravataErrorType::type)ecast1;
+ isset_airavataErrorType = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->message);
+ this->__isset.message = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_airavataErrorType)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t AiravataSystemException::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("AiravataSystemException");
+
+ xfer += oprot->writeFieldBegin("airavataErrorType", ::apache::thrift::protocol::T_I32, 1);
+ xfer += oprot->writeI32((int32_t)this->airavataErrorType);
+ xfer += oprot->writeFieldEnd();
+
+ if (this->__isset.message) {
+ xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->message);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(AiravataSystemException &a, AiravataSystemException &b) {
+ using ::std::swap;
+ swap(a.airavataErrorType, b.airavataErrorType);
+ swap(a.message, b.message);
+ swap(a.__isset, b.__isset);
+}
+
+}}} // namespace
http://git-wip-us.apache.org/repos/asf/airavata/blob/77758cb9/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/airavataErrors_types.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/airavataErrors_types.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/airavataErrors_types.h
new file mode 100644
index 0000000..877051e
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/airavataErrors_types.h
@@ -0,0 +1,341 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+#ifndef airavataErrors_TYPES_H
+#define airavataErrors_TYPES_H
+
+#include <thrift/Thrift.h>
+#include <thrift/TApplicationException.h>
+#include <thrift/protocol/TProtocol.h>
+#include <thrift/transport/TTransport.h>
+
+#include <thrift/cxxfunctional.h>
+
+
+namespace airavata { namespace api { namespace error {
+
+struct AiravataErrorType {
+ enum type {
+ UNKNOWN = 0,
+ PERMISSION_DENIED = 1,
+ INTERNAL_ERROR = 2,
+ AUTHENTICATION_FAILURE = 3,
+ INVALID_AUTHORIZATION = 4,
+ AUTHORIZATION_EXPIRED = 5,
+ UNKNOWN_GATEWAY_ID = 6,
+ UNSUPPORTED_OPERATION = 7
+ };
+};
+
+extern const std::map<int, const char*> _AiravataErrorType_VALUES_TO_NAMES;
+
+typedef struct _ExperimentNotFoundException__isset {
+ _ExperimentNotFoundException__isset() : identifier(false), key(false) {}
+ bool identifier;
+ bool key;
+} _ExperimentNotFoundException__isset;
+
+class ExperimentNotFoundException : public ::apache::thrift::TException {
+ public:
+
+ static const char* ascii_fingerprint; // = "D0297FC5011701BD87898CC36146A565";
+ static const uint8_t binary_fingerprint[16]; // = {0xD0,0x29,0x7F,0xC5,0x01,0x17,0x01,0xBD,0x87,0x89,0x8C,0xC3,0x61,0x46,0xA5,0x65};
+
+ ExperimentNotFoundException() : identifier(), key() {
+ }
+
+ virtual ~ExperimentNotFoundException() throw() {}
+
+ std::string identifier;
+ std::string key;
+
+ _ExperimentNotFoundException__isset __isset;
+
+ void __set_identifier(const std::string& val) {
+ identifier = val;
+ __isset.identifier = true;
+ }
+
+ void __set_key(const std::string& val) {
+ key = val;
+ __isset.key = true;
+ }
+
+ bool operator == (const ExperimentNotFoundException & rhs) const
+ {
+ if (__isset.identifier != rhs.__isset.identifier)
+ return false;
+ else if (__isset.identifier && !(identifier == rhs.identifier))
+ return false;
+ if (__isset.key != rhs.__isset.key)
+ return false;
+ else if (__isset.key && !(key == rhs.key))
+ return false;
+ return true;
+ }
+ bool operator != (const ExperimentNotFoundException &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ExperimentNotFoundException & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(ExperimentNotFoundException &a, ExperimentNotFoundException &b);
+
+
+class InvalidRequestException : public ::apache::thrift::TException {
+ public:
+
+ static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1";
+ static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
+
+ InvalidRequestException() : message() {
+ }
+
+ virtual ~InvalidRequestException() throw() {}
+
+ std::string message;
+
+ void __set_message(const std::string& val) {
+ message = val;
+ }
+
+ bool operator == (const InvalidRequestException & rhs) const
+ {
+ if (!(message == rhs.message))
+ return false;
+ return true;
+ }
+ bool operator != (const InvalidRequestException &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const InvalidRequestException & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(InvalidRequestException &a, InvalidRequestException &b);
+
+
+class TimedOutException : public ::apache::thrift::TException {
+ public:
+
+ static const char* ascii_fingerprint; // = "99914B932BD37A50B983C5E7C90AE93B";
+ static const uint8_t binary_fingerprint[16]; // = {0x99,0x91,0x4B,0x93,0x2B,0xD3,0x7A,0x50,0xB9,0x83,0xC5,0xE7,0xC9,0x0A,0xE9,0x3B};
+
+ TimedOutException() {
+ }
+
+ virtual ~TimedOutException() throw() {}
+
+
+ bool operator == (const TimedOutException & /* rhs */) const
+ {
+ return true;
+ }
+ bool operator != (const TimedOutException &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const TimedOutException & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(TimedOutException &a, TimedOutException &b);
+
+
+class AuthenticationException : public ::apache::thrift::TException {
+ public:
+
+ static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1";
+ static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
+
+ AuthenticationException() : message() {
+ }
+
+ virtual ~AuthenticationException() throw() {}
+
+ std::string message;
+
+ void __set_message(const std::string& val) {
+ message = val;
+ }
+
+ bool operator == (const AuthenticationException & rhs) const
+ {
+ if (!(message == rhs.message))
+ return false;
+ return true;
+ }
+ bool operator != (const AuthenticationException &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const AuthenticationException & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(AuthenticationException &a, AuthenticationException &b);
+
+
+class AuthorizationException : public ::apache::thrift::TException {
+ public:
+
+ static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1";
+ static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
+
+ AuthorizationException() : message() {
+ }
+
+ virtual ~AuthorizationException() throw() {}
+
+ std::string message;
+
+ void __set_message(const std::string& val) {
+ message = val;
+ }
+
+ bool operator == (const AuthorizationException & rhs) const
+ {
+ if (!(message == rhs.message))
+ return false;
+ return true;
+ }
+ bool operator != (const AuthorizationException &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const AuthorizationException & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(AuthorizationException &a, AuthorizationException &b);
+
+typedef struct _AiravataClientException__isset {
+ _AiravataClientException__isset() : parameter(false) {}
+ bool parameter;
+} _AiravataClientException__isset;
+
+class AiravataClientException : public ::apache::thrift::TException {
+ public:
+
+ static const char* ascii_fingerprint; // = "24652790C81ECE22B629CB60A19F1E93";
+ static const uint8_t binary_fingerprint[16]; // = {0x24,0x65,0x27,0x90,0xC8,0x1E,0xCE,0x22,0xB6,0x29,0xCB,0x60,0xA1,0x9F,0x1E,0x93};
+
+ AiravataClientException() : airavataErrorType((AiravataErrorType::type)0), parameter() {
+ }
+
+ virtual ~AiravataClientException() throw() {}
+
+ AiravataErrorType::type airavataErrorType;
+ std::string parameter;
+
+ _AiravataClientException__isset __isset;
+
+ void __set_airavataErrorType(const AiravataErrorType::type val) {
+ airavataErrorType = val;
+ }
+
+ void __set_parameter(const std::string& val) {
+ parameter = val;
+ __isset.parameter = true;
+ }
+
+ bool operator == (const AiravataClientException & rhs) const
+ {
+ if (!(airavataErrorType == rhs.airavataErrorType))
+ return false;
+ if (__isset.parameter != rhs.__isset.parameter)
+ return false;
+ else if (__isset.parameter && !(parameter == rhs.parameter))
+ return false;
+ return true;
+ }
+ bool operator != (const AiravataClientException &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const AiravataClientException & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(AiravataClientException &a, AiravataClientException &b);
+
+typedef struct _AiravataSystemException__isset {
+ _AiravataSystemException__isset() : message(false) {}
+ bool message;
+} _AiravataSystemException__isset;
+
+class AiravataSystemException : public ::apache::thrift::TException {
+ public:
+
+ static const char* ascii_fingerprint; // = "24652790C81ECE22B629CB60A19F1E93";
+ static const uint8_t binary_fingerprint[16]; // = {0x24,0x65,0x27,0x90,0xC8,0x1E,0xCE,0x22,0xB6,0x29,0xCB,0x60,0xA1,0x9F,0x1E,0x93};
+
+ AiravataSystemException() : airavataErrorType((AiravataErrorType::type)0), message() {
+ }
+
+ virtual ~AiravataSystemException() throw() {}
+
+ AiravataErrorType::type airavataErrorType;
+ std::string message;
+
+ _AiravataSystemException__isset __isset;
+
+ void __set_airavataErrorType(const AiravataErrorType::type val) {
+ airavataErrorType = val;
+ }
+
+ void __set_message(const std::string& val) {
+ message = val;
+ __isset.message = true;
+ }
+
+ bool operator == (const AiravataSystemException & rhs) const
+ {
+ if (!(airavataErrorType == rhs.airavataErrorType))
+ return false;
+ if (__isset.message != rhs.__isset.message)
+ return false;
+ else if (__isset.message && !(message == rhs.message))
+ return false;
+ return true;
+ }
+ bool operator != (const AiravataSystemException &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const AiravataSystemException & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(AiravataSystemException &a, AiravataSystemException &b);
+
+}}} // namespace
+
+#endif
http://git-wip-us.apache.org/repos/asf/airavata/blob/77758cb9/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/experimentModel_constants.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/experimentModel_constants.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/experimentModel_constants.cpp
new file mode 100644
index 0000000..9f94244
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/experimentModel_constants.cpp
@@ -0,0 +1,23 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+#include "experimentModel_constants.h"
+
+
+
+const experimentModelConstants g_experimentModel_constants;
+
+experimentModelConstants::experimentModelConstants() {
+ DEFAULT_ID = "DO_NOT_SET_AT_CLIENTS";
+
+ DEFAULT_PROJECT_NAME = "DEFAULT";
+
+ SINGLE_APP_NODE_NAME = "SINGLE_APP_NODE";
+
+}
+
+
+
http://git-wip-us.apache.org/repos/asf/airavata/blob/77758cb9/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/experimentModel_constants.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/experimentModel_constants.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/experimentModel_constants.h
new file mode 100644
index 0000000..7525cc7
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/airavata-stubs/experimentModel_constants.h
@@ -0,0 +1,27 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+#ifndef experimentModel_CONSTANTS_H
+#define experimentModel_CONSTANTS_H
+
+#include "experimentModel_types.h"
+
+
+
+class experimentModelConstants {
+ public:
+ experimentModelConstants();
+
+ std::string DEFAULT_ID;
+ std::string DEFAULT_PROJECT_NAME;
+ std::string SINGLE_APP_NODE_NAME;
+};
+
+extern const experimentModelConstants g_experimentModel_constants;
+
+
+
+#endif