http://git-wip-us.apache.org/repos/asf/airavata/blob/ddb95c12/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/Airavata.cpp ---------------------------------------------------------------------- diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/Airavata.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/Airavata.cpp index de65cd0..9e1f1da 100644 --- a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/Airavata.cpp +++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/Airavata.cpp @@ -52869,19 +52869,2455 @@ uint32_t Airavata_getAllGroupsUserBelongs_presult::read(::apache::thrift::protoc return xfer; } + +Airavata_addUserProfile_args::~Airavata_addUserProfile_args() throw() { +} + + +uint32_t Airavata_addUserProfile_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*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_authzToken = false; + bool isset_userProfile = 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->authzToken.read(iprot); + isset_authzToken = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->userProfile.read(iprot); + isset_userProfile = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_authzToken) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_userProfile) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t Airavata_addUserProfile_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Airavata_addUserProfile_args"); + + xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->authzToken.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("userProfile", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->userProfile.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +Airavata_addUserProfile_pargs::~Airavata_addUserProfile_pargs() throw() { +} + + +uint32_t Airavata_addUserProfile_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Airavata_addUserProfile_pargs"); + + xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->authzToken)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("userProfile", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += (*(this->userProfile)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +Airavata_addUserProfile_result::~Airavata_addUserProfile_result() throw() { +} + + +uint32_t Airavata_addUserProfile_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*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; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ae.read(iprot); + this->__isset.ae = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t Airavata_addUserProfile_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("Airavata_addUserProfile_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(); + } else if (this->__isset.ae) { + xfer += oprot->writeFieldBegin("ae", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->ae.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +Airavata_addUserProfile_presult::~Airavata_addUserProfile_presult() throw() { +} + + +uint32_t Airavata_addUserProfile_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*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; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ae.read(iprot); + this->__isset.ae = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +Airavata_updateUserProfile_args::~Airavata_updateUserProfile_args() throw() { +} + + +uint32_t Airavata_updateUserProfile_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*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_authzToken = false; + bool isset_userProfile = 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->authzToken.read(iprot); + isset_authzToken = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->userProfile.read(iprot); + isset_userProfile = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_authzToken) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_userProfile) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t Airavata_updateUserProfile_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Airavata_updateUserProfile_args"); + + xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->authzToken.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("userProfile", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->userProfile.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +Airavata_updateUserProfile_pargs::~Airavata_updateUserProfile_pargs() throw() { +} + + +uint32_t Airavata_updateUserProfile_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Airavata_updateUserProfile_pargs"); + + xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->authzToken)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("userProfile", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += (*(this->userProfile)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +Airavata_updateUserProfile_result::~Airavata_updateUserProfile_result() throw() { +} + + +uint32_t Airavata_updateUserProfile_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ire.read(iprot); + this->__isset.ire = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ace.read(iprot); + this->__isset.ace = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ase.read(iprot); + this->__isset.ase = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ae.read(iprot); + this->__isset.ae = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t Airavata_updateUserProfile_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("Airavata_updateUserProfile_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0); + xfer += oprot->writeBool(this->success); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.ire) { + xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->ire.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.ace) { + xfer += oprot->writeFieldBegin("ace", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->ace.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.ase) { + xfer += oprot->writeFieldBegin("ase", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->ase.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.ae) { + xfer += oprot->writeFieldBegin("ae", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->ae.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +Airavata_updateUserProfile_presult::~Airavata_updateUserProfile_presult() throw() { +} + + +uint32_t Airavata_updateUserProfile_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ire.read(iprot); + this->__isset.ire = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ace.read(iprot); + this->__isset.ace = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ase.read(iprot); + this->__isset.ase = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ae.read(iprot); + this->__isset.ae = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +Airavata_getUserProfileById_args::~Airavata_getUserProfileById_args() throw() { +} + + +uint32_t Airavata_getUserProfileById_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*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_authzToken = false; + bool isset_userId = false; + bool isset_gatewayId = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->authzToken.read(iprot); + isset_authzToken = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->userId); + isset_userId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->gatewayId); + isset_gatewayId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_authzToken) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_userId) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_gatewayId) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t Airavata_getUserProfileById_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Airavata_getUserProfileById_args"); + + xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->authzToken.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("userId", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->userId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("gatewayId", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->gatewayId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +Airavata_getUserProfileById_pargs::~Airavata_getUserProfileById_pargs() throw() { +} + + +uint32_t Airavata_getUserProfileById_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Airavata_getUserProfileById_pargs"); + + xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->authzToken)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("userId", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->userId))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("gatewayId", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString((*(this->gatewayId))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +Airavata_getUserProfileById_result::~Airavata_getUserProfileById_result() throw() { +} + + +uint32_t Airavata_getUserProfileById_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*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; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ae.read(iprot); + this->__isset.ae = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t Airavata_getUserProfileById_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("Airavata_getUserProfileById_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(); + } else if (this->__isset.ae) { + xfer += oprot->writeFieldBegin("ae", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->ae.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +Airavata_getUserProfileById_presult::~Airavata_getUserProfileById_presult() throw() { +} + + +uint32_t Airavata_getUserProfileById_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*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; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ae.read(iprot); + this->__isset.ae = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +Airavata_deleteUserProfile_args::~Airavata_deleteUserProfile_args() throw() { +} + + +uint32_t Airavata_deleteUserProfile_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*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_authzToken = false; + bool isset_userId = 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->authzToken.read(iprot); + isset_authzToken = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->userId); + isset_userId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_authzToken) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_userId) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t Airavata_deleteUserProfile_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Airavata_deleteUserProfile_args"); + + xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->authzToken.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("userId", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->userId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +Airavata_deleteUserProfile_pargs::~Airavata_deleteUserProfile_pargs() throw() { +} + + +uint32_t Airavata_deleteUserProfile_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Airavata_deleteUserProfile_pargs"); + + xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->authzToken)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("userId", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->userId))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +Airavata_deleteUserProfile_result::~Airavata_deleteUserProfile_result() throw() { +} + + +uint32_t Airavata_deleteUserProfile_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ire.read(iprot); + this->__isset.ire = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ace.read(iprot); + this->__isset.ace = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ase.read(iprot); + this->__isset.ase = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ae.read(iprot); + this->__isset.ae = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t Airavata_deleteUserProfile_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("Airavata_deleteUserProfile_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0); + xfer += oprot->writeBool(this->success); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.ire) { + xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->ire.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.ace) { + xfer += oprot->writeFieldBegin("ace", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->ace.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.ase) { + xfer += oprot->writeFieldBegin("ase", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->ase.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.ae) { + xfer += oprot->writeFieldBegin("ae", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->ae.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +Airavata_deleteUserProfile_presult::~Airavata_deleteUserProfile_presult() throw() { +} + + +uint32_t Airavata_deleteUserProfile_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ire.read(iprot); + this->__isset.ire = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ace.read(iprot); + this->__isset.ace = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ase.read(iprot); + this->__isset.ase = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ae.read(iprot); + this->__isset.ae = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +Airavata_getAllUserProfilesInGateway_args::~Airavata_getAllUserProfilesInGateway_args() throw() { +} + + +uint32_t Airavata_getAllUserProfilesInGateway_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*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_authzToken = false; + bool isset_gatewayId = false; + bool isset_offset = false; + bool isset_limit = 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->authzToken.read(iprot); + isset_authzToken = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->gatewayId); + isset_gatewayId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->offset); + isset_offset = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->limit); + isset_limit = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_authzToken) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_gatewayId) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_offset) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_limit) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t Airavata_getAllUserProfilesInGateway_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Airavata_getAllUserProfilesInGateway_args"); + + xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->authzToken.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("gatewayId", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->gatewayId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("offset", ::apache::thrift::protocol::T_I32, 3); + xfer += oprot->writeI32(this->offset); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("limit", ::apache::thrift::protocol::T_I32, 4); + xfer += oprot->writeI32(this->limit); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +Airavata_getAllUserProfilesInGateway_pargs::~Airavata_getAllUserProfilesInGateway_pargs() throw() { +} + + +uint32_t Airavata_getAllUserProfilesInGateway_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Airavata_getAllUserProfilesInGateway_pargs"); + + xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->authzToken)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("gatewayId", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->gatewayId))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("offset", ::apache::thrift::protocol::T_I32, 3); + xfer += oprot->writeI32((*(this->offset))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("limit", ::apache::thrift::protocol::T_I32, 4); + xfer += oprot->writeI32((*(this->limit))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +Airavata_getAllUserProfilesInGateway_result::~Airavata_getAllUserProfilesInGateway_result() throw() { +} + + +uint32_t Airavata_getAllUserProfilesInGateway_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*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 _size505; + ::apache::thrift::protocol::TType _etype508; + xfer += iprot->readListBegin(_etype508, _size505); + this->success.resize(_size505); + uint32_t _i509; + for (_i509 = 0; _i509 < _size505; ++_i509) + { + xfer += this->success[_i509].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; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ae.read(iprot); + this->__isset.ae = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t Airavata_getAllUserProfilesInGateway_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("Airavata_getAllUserProfilesInGateway_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< ::apache::airavata::model::user::UserProfile> ::const_iterator _iter510; + for (_iter510 = this->success.begin(); _iter510 != this->success.end(); ++_iter510) + { + xfer += (*_iter510).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(); + } else if (this->__isset.ae) { + xfer += oprot->writeFieldBegin("ae", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->ae.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +Airavata_getAllUserProfilesInGateway_presult::~Airavata_getAllUserProfilesInGateway_presult() throw() { +} + + +uint32_t Airavata_getAllUserProfilesInGateway_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*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 _size511; + ::apache::thrift::protocol::TType _etype514; + xfer += iprot->readListBegin(_etype514, _size511); + (*(this->success)).resize(_size511); + uint32_t _i515; + for (_i515 = 0; _i515 < _size511; ++_i515) + { + xfer += (*(this->success))[_i515].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; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ae.read(iprot); + this->__isset.ae = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +Airavata_getUserProfileByName_args::~Airavata_getUserProfileByName_args() throw() { +} + + +uint32_t Airavata_getUserProfileByName_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*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_authzToken = false; + bool isset_userName = false; + bool isset_gatewayId = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->authzToken.read(iprot); + isset_authzToken = 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; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->gatewayId); + isset_gatewayId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_authzToken) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_userName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_gatewayId) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t Airavata_getUserProfileByName_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Airavata_getUserProfileByName_args"); + + xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->authzToken.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->writeFieldBegin("gatewayId", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->gatewayId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +Airavata_getUserProfileByName_pargs::~Airavata_getUserProfileByName_pargs() throw() { +} + + +uint32_t Airavata_getUserProfileByName_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Airavata_getUserProfileByName_pargs"); + + xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->authzToken)).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->writeFieldBegin("gatewayId", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString((*(this->gatewayId))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +Airavata_getUserProfileByName_result::~Airavata_getUserProfileByName_result() throw() { +} + + +uint32_t Airavata_getUserProfileByName_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*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; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ae.read(iprot); + this->__isset.ae = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t Airavata_getUserProfileByName_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("Airavata_getUserProfileByName_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(); + } else if (this->__isset.ae) { + xfer += oprot->writeFieldBegin("ae", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->ae.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +Airavata_getUserProfileByName_presult::~Airavata_getUserProfileByName_presult() throw() { +} + + +uint32_t Airavata_getUserProfileByName_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*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; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ae.read(iprot); + this->__isset.ae = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +Airavata_doesUserProfileExist_args::~Airavata_doesUserProfileExist_args() throw() { +} + + +uint32_t Airavata_doesUserProfileExist_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*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_authzToken = false; + bool isset_userName = false; + bool isset_gatewayId = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->authzToken.read(iprot); + isset_authzToken = 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; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->gatewayId); + isset_gatewayId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_authzToken) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_userName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_gatewayId) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t Airavata_doesUserProfileExist_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Airavata_doesUserProfileExist_args"); + + xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->authzToken.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->writeFieldBegin("gatewayId", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->gatewayId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +Airavata_doesUserProfileExist_pargs::~Airavata_doesUserProfileExist_pargs() throw() { +} + + +uint32_t Airavata_doesUserProfileExist_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Airavata_doesUserProfileExist_pargs"); + + xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->authzToken)).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->writeFieldBegin("gatewayId", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString((*(this->gatewayId))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +Airavata_doesUserProfileExist_result::~Airavata_doesUserProfileExist_result() throw() { +} + + +uint32_t Airavata_doesUserProfileExist_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ire.read(iprot); + this->__isset.ire = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ace.read(iprot); + this->__isset.ace = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ase.read(iprot); + this->__isset.ase = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ae.read(iprot); + this->__isset.ae = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t Airavata_doesUserProfileExist_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("Airavata_doesUserProfileExist_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0); + xfer += oprot->writeBool(this->success); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.ire) { + xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->ire.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.ace) { + xfer += oprot->writeFieldBegin("ace", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->ace.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.ase) { + xfer += oprot->writeFieldBegin("ase", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->ase.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.ae) { + xfer += oprot->writeFieldBegin("ae", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->ae.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +Airavata_doesUserProfileExist_presult::~Airavata_doesUserProfileExist_presult() throw() { +} + + +uint32_t Airavata_doesUserProfileExist_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ire.read(iprot); + this->__isset.ire = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ace.read(iprot); + this->__isset.ace = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ase.read(iprot); + this->__isset.ase = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ae.read(iprot); + this->__isset.ae = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + void AiravataClient::getAPIVersion(std::string& _return, const ::apache::airavata::model::security::AuthzToken& authzToken) { - send_getAPIVersion(authzToken); - recv_getAPIVersion(_return); + send_getAPIVersion(authzToken); + recv_getAPIVersion(_return); +} + +void AiravataClient::send_getAPIVersion(const ::apache::airavata::model::security::AuthzToken& authzToken) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("getAPIVersion", ::apache::thrift::protocol::T_CALL, cseqid); + + Airavata_getAPIVersion_pargs args; + args.authzToken = &authzToken; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void AiravataClient::recv_getAPIVersion(std::string& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("getAPIVersion") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + Airavata_getAPIVersion_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.ire) { + throw result.ire; + } + if (result.__isset.ace) { + throw result.ace; + } + if (result.__isset.ase) { + throw result.ase; + } + if (result.__isset.ae) { + throw result.ae; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getAPIVersion failed: unknown result"); +} + +bool AiravataClient::isUserExists(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId, const std::string& userName) +{ + send_isUserExists(authzToken, gatewayId, userName); + return recv_isUserExists(); +} + +void AiravataClient::send_isUserExists(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId, const std::string& userName) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("isUserExists", ::apache::thrift::protocol::T_CALL, cseqid); + + Airavata_isUserExists_pargs args; + args.authzToken = &authzToken; + args.gatewayId = &gatewayId; + args.userName = &userName; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +bool AiravataClient::recv_isUserExists() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("isUserExists") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + bool _return; + Airavata_isUserExists_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + return _return; + } + if (result.__isset.ire) { + throw result.ire; + } + if (result.__isset.ace) { + throw result.ace; + } + if (result.__isset.ase) { + throw result.ase; + } + if (result.__isset.ae) { + throw result.ae; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "isUserExists failed: unknown result"); +} + +void AiravataClient::addGateway(std::string& _return, const ::apache::airavata::model::security::AuthzToken& authzToken, const ::apache::airavata::model::workspace::Gateway& gateway) +{ + send_addGateway(authzToken, gateway); + recv_addGateway(_return); +} + +void AiravataClient::send_addGateway(const ::apache::airavata::model::security::AuthzToken& authzToken, const ::apache::airavata::model::workspace::Gateway& gateway) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("addGateway", ::apache::thrift::protocol::T_CALL, cseqid); + + Airavata_addGateway_pargs args; + args.authzToken = &authzToken; + args.gateway = &gateway; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void AiravataClient::recv_addGateway(std::string& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("addGateway") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + Airavata_addGateway_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.ire) { + throw result.ire; + } + if (result.__isset.ace) { + throw result.ace; + } + if (result.__isset.ase) { + throw result.ase; + } + if (result.__isset.ae) { + throw result.ae; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "addGateway failed: unknown result"); +} + +void AiravataClient::getAllUsersInGateway(std::vector<std::string> & _return, const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId) +{ + send_getAllUsersInGateway(authzToken, gatewayId); + recv_getAllUsersInGateway(_return); +} + +void AiravataClient::send_getAllUsersInGateway(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("getAllUsersInGateway", ::apache::thrift::protocol::T_CALL, cseqid); + + Airavata_getAllUsersInGateway_pargs args; + args.authzToken = &authzToken; + args.gatewayId = &gatewayId; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void AiravataClient::recv_getAllUsersInGateway(std::vector<std::string> & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("getAllUsersInGateway") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + Airavata_getAllUsersInGateway_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.ire) { + throw result.ire; + } + if (result.__isset.ace) { + throw result.ace; + } + if (result.__isset.ase) { + throw result.ase; + } + if (result.__isset.ae) { + throw result.ae; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getAllUsersInGateway failed: unknown result"); +} + +bool AiravataClient::updateGateway(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId, const ::apache::airavata::model::workspace::Gateway& updatedGateway) +{ + send_updateGateway(authzToken, gatewayId, updatedGateway); + return recv_updateGateway(); } -void AiravataClient::send_getAPIVersion(const ::apache::airavata::model::security::AuthzToken& authzToken) +void AiravataClient::send_updateGateway(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId, const ::apache::airavata::model::workspace::Gateway& updatedGateway) { int32_t cseqid = 0; - oprot_->writeMessageBegin("getAPIVersion", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("updateGateway", ::apache::thrift::protocol::T_CALL, cseqid); - Airavata_getAPIVersion_pargs args; + Airavata_updateGateway_pargs args; args.authzToken = &authzToken; + args.gatewayId = &gatewayId; + args.updatedGateway = &updatedGateway; args.write(oprot_); oprot_->writeMessageEnd(); @@ -52889,7 +55325,7 @@ void AiravataClient::send_getAPIVersion(const ::apache::airavata::model::securi oprot_->getTransport()->flush(); } -void AiravataClient::recv_getAPIVersion(std::string& _return) +bool AiravataClient::recv_updateGateway() { int32_t rseqid = 0; @@ -52909,12 +55345,83 @@ void AiravataClient::recv_getAPIVersion(std::string& _return) iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("getAPIVersion") != 0) { + if (fname.compare("updateGateway") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - Airavata_getAPIVersion_presult result; + bool _return; + Airavata_updateGateway_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + return _return; + } + if (result.__isset.ire) { + throw result.ire; + } + if (result.__isset.ace) { + throw result.ace; + } + if (result.__isset.ase) { + throw result.ase; + } + if (result.__isset.ae) { + throw result.ae; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "updateGateway failed: unknown result"); +} + +void AiravataClient::getGateway( ::apache::airavata::model::workspace::Gateway& _return, const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId) +{ + send_getGateway(authzToken, gatewayId); + recv_getGateway(_return); +} + +void AiravataClient::send_getGateway(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("getGateway", ::apache::thrift::protocol::T_CALL, cseqid); + + Airavata_getGateway_pargs args; + args.authzToken = &authzToken; + args.gatewayId = &gatewayId; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void AiravataClient::recv_getGateway( ::apache::airavata::model::workspace::Gateway& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("getGateway") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + Airavata_getGateway_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -52936,24 +55443,23 @@ void AiravataClient::recv_getAPIVersion(std::string& _return) if (result.__isset.ae) { throw result.ae; } - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getAPIVersion failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getGateway failed: unknown result"); } -bool AiravataClient::isUserExists(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId, const std::string& userName) +bool AiravataClient::deleteGateway(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId) { - send_isUserExists(authzToken, gatewayId, userName); - return recv_isUserExists(); + send_deleteGateway(authzToken, gatewayId); + return recv_deleteGateway(); } -void AiravataClient::send_isUserExists(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId, const std::string& userName) +void AiravataClient::send_deleteGateway(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId) { int32_t cseqid = 0; - oprot_->writeMessageBegin("isUserExists", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("deleteGateway", ::apache::thrift::protocol::T_CALL, cseqid); - Airavata_isUserExists_pargs args; + Airavata_deleteGateway_pargs args; args.authzToken = &authzToken; args.gatewayId = &gatewayId; - args.userName = &userName; args.write(oprot_); oprot_->writeMessageEnd(); @@ -52961,7 +55467,7 @@ void AiravataClient::send_isUserExists(const ::apache::airavata::model::securit oprot_->getTransport()->flush(); } -bool AiravataClient::recv_isUserExists() +bool AiravataClient::recv_deleteGateway() { int32_t rseqid = 0; @@ -52981,13 +55487,13 @@ bool AiravataClient::recv_isUserExists() iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("isUserExists") != 0) { + if (fname.compare("deleteGateway") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } bool _return; - Airavata_isUserExists_presult result; + Airavata_deleteGateway_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -53008,23 +55514,22 @@ bool AiravataClient::recv_isUserExists() if (result.__isset.ae) { throw result.ae; } - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "isUserExists failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "deleteGateway failed: unknown result"); } -void AiravataClient::addGateway(std::string& _return, const ::apache::airavata::model::security::AuthzToken& authzToken, const ::apache::airavata::model::workspace::Gateway& gateway) +void AiravataClient::getAllGateways(std::vector< ::apache::airavata::model::workspace::Gateway> & _return, const ::apache::airavata::model::security::AuthzToken& authzToken) { - send_addGateway(authzToken, gateway); - recv_addGateway(_return); + send_getAllGateways(authzToken); + recv_getAllGateways(_return); } -void AiravataClient::send_addGateway(const ::apache::airavata::model::security::AuthzToken& authzToken, const ::apache::airavata::model::workspace::Gateway& gateway) +void AiravataClient::send_getAllGateways(const ::apache::airavata::model::security::AuthzToken& authzToken) { int32_t cseqid = 0; - oprot_->writeMessageBegin("addGateway", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("getAllGateways", ::apache::thrift::protocol::T_CALL, cseqid); - Airavata_addGateway_pargs args; + Airavata_getAllGateways_pargs args; args.authzToken = &authzToken; - args.gateway = &gateway; args.write(oprot_); oprot_->writeMessageEnd(); @@ -53032,7 +55537,7 @@ void AiravataClient::send_addGateway(const ::apache::airavata::model::security: oprot_->getTransport()->flush(); } -void AiravataClient::recv_addGateway(std::string& _return) +void AiravataClient::recv_getAllGateways(std::vector< ::apache::airavata::model::workspace::Gateway> & _return) { int32_t rseqid = 0; @@ -53052,12 +55557,12 @@ void AiravataClient::recv_addGateway(std::string& _return) iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("addGateway") != 0) { + if (fname.compare("getAllGateways") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - Airavata_addGateway_presult result; + Airavata_getAllGateways_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -53079,21 +55584,21 @@ void AiravataClient::recv_addGateway(std::string& _return) if (result.__isset.ae) { throw result.ae; } - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "addGateway failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getAllGateways failed: unknown result"); } -void AiravataClient::getAllUsersInGateway(std::vector<std::string> & _return, const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId) +bool AiravataClient::isGatewayExist(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId) { - send_getAllUsersInGateway(authzToken, gatewayId); - recv_getAllUsersInGateway(_return); + send_isGatewayExist(authzToken, gatewayId); + return recv_isGatewayExist(); } -void AiravataClient::send_getAllUsersInGateway(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId) +void AiravataClient::send_isGatewayExist(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId) { int32_t cseqid = 0; - oprot_->writeMessageBegin("getAllUsersInGateway", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("isGatewayExist", ::apache::thrift::protocol::T_CALL, cseqid); - Airavata_getAllUsersInGateway_pargs args; + Airavata_isGatewayExist_pargs args; args.authzToken = &authzToken; args.gatewayId = &gatewayId; args.write(oprot_); @@ -53103,7 +55608,7 @@ void AiravataClient::send_getAllUsersInGateway(const ::apache::airavata::model: oprot_->getTransport()->flush(); } -void AiravataClient::recv_getAllUsersInGateway(std::vector<std::string> & _return) +bool AiravataClient::recv_isGatewayExist() { int32_t rseqid = 0; @@ -53123,12 +55628,83 @@ void AiravataClient::recv_getAllUsersInGateway(std::vector<std::string> & _retur iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("getAllUsersInGateway") != 0) { + if (fname.compare("isGatewayExist") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - Airavata_getAllUsersInGateway_presult result; + bool _return; + Airavata_isGatewayExist_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + return _return; + } + if (result.__isset.ire) { + throw result.ire; + } + if (result.__isset.ace) { + throw result.ace; + } + if (result.__isset.ase) { + throw result.ase; + } + if (result.__isset.ae) { + throw result.ae; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "isGatewayExist failed: unknown result"); +} + +void AiravataClient::createNotification(std::string& _return, const ::apache::airavata::model::security::AuthzToken& authzToken, const ::apache::airavata::model::workspace::Notification& notification) +{ + send_createNotification(authzToken, notification); + recv_createNotification(_return); +} + +void AiravataClient::send_createNotification(const ::apache::airavata::model::security::AuthzToken& authzToken, const ::apache::airavata::model::workspace::Notification& notification) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("createNotification", ::apache::thrift::protocol::T_CALL, cseqid); + + Airavata_createNotification_pargs args; + args.authzToken = &authzToken; + args.notification = ¬ification; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void AiravataClient::recv_createNotification(std::string& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("createNotification") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + Airavata_createNotification_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -53150,24 +55726,95 @@ void AiravataClient::recv_getAllUsersInGateway(std::vector<std::string> & _retur if (result.__isset.ae) { throw result.ae; } - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getAllUsersInGateway failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "createNotification failed: unknown result"); } -bool AiravataClient::updateGateway(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId, const ::apache::airavata::model::workspace::Gateway& updatedGateway) +bool AiravataClient::updateNotification(const ::apache::airavata::model::security::AuthzToken& authzToken, const ::apache::airavata::model::workspace::Notification& notification) { - send_updateGateway(authzToken, gatewayId, updatedGateway); - return recv_updateGateway(); + send_updateNotification(authzToken, notification); + return recv_updateNotification(); } -void AiravataClient::send_updateGateway(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId, const ::apache::airavata::model::workspace::Gateway& updatedGateway) +void AiravataClient::send_updateNotification(const ::apache::airavata::model::security::AuthzToken& authzToken, const ::apache::airavata::model::workspace::Notification& notification) { int32_t cseqid = 0; - oprot_->writeMessageBegin("updateGateway", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("updateNotification", ::apache::thrift::protocol::T_CALL, cseqid); - Airavata_updateGateway_pargs args; + Airavata_updateNotification_pargs args; + args.authzToken = &authzToken; + args.notification = ¬ification; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +bool AiravataClient::recv_updateNotification() +{ +
<TRUNCATED>
