You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hive.apache.org by se...@apache.org on 2017/10/10 00:52:11 UTC
[37/61] [abbrv] hive git commit: HIVE-17566 : Create schema required
for workload management (Harish Jaiprakash,
reviewed Prasanth Jayachandran and Sergey Shelukhin)
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);
+ }
+ }
+ }
+
+}
+