http://git-wip-us.apache.org/repos/asf/hive/blob/32b7abac/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp ---------------------------------------------------------------------- diff --git a/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp b/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp index b3c9798..79da92e 100644 --- a/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp +++ b/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp @@ -20760,6 +20760,674 @@ void TableMeta::printTo(std::ostream& out) const { } +WMResourcePlan::~WMResourcePlan() throw() { +} + + +void WMResourcePlan::__set_name(const std::string& val) { + this->name = val; +} + +void WMResourcePlan::__set_status(const std::string& val) { + this->status = val; +__isset.status = true; +} + +void WMResourcePlan::__set_queryParallelism(const int32_t val) { + this->queryParallelism = val; +__isset.queryParallelism = true; +} + +uint32_t WMResourcePlan::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_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->name); + isset_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->status); + this->__isset.status = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->queryParallelism); + this->__isset.queryParallelism = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_name) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t WMResourcePlan::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMResourcePlan"); + + xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->name); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.status) { + xfer += oprot->writeFieldBegin("status", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->status); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.queryParallelism) { + xfer += oprot->writeFieldBegin("queryParallelism", ::apache::thrift::protocol::T_I32, 3); + xfer += oprot->writeI32(this->queryParallelism); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMResourcePlan &a, WMResourcePlan &b) { + using ::std::swap; + swap(a.name, b.name); + swap(a.status, b.status); + swap(a.queryParallelism, b.queryParallelism); + swap(a.__isset, b.__isset); +} + +WMResourcePlan::WMResourcePlan(const WMResourcePlan& other863) { + name = other863.name; + status = other863.status; + queryParallelism = other863.queryParallelism; + __isset = other863.__isset; +} +WMResourcePlan& WMResourcePlan::operator=(const WMResourcePlan& other864) { + name = other864.name; + status = other864.status; + queryParallelism = other864.queryParallelism; + __isset = other864.__isset; + return *this; +} +void WMResourcePlan::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMResourcePlan("; + out << "name=" << to_string(name); + out << ", " << "status="; (__isset.status ? (out << to_string(status)) : (out << "<null>")); + out << ", " << "queryParallelism="; (__isset.queryParallelism ? (out << to_string(queryParallelism)) : (out << "<null>")); + out << ")"; +} + + +WMPool::~WMPool() throw() { +} + + +void WMPool::__set_resourcePlanName(const std::string& val) { + this->resourcePlanName = val; +} + +void WMPool::__set_poolName(const std::string& val) { + this->poolName = val; +} + +void WMPool::__set_parentPoolName(const std::string& val) { + this->parentPoolName = val; +__isset.parentPoolName = true; +} + +void WMPool::__set_allocFraction(const double val) { + this->allocFraction = val; +__isset.allocFraction = true; +} + +void WMPool::__set_queryParallelism(const int32_t val) { + this->queryParallelism = val; +__isset.queryParallelism = true; +} + +void WMPool::__set_schedulingPolicy(const std::string& val) { + this->schedulingPolicy = val; +__isset.schedulingPolicy = true; +} + +uint32_t WMPool::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_resourcePlanName = false; + bool isset_poolName = 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->resourcePlanName); + isset_resourcePlanName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->poolName); + isset_poolName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->parentPoolName); + this->__isset.parentPoolName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_DOUBLE) { + xfer += iprot->readDouble(this->allocFraction); + this->__isset.allocFraction = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->queryParallelism); + this->__isset.queryParallelism = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->schedulingPolicy); + this->__isset.schedulingPolicy = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_resourcePlanName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_poolName) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t WMPool::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMPool"); + + xfer += oprot->writeFieldBegin("resourcePlanName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->resourcePlanName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("poolName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->poolName); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.parentPoolName) { + xfer += oprot->writeFieldBegin("parentPoolName", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->parentPoolName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.allocFraction) { + xfer += oprot->writeFieldBegin("allocFraction", ::apache::thrift::protocol::T_DOUBLE, 4); + xfer += oprot->writeDouble(this->allocFraction); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.queryParallelism) { + xfer += oprot->writeFieldBegin("queryParallelism", ::apache::thrift::protocol::T_I32, 5); + xfer += oprot->writeI32(this->queryParallelism); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.schedulingPolicy) { + xfer += oprot->writeFieldBegin("schedulingPolicy", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeString(this->schedulingPolicy); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMPool &a, WMPool &b) { + using ::std::swap; + swap(a.resourcePlanName, b.resourcePlanName); + swap(a.poolName, b.poolName); + swap(a.parentPoolName, b.parentPoolName); + swap(a.allocFraction, b.allocFraction); + swap(a.queryParallelism, b.queryParallelism); + swap(a.schedulingPolicy, b.schedulingPolicy); + swap(a.__isset, b.__isset); +} + +WMPool::WMPool(const WMPool& other865) { + resourcePlanName = other865.resourcePlanName; + poolName = other865.poolName; + parentPoolName = other865.parentPoolName; + allocFraction = other865.allocFraction; + queryParallelism = other865.queryParallelism; + schedulingPolicy = other865.schedulingPolicy; + __isset = other865.__isset; +} +WMPool& WMPool::operator=(const WMPool& other866) { + resourcePlanName = other866.resourcePlanName; + poolName = other866.poolName; + parentPoolName = other866.parentPoolName; + allocFraction = other866.allocFraction; + queryParallelism = other866.queryParallelism; + schedulingPolicy = other866.schedulingPolicy; + __isset = other866.__isset; + return *this; +} +void WMPool::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMPool("; + out << "resourcePlanName=" << to_string(resourcePlanName); + out << ", " << "poolName=" << to_string(poolName); + out << ", " << "parentPoolName="; (__isset.parentPoolName ? (out << to_string(parentPoolName)) : (out << "<null>")); + out << ", " << "allocFraction="; (__isset.allocFraction ? (out << to_string(allocFraction)) : (out << "<null>")); + out << ", " << "queryParallelism="; (__isset.queryParallelism ? (out << to_string(queryParallelism)) : (out << "<null>")); + out << ", " << "schedulingPolicy="; (__isset.schedulingPolicy ? (out << to_string(schedulingPolicy)) : (out << "<null>")); + out << ")"; +} + + +WMTrigger::~WMTrigger() throw() { +} + + +void WMTrigger::__set_resourcePlanName(const std::string& val) { + this->resourcePlanName = val; +} + +void WMTrigger::__set_poolName(const std::string& val) { + this->poolName = val; +} + +void WMTrigger::__set_triggerExpression(const std::string& val) { + this->triggerExpression = val; +__isset.triggerExpression = true; +} + +void WMTrigger::__set_actionExpression(const std::string& val) { + this->actionExpression = val; +__isset.actionExpression = true; +} + +uint32_t WMTrigger::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_resourcePlanName = false; + bool isset_poolName = 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->resourcePlanName); + isset_resourcePlanName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->poolName); + isset_poolName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->triggerExpression); + this->__isset.triggerExpression = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->actionExpression); + this->__isset.actionExpression = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_resourcePlanName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_poolName) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t WMTrigger::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMTrigger"); + + xfer += oprot->writeFieldBegin("resourcePlanName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->resourcePlanName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("poolName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->poolName); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.triggerExpression) { + xfer += oprot->writeFieldBegin("triggerExpression", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->triggerExpression); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.actionExpression) { + xfer += oprot->writeFieldBegin("actionExpression", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->actionExpression); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMTrigger &a, WMTrigger &b) { + using ::std::swap; + swap(a.resourcePlanName, b.resourcePlanName); + swap(a.poolName, b.poolName); + swap(a.triggerExpression, b.triggerExpression); + swap(a.actionExpression, b.actionExpression); + swap(a.__isset, b.__isset); +} + +WMTrigger::WMTrigger(const WMTrigger& other867) { + resourcePlanName = other867.resourcePlanName; + poolName = other867.poolName; + triggerExpression = other867.triggerExpression; + actionExpression = other867.actionExpression; + __isset = other867.__isset; +} +WMTrigger& WMTrigger::operator=(const WMTrigger& other868) { + resourcePlanName = other868.resourcePlanName; + poolName = other868.poolName; + triggerExpression = other868.triggerExpression; + actionExpression = other868.actionExpression; + __isset = other868.__isset; + return *this; +} +void WMTrigger::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMTrigger("; + out << "resourcePlanName=" << to_string(resourcePlanName); + out << ", " << "poolName=" << to_string(poolName); + out << ", " << "triggerExpression="; (__isset.triggerExpression ? (out << to_string(triggerExpression)) : (out << "<null>")); + out << ", " << "actionExpression="; (__isset.actionExpression ? (out << to_string(actionExpression)) : (out << "<null>")); + out << ")"; +} + + +WMMapping::~WMMapping() throw() { +} + + +void WMMapping::__set_resourcePlanName(const std::string& val) { + this->resourcePlanName = val; +} + +void WMMapping::__set_entityType(const std::string& val) { + this->entityType = val; +} + +void WMMapping::__set_entityName(const std::string& val) { + this->entityName = val; +} + +void WMMapping::__set_poolName(const std::string& val) { + this->poolName = val; +__isset.poolName = true; +} + +void WMMapping::__set_ordering(const int32_t val) { + this->ordering = val; +__isset.ordering = true; +} + +uint32_t WMMapping::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_resourcePlanName = false; + bool isset_entityType = false; + bool isset_entityName = 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->resourcePlanName); + isset_resourcePlanName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->entityType); + isset_entityType = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->entityName); + isset_entityName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->poolName); + this->__isset.poolName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->ordering); + this->__isset.ordering = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_resourcePlanName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_entityType) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_entityName) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t WMMapping::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("WMMapping"); + + xfer += oprot->writeFieldBegin("resourcePlanName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->resourcePlanName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("entityType", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->entityType); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("entityName", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->entityName); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.poolName) { + xfer += oprot->writeFieldBegin("poolName", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->poolName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.ordering) { + xfer += oprot->writeFieldBegin("ordering", ::apache::thrift::protocol::T_I32, 5); + xfer += oprot->writeI32(this->ordering); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WMMapping &a, WMMapping &b) { + using ::std::swap; + swap(a.resourcePlanName, b.resourcePlanName); + swap(a.entityType, b.entityType); + swap(a.entityName, b.entityName); + swap(a.poolName, b.poolName); + swap(a.ordering, b.ordering); + swap(a.__isset, b.__isset); +} + +WMMapping::WMMapping(const WMMapping& other869) { + resourcePlanName = other869.resourcePlanName; + entityType = other869.entityType; + entityName = other869.entityName; + poolName = other869.poolName; + ordering = other869.ordering; + __isset = other869.__isset; +} +WMMapping& WMMapping::operator=(const WMMapping& other870) { + resourcePlanName = other870.resourcePlanName; + entityType = other870.entityType; + entityName = other870.entityName; + poolName = other870.poolName; + ordering = other870.ordering; + __isset = other870.__isset; + return *this; +} +void WMMapping::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WMMapping("; + out << "resourcePlanName=" << to_string(resourcePlanName); + out << ", " << "entityType=" << to_string(entityType); + out << ", " << "entityName=" << to_string(entityName); + out << ", " << "poolName="; (__isset.poolName ? (out << to_string(poolName)) : (out << "<null>")); + out << ", " << "ordering="; (__isset.ordering ? (out << to_string(ordering)) : (out << "<null>")); + out << ")"; +} + + MetaException::~MetaException() throw() { } @@ -20829,13 +21497,13 @@ void swap(MetaException &a, MetaException &b) { swap(a.__isset, b.__isset); } -MetaException::MetaException(const MetaException& other863) : TException() { - message = other863.message; - __isset = other863.__isset; +MetaException::MetaException(const MetaException& other871) : TException() { + message = other871.message; + __isset = other871.__isset; } -MetaException& MetaException::operator=(const MetaException& other864) { - message = other864.message; - __isset = other864.__isset; +MetaException& MetaException::operator=(const MetaException& other872) { + message = other872.message; + __isset = other872.__isset; return *this; } void MetaException::printTo(std::ostream& out) const { @@ -20926,13 +21594,13 @@ void swap(UnknownTableException &a, UnknownTableException &b) { swap(a.__isset, b.__isset); } -UnknownTableException::UnknownTableException(const UnknownTableException& other865) : TException() { - message = other865.message; - __isset = other865.__isset; +UnknownTableException::UnknownTableException(const UnknownTableException& other873) : TException() { + message = other873.message; + __isset = other873.__isset; } -UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other866) { - message = other866.message; - __isset = other866.__isset; +UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other874) { + message = other874.message; + __isset = other874.__isset; return *this; } void UnknownTableException::printTo(std::ostream& out) const { @@ -21023,13 +21691,13 @@ void swap(UnknownDBException &a, UnknownDBException &b) { swap(a.__isset, b.__isset); } -UnknownDBException::UnknownDBException(const UnknownDBException& other867) : TException() { - message = other867.message; - __isset = other867.__isset; +UnknownDBException::UnknownDBException(const UnknownDBException& other875) : TException() { + message = other875.message; + __isset = other875.__isset; } -UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other868) { - message = other868.message; - __isset = other868.__isset; +UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other876) { + message = other876.message; + __isset = other876.__isset; return *this; } void UnknownDBException::printTo(std::ostream& out) const { @@ -21120,13 +21788,13 @@ void swap(AlreadyExistsException &a, AlreadyExistsException &b) { swap(a.__isset, b.__isset); } -AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other869) : TException() { - message = other869.message; - __isset = other869.__isset; +AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other877) : TException() { + message = other877.message; + __isset = other877.__isset; } -AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other870) { - message = other870.message; - __isset = other870.__isset; +AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other878) { + message = other878.message; + __isset = other878.__isset; return *this; } void AlreadyExistsException::printTo(std::ostream& out) const { @@ -21217,13 +21885,13 @@ void swap(InvalidPartitionException &a, InvalidPartitionException &b) { swap(a.__isset, b.__isset); } -InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other871) : TException() { - message = other871.message; - __isset = other871.__isset; +InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other879) : TException() { + message = other879.message; + __isset = other879.__isset; } -InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other872) { - message = other872.message; - __isset = other872.__isset; +InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other880) { + message = other880.message; + __isset = other880.__isset; return *this; } void InvalidPartitionException::printTo(std::ostream& out) const { @@ -21314,13 +21982,13 @@ void swap(UnknownPartitionException &a, UnknownPartitionException &b) { swap(a.__isset, b.__isset); } -UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other873) : TException() { - message = other873.message; - __isset = other873.__isset; +UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other881) : TException() { + message = other881.message; + __isset = other881.__isset; } -UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other874) { - message = other874.message; - __isset = other874.__isset; +UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other882) { + message = other882.message; + __isset = other882.__isset; return *this; } void UnknownPartitionException::printTo(std::ostream& out) const { @@ -21411,13 +22079,13 @@ void swap(InvalidObjectException &a, InvalidObjectException &b) { swap(a.__isset, b.__isset); } -InvalidObjectException::InvalidObjectException(const InvalidObjectException& other875) : TException() { - message = other875.message; - __isset = other875.__isset; +InvalidObjectException::InvalidObjectException(const InvalidObjectException& other883) : TException() { + message = other883.message; + __isset = other883.__isset; } -InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other876) { - message = other876.message; - __isset = other876.__isset; +InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other884) { + message = other884.message; + __isset = other884.__isset; return *this; } void InvalidObjectException::printTo(std::ostream& out) const { @@ -21508,13 +22176,13 @@ void swap(NoSuchObjectException &a, NoSuchObjectException &b) { swap(a.__isset, b.__isset); } -NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other877) : TException() { - message = other877.message; - __isset = other877.__isset; +NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other885) : TException() { + message = other885.message; + __isset = other885.__isset; } -NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other878) { - message = other878.message; - __isset = other878.__isset; +NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other886) { + message = other886.message; + __isset = other886.__isset; return *this; } void NoSuchObjectException::printTo(std::ostream& out) const { @@ -21605,13 +22273,13 @@ void swap(IndexAlreadyExistsException &a, IndexAlreadyExistsException &b) { swap(a.__isset, b.__isset); } -IndexAlreadyExistsException::IndexAlreadyExistsException(const IndexAlreadyExistsException& other879) : TException() { - message = other879.message; - __isset = other879.__isset; +IndexAlreadyExistsException::IndexAlreadyExistsException(const IndexAlreadyExistsException& other887) : TException() { + message = other887.message; + __isset = other887.__isset; } -IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other880) { - message = other880.message; - __isset = other880.__isset; +IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other888) { + message = other888.message; + __isset = other888.__isset; return *this; } void IndexAlreadyExistsException::printTo(std::ostream& out) const { @@ -21702,13 +22370,13 @@ void swap(InvalidOperationException &a, InvalidOperationException &b) { swap(a.__isset, b.__isset); } -InvalidOperationException::InvalidOperationException(const InvalidOperationException& other881) : TException() { - message = other881.message; - __isset = other881.__isset; +InvalidOperationException::InvalidOperationException(const InvalidOperationException& other889) : TException() { + message = other889.message; + __isset = other889.__isset; } -InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other882) { - message = other882.message; - __isset = other882.__isset; +InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other890) { + message = other890.message; + __isset = other890.__isset; return *this; } void InvalidOperationException::printTo(std::ostream& out) const { @@ -21799,13 +22467,13 @@ void swap(ConfigValSecurityException &a, ConfigValSecurityException &b) { swap(a.__isset, b.__isset); } -ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other883) : TException() { - message = other883.message; - __isset = other883.__isset; +ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other891) : TException() { + message = other891.message; + __isset = other891.__isset; } -ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other884) { - message = other884.message; - __isset = other884.__isset; +ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other892) { + message = other892.message; + __isset = other892.__isset; return *this; } void ConfigValSecurityException::printTo(std::ostream& out) const { @@ -21896,13 +22564,13 @@ void swap(InvalidInputException &a, InvalidInputException &b) { swap(a.__isset, b.__isset); } -InvalidInputException::InvalidInputException(const InvalidInputException& other885) : TException() { - message = other885.message; - __isset = other885.__isset; +InvalidInputException::InvalidInputException(const InvalidInputException& other893) : TException() { + message = other893.message; + __isset = other893.__isset; } -InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other886) { - message = other886.message; - __isset = other886.__isset; +InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other894) { + message = other894.message; + __isset = other894.__isset; return *this; } void InvalidInputException::printTo(std::ostream& out) const { @@ -21993,13 +22661,13 @@ void swap(NoSuchTxnException &a, NoSuchTxnException &b) { swap(a.__isset, b.__isset); } -NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other887) : TException() { - message = other887.message; - __isset = other887.__isset; +NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other895) : TException() { + message = other895.message; + __isset = other895.__isset; } -NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other888) { - message = other888.message; - __isset = other888.__isset; +NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other896) { + message = other896.message; + __isset = other896.__isset; return *this; } void NoSuchTxnException::printTo(std::ostream& out) const { @@ -22090,13 +22758,13 @@ void swap(TxnAbortedException &a, TxnAbortedException &b) { swap(a.__isset, b.__isset); } -TxnAbortedException::TxnAbortedException(const TxnAbortedException& other889) : TException() { - message = other889.message; - __isset = other889.__isset; +TxnAbortedException::TxnAbortedException(const TxnAbortedException& other897) : TException() { + message = other897.message; + __isset = other897.__isset; } -TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other890) { - message = other890.message; - __isset = other890.__isset; +TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other898) { + message = other898.message; + __isset = other898.__isset; return *this; } void TxnAbortedException::printTo(std::ostream& out) const { @@ -22187,13 +22855,13 @@ void swap(TxnOpenException &a, TxnOpenException &b) { swap(a.__isset, b.__isset); } -TxnOpenException::TxnOpenException(const TxnOpenException& other891) : TException() { - message = other891.message; - __isset = other891.__isset; +TxnOpenException::TxnOpenException(const TxnOpenException& other899) : TException() { + message = other899.message; + __isset = other899.__isset; } -TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other892) { - message = other892.message; - __isset = other892.__isset; +TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other900) { + message = other900.message; + __isset = other900.__isset; return *this; } void TxnOpenException::printTo(std::ostream& out) const { @@ -22284,13 +22952,13 @@ void swap(NoSuchLockException &a, NoSuchLockException &b) { swap(a.__isset, b.__isset); } -NoSuchLockException::NoSuchLockException(const NoSuchLockException& other893) : TException() { - message = other893.message; - __isset = other893.__isset; +NoSuchLockException::NoSuchLockException(const NoSuchLockException& other901) : TException() { + message = other901.message; + __isset = other901.__isset; } -NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other894) { - message = other894.message; - __isset = other894.__isset; +NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other902) { + message = other902.message; + __isset = other902.__isset; return *this; } void NoSuchLockException::printTo(std::ostream& out) const {
http://git-wip-us.apache.org/repos/asf/hive/blob/32b7abac/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h ---------------------------------------------------------------------- diff --git a/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h b/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h index fd9014d..9c883ca 100644 --- a/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h +++ b/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h @@ -438,6 +438,14 @@ class CmRecycleResponse; class TableMeta; +class WMResourcePlan; + +class WMPool; + +class WMTrigger; + +class WMMapping; + class MetaException; class UnknownTableException; @@ -8441,6 +8449,286 @@ inline std::ostream& operator<<(std::ostream& out, const TableMeta& obj) return out; } +typedef struct _WMResourcePlan__isset { + _WMResourcePlan__isset() : status(false), queryParallelism(false) {} + bool status :1; + bool queryParallelism :1; +} _WMResourcePlan__isset; + +class WMResourcePlan { + public: + + WMResourcePlan(const WMResourcePlan&); + WMResourcePlan& operator=(const WMResourcePlan&); + WMResourcePlan() : name(), status(), queryParallelism(0) { + } + + virtual ~WMResourcePlan() throw(); + std::string name; + std::string status; + int32_t queryParallelism; + + _WMResourcePlan__isset __isset; + + void __set_name(const std::string& val); + + void __set_status(const std::string& val); + + void __set_queryParallelism(const int32_t val); + + bool operator == (const WMResourcePlan & rhs) const + { + if (!(name == rhs.name)) + return false; + if (__isset.status != rhs.__isset.status) + return false; + else if (__isset.status && !(status == rhs.status)) + return false; + if (__isset.queryParallelism != rhs.__isset.queryParallelism) + return false; + else if (__isset.queryParallelism && !(queryParallelism == rhs.queryParallelism)) + return false; + return true; + } + bool operator != (const WMResourcePlan &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMResourcePlan & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMResourcePlan &a, WMResourcePlan &b); + +inline std::ostream& operator<<(std::ostream& out, const WMResourcePlan& obj) +{ + obj.printTo(out); + return out; +} + +typedef struct _WMPool__isset { + _WMPool__isset() : parentPoolName(false), allocFraction(false), queryParallelism(false), schedulingPolicy(false) {} + bool parentPoolName :1; + bool allocFraction :1; + bool queryParallelism :1; + bool schedulingPolicy :1; +} _WMPool__isset; + +class WMPool { + public: + + WMPool(const WMPool&); + WMPool& operator=(const WMPool&); + WMPool() : resourcePlanName(), poolName(), parentPoolName(), allocFraction(0), queryParallelism(0), schedulingPolicy() { + } + + virtual ~WMPool() throw(); + std::string resourcePlanName; + std::string poolName; + std::string parentPoolName; + double allocFraction; + int32_t queryParallelism; + std::string schedulingPolicy; + + _WMPool__isset __isset; + + void __set_resourcePlanName(const std::string& val); + + void __set_poolName(const std::string& val); + + void __set_parentPoolName(const std::string& val); + + void __set_allocFraction(const double val); + + void __set_queryParallelism(const int32_t val); + + void __set_schedulingPolicy(const std::string& val); + + bool operator == (const WMPool & rhs) const + { + if (!(resourcePlanName == rhs.resourcePlanName)) + return false; + if (!(poolName == rhs.poolName)) + return false; + if (__isset.parentPoolName != rhs.__isset.parentPoolName) + return false; + else if (__isset.parentPoolName && !(parentPoolName == rhs.parentPoolName)) + return false; + if (__isset.allocFraction != rhs.__isset.allocFraction) + return false; + else if (__isset.allocFraction && !(allocFraction == rhs.allocFraction)) + return false; + if (__isset.queryParallelism != rhs.__isset.queryParallelism) + return false; + else if (__isset.queryParallelism && !(queryParallelism == rhs.queryParallelism)) + return false; + if (__isset.schedulingPolicy != rhs.__isset.schedulingPolicy) + return false; + else if (__isset.schedulingPolicy && !(schedulingPolicy == rhs.schedulingPolicy)) + return false; + return true; + } + bool operator != (const WMPool &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMPool & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMPool &a, WMPool &b); + +inline std::ostream& operator<<(std::ostream& out, const WMPool& obj) +{ + obj.printTo(out); + return out; +} + +typedef struct _WMTrigger__isset { + _WMTrigger__isset() : triggerExpression(false), actionExpression(false) {} + bool triggerExpression :1; + bool actionExpression :1; +} _WMTrigger__isset; + +class WMTrigger { + public: + + WMTrigger(const WMTrigger&); + WMTrigger& operator=(const WMTrigger&); + WMTrigger() : resourcePlanName(), poolName(), triggerExpression(), actionExpression() { + } + + virtual ~WMTrigger() throw(); + std::string resourcePlanName; + std::string poolName; + std::string triggerExpression; + std::string actionExpression; + + _WMTrigger__isset __isset; + + void __set_resourcePlanName(const std::string& val); + + void __set_poolName(const std::string& val); + + void __set_triggerExpression(const std::string& val); + + void __set_actionExpression(const std::string& val); + + bool operator == (const WMTrigger & rhs) const + { + if (!(resourcePlanName == rhs.resourcePlanName)) + return false; + if (!(poolName == rhs.poolName)) + return false; + if (__isset.triggerExpression != rhs.__isset.triggerExpression) + return false; + else if (__isset.triggerExpression && !(triggerExpression == rhs.triggerExpression)) + return false; + if (__isset.actionExpression != rhs.__isset.actionExpression) + return false; + else if (__isset.actionExpression && !(actionExpression == rhs.actionExpression)) + return false; + return true; + } + bool operator != (const WMTrigger &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMTrigger & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMTrigger &a, WMTrigger &b); + +inline std::ostream& operator<<(std::ostream& out, const WMTrigger& obj) +{ + obj.printTo(out); + return out; +} + +typedef struct _WMMapping__isset { + _WMMapping__isset() : poolName(false), ordering(false) {} + bool poolName :1; + bool ordering :1; +} _WMMapping__isset; + +class WMMapping { + public: + + WMMapping(const WMMapping&); + WMMapping& operator=(const WMMapping&); + WMMapping() : resourcePlanName(), entityType(), entityName(), poolName(), ordering(0) { + } + + virtual ~WMMapping() throw(); + std::string resourcePlanName; + std::string entityType; + std::string entityName; + std::string poolName; + int32_t ordering; + + _WMMapping__isset __isset; + + void __set_resourcePlanName(const std::string& val); + + void __set_entityType(const std::string& val); + + void __set_entityName(const std::string& val); + + void __set_poolName(const std::string& val); + + void __set_ordering(const int32_t val); + + bool operator == (const WMMapping & rhs) const + { + if (!(resourcePlanName == rhs.resourcePlanName)) + return false; + if (!(entityType == rhs.entityType)) + return false; + if (!(entityName == rhs.entityName)) + return false; + if (__isset.poolName != rhs.__isset.poolName) + return false; + else if (__isset.poolName && !(poolName == rhs.poolName)) + return false; + if (__isset.ordering != rhs.__isset.ordering) + return false; + else if (__isset.ordering && !(ordering == rhs.ordering)) + return false; + return true; + } + bool operator != (const WMMapping &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WMMapping & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(WMMapping &a, WMMapping &b); + +inline std::ostream& operator<<(std::ostream& out, const WMMapping& obj) +{ + obj.printTo(out); + return out; +} + typedef struct _MetaException__isset { _MetaException__isset() : message(false) {} bool message :1; http://git-wip-us.apache.org/repos/asf/hive/blob/32b7abac/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMMapping.java ---------------------------------------------------------------------- diff --git a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMMapping.java b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMMapping.java new file mode 100644 index 0000000..cbf4f38 --- /dev/null +++ b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMMapping.java @@ -0,0 +1,804 @@ +/** + * Autogenerated by Thrift Compiler (0.9.3) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +package org.apache.hadoop.hive.metastore.api; + +import org.apache.thrift.scheme.IScheme; +import org.apache.thrift.scheme.SchemeFactory; +import org.apache.thrift.scheme.StandardScheme; + +import org.apache.thrift.scheme.TupleScheme; +import org.apache.thrift.protocol.TTupleProtocol; +import org.apache.thrift.protocol.TProtocolException; +import org.apache.thrift.EncodingUtils; +import org.apache.thrift.TException; +import org.apache.thrift.async.AsyncMethodCallback; +import org.apache.thrift.server.AbstractNonblockingServer.*; +import java.util.List; +import java.util.ArrayList; +import java.util.Map; +import java.util.HashMap; +import java.util.EnumMap; +import java.util.Set; +import java.util.HashSet; +import java.util.EnumSet; +import java.util.Collections; +import java.util.BitSet; +import java.nio.ByteBuffer; +import java.util.Arrays; +import javax.annotation.Generated; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) +@Generated(value = "Autogenerated by Thrift Compiler (0.9.3)") +public class WMMapping implements org.apache.thrift.TBase<WMMapping, WMMapping._Fields>, java.io.Serializable, Cloneable, Comparable<WMMapping> { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("WMMapping"); + + private static final org.apache.thrift.protocol.TField RESOURCE_PLAN_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("resourcePlanName", org.apache.thrift.protocol.TType.STRING, (short)1); + private static final org.apache.thrift.protocol.TField ENTITY_TYPE_FIELD_DESC = new org.apache.thrift.protocol.TField("entityType", org.apache.thrift.protocol.TType.STRING, (short)2); + private static final org.apache.thrift.protocol.TField ENTITY_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("entityName", org.apache.thrift.protocol.TType.STRING, (short)3); + private static final org.apache.thrift.protocol.TField POOL_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("poolName", org.apache.thrift.protocol.TType.STRING, (short)4); + private static final org.apache.thrift.protocol.TField ORDERING_FIELD_DESC = new org.apache.thrift.protocol.TField("ordering", org.apache.thrift.protocol.TType.I32, (short)5); + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new WMMappingStandardSchemeFactory()); + schemes.put(TupleScheme.class, new WMMappingTupleSchemeFactory()); + } + + private String resourcePlanName; // required + private String entityType; // required + private String entityName; // required + private String poolName; // optional + private int ordering; // optional + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + RESOURCE_PLAN_NAME((short)1, "resourcePlanName"), + ENTITY_TYPE((short)2, "entityType"), + ENTITY_NAME((short)3, "entityName"), + POOL_NAME((short)4, "poolName"), + ORDERING((short)5, "ordering"); + + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + case 1: // RESOURCE_PLAN_NAME + return RESOURCE_PLAN_NAME; + case 2: // ENTITY_TYPE + return ENTITY_TYPE; + case 3: // ENTITY_NAME + return ENTITY_NAME; + case 4: // POOL_NAME + return POOL_NAME; + case 5: // ORDERING + return ORDERING; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + private static final int __ORDERING_ISSET_ID = 0; + private byte __isset_bitfield = 0; + private static final _Fields optionals[] = {_Fields.POOL_NAME,_Fields.ORDERING}; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.RESOURCE_PLAN_NAME, new org.apache.thrift.meta_data.FieldMetaData("resourcePlanName", org.apache.thrift.TFieldRequirementType.REQUIRED, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.ENTITY_TYPE, new org.apache.thrift.meta_data.FieldMetaData("entityType", org.apache.thrift.TFieldRequirementType.REQUIRED, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.ENTITY_NAME, new org.apache.thrift.meta_data.FieldMetaData("entityName", org.apache.thrift.TFieldRequirementType.REQUIRED, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.POOL_NAME, new org.apache.thrift.meta_data.FieldMetaData("poolName", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.ORDERING, new org.apache.thrift.meta_data.FieldMetaData("ordering", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(WMMapping.class, metaDataMap); + } + + public WMMapping() { + } + + public WMMapping( + String resourcePlanName, + String entityType, + String entityName) + { + this(); + this.resourcePlanName = resourcePlanName; + this.entityType = entityType; + this.entityName = entityName; + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public WMMapping(WMMapping other) { + __isset_bitfield = other.__isset_bitfield; + if (other.isSetResourcePlanName()) { + this.resourcePlanName = other.resourcePlanName; + } + if (other.isSetEntityType()) { + this.entityType = other.entityType; + } + if (other.isSetEntityName()) { + this.entityName = other.entityName; + } + if (other.isSetPoolName()) { + this.poolName = other.poolName; + } + this.ordering = other.ordering; + } + + public WMMapping deepCopy() { + return new WMMapping(this); + } + + @Override + public void clear() { + this.resourcePlanName = null; + this.entityType = null; + this.entityName = null; + this.poolName = null; + setOrderingIsSet(false); + this.ordering = 0; + } + + public String getResourcePlanName() { + return this.resourcePlanName; + } + + public void setResourcePlanName(String resourcePlanName) { + this.resourcePlanName = resourcePlanName; + } + + public void unsetResourcePlanName() { + this.resourcePlanName = null; + } + + /** Returns true if field resourcePlanName is set (has been assigned a value) and false otherwise */ + public boolean isSetResourcePlanName() { + return this.resourcePlanName != null; + } + + public void setResourcePlanNameIsSet(boolean value) { + if (!value) { + this.resourcePlanName = null; + } + } + + public String getEntityType() { + return this.entityType; + } + + public void setEntityType(String entityType) { + this.entityType = entityType; + } + + public void unsetEntityType() { + this.entityType = null; + } + + /** Returns true if field entityType is set (has been assigned a value) and false otherwise */ + public boolean isSetEntityType() { + return this.entityType != null; + } + + public void setEntityTypeIsSet(boolean value) { + if (!value) { + this.entityType = null; + } + } + + public String getEntityName() { + return this.entityName; + } + + public void setEntityName(String entityName) { + this.entityName = entityName; + } + + public void unsetEntityName() { + this.entityName = null; + } + + /** Returns true if field entityName is set (has been assigned a value) and false otherwise */ + public boolean isSetEntityName() { + return this.entityName != null; + } + + public void setEntityNameIsSet(boolean value) { + if (!value) { + this.entityName = null; + } + } + + public String getPoolName() { + return this.poolName; + } + + public void setPoolName(String poolName) { + this.poolName = poolName; + } + + public void unsetPoolName() { + this.poolName = null; + } + + /** Returns true if field poolName is set (has been assigned a value) and false otherwise */ + public boolean isSetPoolName() { + return this.poolName != null; + } + + public void setPoolNameIsSet(boolean value) { + if (!value) { + this.poolName = null; + } + } + + public int getOrdering() { + return this.ordering; + } + + public void setOrdering(int ordering) { + this.ordering = ordering; + setOrderingIsSet(true); + } + + public void unsetOrdering() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __ORDERING_ISSET_ID); + } + + /** Returns true if field ordering is set (has been assigned a value) and false otherwise */ + public boolean isSetOrdering() { + return EncodingUtils.testBit(__isset_bitfield, __ORDERING_ISSET_ID); + } + + public void setOrderingIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __ORDERING_ISSET_ID, value); + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case RESOURCE_PLAN_NAME: + if (value == null) { + unsetResourcePlanName(); + } else { + setResourcePlanName((String)value); + } + break; + + case ENTITY_TYPE: + if (value == null) { + unsetEntityType(); + } else { + setEntityType((String)value); + } + break; + + case ENTITY_NAME: + if (value == null) { + unsetEntityName(); + } else { + setEntityName((String)value); + } + break; + + case POOL_NAME: + if (value == null) { + unsetPoolName(); + } else { + setPoolName((String)value); + } + break; + + case ORDERING: + if (value == null) { + unsetOrdering(); + } else { + setOrdering((Integer)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case RESOURCE_PLAN_NAME: + return getResourcePlanName(); + + case ENTITY_TYPE: + return getEntityType(); + + case ENTITY_NAME: + return getEntityName(); + + case POOL_NAME: + return getPoolName(); + + case ORDERING: + return getOrdering(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case RESOURCE_PLAN_NAME: + return isSetResourcePlanName(); + case ENTITY_TYPE: + return isSetEntityType(); + case ENTITY_NAME: + return isSetEntityName(); + case POOL_NAME: + return isSetPoolName(); + case ORDERING: + return isSetOrdering(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof WMMapping) + return this.equals((WMMapping)that); + return false; + } + + public boolean equals(WMMapping that) { + if (that == null) + return false; + + boolean this_present_resourcePlanName = true && this.isSetResourcePlanName(); + boolean that_present_resourcePlanName = true && that.isSetResourcePlanName(); + if (this_present_resourcePlanName || that_present_resourcePlanName) { + if (!(this_present_resourcePlanName && that_present_resourcePlanName)) + return false; + if (!this.resourcePlanName.equals(that.resourcePlanName)) + return false; + } + + boolean this_present_entityType = true && this.isSetEntityType(); + boolean that_present_entityType = true && that.isSetEntityType(); + if (this_present_entityType || that_present_entityType) { + if (!(this_present_entityType && that_present_entityType)) + return false; + if (!this.entityType.equals(that.entityType)) + return false; + } + + boolean this_present_entityName = true && this.isSetEntityName(); + boolean that_present_entityName = true && that.isSetEntityName(); + if (this_present_entityName || that_present_entityName) { + if (!(this_present_entityName && that_present_entityName)) + return false; + if (!this.entityName.equals(that.entityName)) + return false; + } + + boolean this_present_poolName = true && this.isSetPoolName(); + boolean that_present_poolName = true && that.isSetPoolName(); + if (this_present_poolName || that_present_poolName) { + if (!(this_present_poolName && that_present_poolName)) + return false; + if (!this.poolName.equals(that.poolName)) + return false; + } + + boolean this_present_ordering = true && this.isSetOrdering(); + boolean that_present_ordering = true && that.isSetOrdering(); + if (this_present_ordering || that_present_ordering) { + if (!(this_present_ordering && that_present_ordering)) + return false; + if (this.ordering != that.ordering) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + boolean present_resourcePlanName = true && (isSetResourcePlanName()); + list.add(present_resourcePlanName); + if (present_resourcePlanName) + list.add(resourcePlanName); + + boolean present_entityType = true && (isSetEntityType()); + list.add(present_entityType); + if (present_entityType) + list.add(entityType); + + boolean present_entityName = true && (isSetEntityName()); + list.add(present_entityName); + if (present_entityName) + list.add(entityName); + + boolean present_poolName = true && (isSetPoolName()); + list.add(present_poolName); + if (present_poolName) + list.add(poolName); + + boolean present_ordering = true && (isSetOrdering()); + list.add(present_ordering); + if (present_ordering) + list.add(ordering); + + return list.hashCode(); + } + + @Override + public int compareTo(WMMapping other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetResourcePlanName()).compareTo(other.isSetResourcePlanName()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetResourcePlanName()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.resourcePlanName, other.resourcePlanName); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetEntityType()).compareTo(other.isSetEntityType()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetEntityType()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.entityType, other.entityType); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetEntityName()).compareTo(other.isSetEntityName()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetEntityName()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.entityName, other.entityName); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetPoolName()).compareTo(other.isSetPoolName()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPoolName()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.poolName, other.poolName); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetOrdering()).compareTo(other.isSetOrdering()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetOrdering()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ordering, other.ordering); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("WMMapping("); + boolean first = true; + + sb.append("resourcePlanName:"); + if (this.resourcePlanName == null) { + sb.append("null"); + } else { + sb.append(this.resourcePlanName); + } + first = false; + if (!first) sb.append(", "); + sb.append("entityType:"); + if (this.entityType == null) { + sb.append("null"); + } else { + sb.append(this.entityType); + } + first = false; + if (!first) sb.append(", "); + sb.append("entityName:"); + if (this.entityName == null) { + sb.append("null"); + } else { + sb.append(this.entityName); + } + first = false; + if (isSetPoolName()) { + if (!first) sb.append(", "); + sb.append("poolName:"); + if (this.poolName == null) { + sb.append("null"); + } else { + sb.append(this.poolName); + } + first = false; + } + if (isSetOrdering()) { + if (!first) sb.append(", "); + sb.append("ordering:"); + sb.append(this.ordering); + first = false; + } + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + if (!isSetResourcePlanName()) { + throw new org.apache.thrift.protocol.TProtocolException("Required field 'resourcePlanName' is unset! Struct:" + toString()); + } + + if (!isSetEntityType()) { + throw new org.apache.thrift.protocol.TProtocolException("Required field 'entityType' is unset! Struct:" + toString()); + } + + if (!isSetEntityName()) { + throw new org.apache.thrift.protocol.TProtocolException("Required field 'entityName' is unset! Struct:" + toString()); + } + + // check for sub-struct validity + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_bitfield = 0; + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class WMMappingStandardSchemeFactory implements SchemeFactory { + public WMMappingStandardScheme getScheme() { + return new WMMappingStandardScheme(); + } + } + + private static class WMMappingStandardScheme extends StandardScheme<WMMapping> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, WMMapping struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField schemeField; + iprot.readStructBegin(); + while (true) + { + schemeField = iprot.readFieldBegin(); + if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (schemeField.id) { + case 1: // RESOURCE_PLAN_NAME + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.resourcePlanName = iprot.readString(); + struct.setResourcePlanNameIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // ENTITY_TYPE + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.entityType = iprot.readString(); + struct.setEntityTypeIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 3: // ENTITY_NAME + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.entityName = iprot.readString(); + struct.setEntityNameIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 4: // POOL_NAME + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.poolName = iprot.readString(); + struct.setPoolNameIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 5: // ORDERING + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.ordering = iprot.readI32(); + struct.setOrderingIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + struct.validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot, WMMapping struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.resourcePlanName != null) { + oprot.writeFieldBegin(RESOURCE_PLAN_NAME_FIELD_DESC); + oprot.writeString(struct.resourcePlanName); + oprot.writeFieldEnd(); + } + if (struct.entityType != null) { + oprot.writeFieldBegin(ENTITY_TYPE_FIELD_DESC); + oprot.writeString(struct.entityType); + oprot.writeFieldEnd(); + } + if (struct.entityName != null) { + oprot.writeFieldBegin(ENTITY_NAME_FIELD_DESC); + oprot.writeString(struct.entityName); + oprot.writeFieldEnd(); + } + if (struct.poolName != null) { + if (struct.isSetPoolName()) { + oprot.writeFieldBegin(POOL_NAME_FIELD_DESC); + oprot.writeString(struct.poolName); + oprot.writeFieldEnd(); + } + } + if (struct.isSetOrdering()) { + oprot.writeFieldBegin(ORDERING_FIELD_DESC); + oprot.writeI32(struct.ordering); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class WMMappingTupleSchemeFactory implements SchemeFactory { + public WMMappingTupleScheme getScheme() { + return new WMMappingTupleScheme(); + } + } + + private static class WMMappingTupleScheme extends TupleScheme<WMMapping> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, WMMapping struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + oprot.writeString(struct.resourcePlanName); + oprot.writeString(struct.entityType); + oprot.writeString(struct.entityName); + BitSet optionals = new BitSet(); + if (struct.isSetPoolName()) { + optionals.set(0); + } + if (struct.isSetOrdering()) { + optionals.set(1); + } + oprot.writeBitSet(optionals, 2); + if (struct.isSetPoolName()) { + oprot.writeString(struct.poolName); + } + if (struct.isSetOrdering()) { + oprot.writeI32(struct.ordering); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, WMMapping struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + struct.resourcePlanName = iprot.readString(); + struct.setResourcePlanNameIsSet(true); + struct.entityType = iprot.readString(); + struct.setEntityTypeIsSet(true); + struct.entityName = iprot.readString(); + struct.setEntityNameIsSet(true); + BitSet incoming = iprot.readBitSet(2); + if (incoming.get(0)) { + struct.poolName = iprot.readString(); + struct.setPoolNameIsSet(true); + } + if (incoming.get(1)) { + struct.ordering = iprot.readI32(); + struct.setOrderingIsSet(true); + } + } + } + +} +
