You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hive.apache.org by kh...@apache.org on 2015/01/07 21:15:11 UTC
svn commit: r1650145 [3/8] - in /hive/trunk:
common/src/java/org/apache/hadoop/hive/conf/
hcatalog/server-extensions/src/main/java/org/apache/hive/hcatalog/listener/
hcatalog/server-extensions/src/main/java/org/apache/hive/hcatalog/messaging/json/
ites...
Modified: hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h
URL: http://svn.apache.org/viewvc/hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h?rev=1650145&r1=1650144&r2=1650145&view=diff
==============================================================================
--- hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h (original)
+++ hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h Wed Jan 7 20:15:10 2015
@@ -133,6 +133,8 @@ class ThriftHiveMetastoreIf : virtual pu
virtual void heartbeat_txn_range(HeartbeatTxnRangeResponse& _return, const HeartbeatTxnRangeRequest& txns) = 0;
virtual void compact(const CompactionRequest& rqst) = 0;
virtual void show_compact(ShowCompactResponse& _return, const ShowCompactRequest& rqst) = 0;
+ virtual void getNextNotification(NotificationEventResponse& _return, const NotificationEventRequest& rqst) = 0;
+ virtual void getCurrentNotificationEventId(CurrentNotificationEventId& _return) = 0;
};
class ThriftHiveMetastoreIfFactory : virtual public ::facebook::fb303::FacebookServiceIfFactory {
@@ -536,6 +538,12 @@ class ThriftHiveMetastoreNull : virtual
void show_compact(ShowCompactResponse& /* _return */, const ShowCompactRequest& /* rqst */) {
return;
}
+ void getNextNotification(NotificationEventResponse& /* _return */, const NotificationEventRequest& /* rqst */) {
+ return;
+ }
+ void getCurrentNotificationEventId(CurrentNotificationEventId& /* _return */) {
+ return;
+ }
};
typedef struct _ThriftHiveMetastore_getMetaConf_args__isset {
@@ -16567,6 +16575,208 @@ class ThriftHiveMetastore_show_compact_p
};
+typedef struct _ThriftHiveMetastore_getNextNotification_args__isset {
+ _ThriftHiveMetastore_getNextNotification_args__isset() : rqst(false) {}
+ bool rqst;
+} _ThriftHiveMetastore_getNextNotification_args__isset;
+
+class ThriftHiveMetastore_getNextNotification_args {
+ public:
+
+ ThriftHiveMetastore_getNextNotification_args() {
+ }
+
+ virtual ~ThriftHiveMetastore_getNextNotification_args() throw() {}
+
+ NotificationEventRequest rqst;
+
+ _ThriftHiveMetastore_getNextNotification_args__isset __isset;
+
+ void __set_rqst(const NotificationEventRequest& val) {
+ rqst = val;
+ }
+
+ bool operator == (const ThriftHiveMetastore_getNextNotification_args & rhs) const
+ {
+ if (!(rqst == rhs.rqst))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHiveMetastore_getNextNotification_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHiveMetastore_getNextNotification_args & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_getNextNotification_pargs {
+ public:
+
+
+ virtual ~ThriftHiveMetastore_getNextNotification_pargs() throw() {}
+
+ const NotificationEventRequest* rqst;
+
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_getNextNotification_result__isset {
+ _ThriftHiveMetastore_getNextNotification_result__isset() : success(false) {}
+ bool success;
+} _ThriftHiveMetastore_getNextNotification_result__isset;
+
+class ThriftHiveMetastore_getNextNotification_result {
+ public:
+
+ ThriftHiveMetastore_getNextNotification_result() {
+ }
+
+ virtual ~ThriftHiveMetastore_getNextNotification_result() throw() {}
+
+ NotificationEventResponse success;
+
+ _ThriftHiveMetastore_getNextNotification_result__isset __isset;
+
+ void __set_success(const NotificationEventResponse& val) {
+ success = val;
+ }
+
+ bool operator == (const ThriftHiveMetastore_getNextNotification_result & rhs) const
+ {
+ if (!(success == rhs.success))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHiveMetastore_getNextNotification_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHiveMetastore_getNextNotification_result & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_getNextNotification_presult__isset {
+ _ThriftHiveMetastore_getNextNotification_presult__isset() : success(false) {}
+ bool success;
+} _ThriftHiveMetastore_getNextNotification_presult__isset;
+
+class ThriftHiveMetastore_getNextNotification_presult {
+ public:
+
+
+ virtual ~ThriftHiveMetastore_getNextNotification_presult() throw() {}
+
+ NotificationEventResponse* success;
+
+ _ThriftHiveMetastore_getNextNotification_presult__isset __isset;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class ThriftHiveMetastore_getCurrentNotificationEventId_args {
+ public:
+
+ ThriftHiveMetastore_getCurrentNotificationEventId_args() {
+ }
+
+ virtual ~ThriftHiveMetastore_getCurrentNotificationEventId_args() throw() {}
+
+
+ bool operator == (const ThriftHiveMetastore_getCurrentNotificationEventId_args & /* rhs */) const
+ {
+ return true;
+ }
+ bool operator != (const ThriftHiveMetastore_getCurrentNotificationEventId_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHiveMetastore_getCurrentNotificationEventId_args & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_getCurrentNotificationEventId_pargs {
+ public:
+
+
+ virtual ~ThriftHiveMetastore_getCurrentNotificationEventId_pargs() throw() {}
+
+
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_getCurrentNotificationEventId_result__isset {
+ _ThriftHiveMetastore_getCurrentNotificationEventId_result__isset() : success(false) {}
+ bool success;
+} _ThriftHiveMetastore_getCurrentNotificationEventId_result__isset;
+
+class ThriftHiveMetastore_getCurrentNotificationEventId_result {
+ public:
+
+ ThriftHiveMetastore_getCurrentNotificationEventId_result() {
+ }
+
+ virtual ~ThriftHiveMetastore_getCurrentNotificationEventId_result() throw() {}
+
+ CurrentNotificationEventId success;
+
+ _ThriftHiveMetastore_getCurrentNotificationEventId_result__isset __isset;
+
+ void __set_success(const CurrentNotificationEventId& val) {
+ success = val;
+ }
+
+ bool operator == (const ThriftHiveMetastore_getCurrentNotificationEventId_result & rhs) const
+ {
+ if (!(success == rhs.success))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHiveMetastore_getCurrentNotificationEventId_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHiveMetastore_getCurrentNotificationEventId_result & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_getCurrentNotificationEventId_presult__isset {
+ _ThriftHiveMetastore_getCurrentNotificationEventId_presult__isset() : success(false) {}
+ bool success;
+} _ThriftHiveMetastore_getCurrentNotificationEventId_presult__isset;
+
+class ThriftHiveMetastore_getCurrentNotificationEventId_presult {
+ public:
+
+
+ virtual ~ThriftHiveMetastore_getCurrentNotificationEventId_presult() throw() {}
+
+ CurrentNotificationEventId* success;
+
+ _ThriftHiveMetastore_getCurrentNotificationEventId_presult__isset __isset;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
class ThriftHiveMetastoreClient : virtual public ThriftHiveMetastoreIf, public ::facebook::fb303::FacebookServiceClient {
public:
ThriftHiveMetastoreClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) :
@@ -16930,6 +17140,12 @@ class ThriftHiveMetastoreClient : virtua
void show_compact(ShowCompactResponse& _return, const ShowCompactRequest& rqst);
void send_show_compact(const ShowCompactRequest& rqst);
void recv_show_compact(ShowCompactResponse& _return);
+ void getNextNotification(NotificationEventResponse& _return, const NotificationEventRequest& rqst);
+ void send_getNextNotification(const NotificationEventRequest& rqst);
+ void recv_getNextNotification(NotificationEventResponse& _return);
+ void getCurrentNotificationEventId(CurrentNotificationEventId& _return);
+ void send_getCurrentNotificationEventId();
+ void recv_getCurrentNotificationEventId(CurrentNotificationEventId& _return);
};
class ThriftHiveMetastoreProcessor : public ::facebook::fb303::FacebookServiceProcessor {
@@ -17057,6 +17273,8 @@ class ThriftHiveMetastoreProcessor : pub
void process_heartbeat_txn_range(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
void process_compact(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
void process_show_compact(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+ void process_getNextNotification(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+ void process_getCurrentNotificationEventId(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
public:
ThriftHiveMetastoreProcessor(boost::shared_ptr<ThriftHiveMetastoreIf> iface) :
::facebook::fb303::FacebookServiceProcessor(iface),
@@ -17178,6 +17396,8 @@ class ThriftHiveMetastoreProcessor : pub
processMap_["heartbeat_txn_range"] = &ThriftHiveMetastoreProcessor::process_heartbeat_txn_range;
processMap_["compact"] = &ThriftHiveMetastoreProcessor::process_compact;
processMap_["show_compact"] = &ThriftHiveMetastoreProcessor::process_show_compact;
+ processMap_["getNextNotification"] = &ThriftHiveMetastoreProcessor::process_getNextNotification;
+ processMap_["getCurrentNotificationEventId"] = &ThriftHiveMetastoreProcessor::process_getCurrentNotificationEventId;
}
virtual ~ThriftHiveMetastoreProcessor() {}
@@ -18332,6 +18552,26 @@ class ThriftHiveMetastoreMultiface : vir
return;
}
+ void getNextNotification(NotificationEventResponse& _return, const NotificationEventRequest& rqst) {
+ size_t sz = ifaces_.size();
+ size_t i = 0;
+ for (; i < (sz - 1); ++i) {
+ ifaces_[i]->getNextNotification(_return, rqst);
+ }
+ ifaces_[i]->getNextNotification(_return, rqst);
+ return;
+ }
+
+ void getCurrentNotificationEventId(CurrentNotificationEventId& _return) {
+ size_t sz = ifaces_.size();
+ size_t i = 0;
+ for (; i < (sz - 1); ++i) {
+ ifaces_[i]->getCurrentNotificationEventId(_return);
+ }
+ ifaces_[i]->getCurrentNotificationEventId(_return);
+ return;
+ }
+
};
}}} // namespace
Modified: hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp
URL: http://svn.apache.org/viewvc/hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp?rev=1650145&r1=1650144&r2=1650145&view=diff
==============================================================================
--- hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp (original)
+++ hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp Wed Jan 7 20:15:10 2015
@@ -607,6 +607,16 @@ class ThriftHiveMetastoreHandler : virtu
printf("show_compact\n");
}
+ void getNextNotification(NotificationEventResponse& _return, const NotificationEventRequest& rqst) {
+ // Your implementation goes here
+ printf("getNextNotification\n");
+ }
+
+ void getCurrentNotificationEventId(CurrentNotificationEventId& _return) {
+ // Your implementation goes here
+ printf("getCurrentNotificationEventId\n");
+ }
+
};
int main(int argc, char **argv) {
Modified: hive/trunk/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
URL: http://svn.apache.org/viewvc/hive/trunk/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp?rev=1650145&r1=1650144&r2=1650145&view=diff
==============================================================================
--- hive/trunk/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp (original)
+++ hive/trunk/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp Wed Jan 7 20:15:10 2015
@@ -9282,6 +9282,374 @@ void swap(ShowCompactResponse &a, ShowCo
swap(a.compacts, b.compacts);
}
+const char* NotificationEventRequest::ascii_fingerprint = "6E578DA8AB10EED824A75534350EBAEF";
+const uint8_t NotificationEventRequest::binary_fingerprint[16] = {0x6E,0x57,0x8D,0xA8,0xAB,0x10,0xEE,0xD8,0x24,0xA7,0x55,0x34,0x35,0x0E,0xBA,0xEF};
+
+uint32_t NotificationEventRequest::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_lastEvent = 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_I64) {
+ xfer += iprot->readI64(this->lastEvent);
+ isset_lastEvent = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ xfer += iprot->readI32(this->maxEvents);
+ this->__isset.maxEvents = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_lastEvent)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t NotificationEventRequest::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("NotificationEventRequest");
+
+ xfer += oprot->writeFieldBegin("lastEvent", ::apache::thrift::protocol::T_I64, 1);
+ xfer += oprot->writeI64(this->lastEvent);
+ xfer += oprot->writeFieldEnd();
+
+ if (this->__isset.maxEvents) {
+ xfer += oprot->writeFieldBegin("maxEvents", ::apache::thrift::protocol::T_I32, 2);
+ xfer += oprot->writeI32(this->maxEvents);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(NotificationEventRequest &a, NotificationEventRequest &b) {
+ using ::std::swap;
+ swap(a.lastEvent, b.lastEvent);
+ swap(a.maxEvents, b.maxEvents);
+ swap(a.__isset, b.__isset);
+}
+
+const char* NotificationEvent::ascii_fingerprint = "ACAF0036D9999F3A389F490F5E22D369";
+const uint8_t NotificationEvent::binary_fingerprint[16] = {0xAC,0xAF,0x00,0x36,0xD9,0x99,0x9F,0x3A,0x38,0x9F,0x49,0x0F,0x5E,0x22,0xD3,0x69};
+
+uint32_t NotificationEvent::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_eventId = false;
+ bool isset_eventTime = false;
+ bool isset_eventType = false;
+ bool isset_message = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_I64) {
+ xfer += iprot->readI64(this->eventId);
+ isset_eventId = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ xfer += iprot->readI32(this->eventTime);
+ isset_eventTime = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->eventType);
+ isset_eventType = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->dbName);
+ this->__isset.dbName = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 5:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->tableName);
+ this->__isset.tableName = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 6:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->message);
+ isset_message = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_eventId)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_eventTime)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_eventType)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_message)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t NotificationEvent::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("NotificationEvent");
+
+ xfer += oprot->writeFieldBegin("eventId", ::apache::thrift::protocol::T_I64, 1);
+ xfer += oprot->writeI64(this->eventId);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("eventTime", ::apache::thrift::protocol::T_I32, 2);
+ xfer += oprot->writeI32(this->eventTime);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("eventType", ::apache::thrift::protocol::T_STRING, 3);
+ xfer += oprot->writeString(this->eventType);
+ xfer += oprot->writeFieldEnd();
+
+ if (this->__isset.dbName) {
+ xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 4);
+ xfer += oprot->writeString(this->dbName);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.tableName) {
+ xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 5);
+ xfer += oprot->writeString(this->tableName);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 6);
+ xfer += oprot->writeString(this->message);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(NotificationEvent &a, NotificationEvent &b) {
+ using ::std::swap;
+ swap(a.eventId, b.eventId);
+ swap(a.eventTime, b.eventTime);
+ swap(a.eventType, b.eventType);
+ swap(a.dbName, b.dbName);
+ swap(a.tableName, b.tableName);
+ swap(a.message, b.message);
+ swap(a.__isset, b.__isset);
+}
+
+const char* NotificationEventResponse::ascii_fingerprint = "EE3DB23399639114BCD1782A0FB01818";
+const uint8_t NotificationEventResponse::binary_fingerprint[16] = {0xEE,0x3D,0xB2,0x33,0x99,0x63,0x91,0x14,0xBC,0xD1,0x78,0x2A,0x0F,0xB0,0x18,0x18};
+
+uint32_t NotificationEventResponse::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_events = 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_LIST) {
+ {
+ this->events.clear();
+ uint32_t _size401;
+ ::apache::thrift::protocol::TType _etype404;
+ xfer += iprot->readListBegin(_etype404, _size401);
+ this->events.resize(_size401);
+ uint32_t _i405;
+ for (_i405 = 0; _i405 < _size401; ++_i405)
+ {
+ xfer += this->events[_i405].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ isset_events = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_events)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t NotificationEventResponse::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("NotificationEventResponse");
+
+ xfer += oprot->writeFieldBegin("events", ::apache::thrift::protocol::T_LIST, 1);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->events.size()));
+ std::vector<NotificationEvent> ::const_iterator _iter406;
+ for (_iter406 = this->events.begin(); _iter406 != this->events.end(); ++_iter406)
+ {
+ xfer += (*_iter406).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(NotificationEventResponse &a, NotificationEventResponse &b) {
+ using ::std::swap;
+ swap(a.events, b.events);
+}
+
+const char* CurrentNotificationEventId::ascii_fingerprint = "56A59CE7FFAF82BCA8A19FAACDE4FB75";
+const uint8_t CurrentNotificationEventId::binary_fingerprint[16] = {0x56,0xA5,0x9C,0xE7,0xFF,0xAF,0x82,0xBC,0xA8,0xA1,0x9F,0xAA,0xCD,0xE4,0xFB,0x75};
+
+uint32_t CurrentNotificationEventId::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_eventId = 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_I64) {
+ xfer += iprot->readI64(this->eventId);
+ isset_eventId = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_eventId)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t CurrentNotificationEventId::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("CurrentNotificationEventId");
+
+ xfer += oprot->writeFieldBegin("eventId", ::apache::thrift::protocol::T_I64, 1);
+ xfer += oprot->writeI64(this->eventId);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(CurrentNotificationEventId &a, CurrentNotificationEventId &b) {
+ using ::std::swap;
+ swap(a.eventId, b.eventId);
+}
+
const char* MetaException::ascii_fingerprint = "EFB929595D312AC8F305D5A794CFEDA1";
const uint8_t MetaException::binary_fingerprint[16] = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
Modified: hive/trunk/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h
URL: http://svn.apache.org/viewvc/hive/trunk/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h?rev=1650145&r1=1650144&r2=1650145&view=diff
==============================================================================
--- hive/trunk/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h (original)
+++ hive/trunk/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h Wed Jan 7 20:15:10 2015
@@ -5078,6 +5078,218 @@ class ShowCompactResponse {
void swap(ShowCompactResponse &a, ShowCompactResponse &b);
+typedef struct _NotificationEventRequest__isset {
+ _NotificationEventRequest__isset() : maxEvents(false) {}
+ bool maxEvents;
+} _NotificationEventRequest__isset;
+
+class NotificationEventRequest {
+ public:
+
+ static const char* ascii_fingerprint; // = "6E578DA8AB10EED824A75534350EBAEF";
+ static const uint8_t binary_fingerprint[16]; // = {0x6E,0x57,0x8D,0xA8,0xAB,0x10,0xEE,0xD8,0x24,0xA7,0x55,0x34,0x35,0x0E,0xBA,0xEF};
+
+ NotificationEventRequest() : lastEvent(0), maxEvents(0) {
+ }
+
+ virtual ~NotificationEventRequest() throw() {}
+
+ int64_t lastEvent;
+ int32_t maxEvents;
+
+ _NotificationEventRequest__isset __isset;
+
+ void __set_lastEvent(const int64_t val) {
+ lastEvent = val;
+ }
+
+ void __set_maxEvents(const int32_t val) {
+ maxEvents = val;
+ __isset.maxEvents = true;
+ }
+
+ bool operator == (const NotificationEventRequest & rhs) const
+ {
+ if (!(lastEvent == rhs.lastEvent))
+ return false;
+ if (__isset.maxEvents != rhs.__isset.maxEvents)
+ return false;
+ else if (__isset.maxEvents && !(maxEvents == rhs.maxEvents))
+ return false;
+ return true;
+ }
+ bool operator != (const NotificationEventRequest &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const NotificationEventRequest & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(NotificationEventRequest &a, NotificationEventRequest &b);
+
+typedef struct _NotificationEvent__isset {
+ _NotificationEvent__isset() : dbName(false), tableName(false) {}
+ bool dbName;
+ bool tableName;
+} _NotificationEvent__isset;
+
+class NotificationEvent {
+ public:
+
+ static const char* ascii_fingerprint; // = "ACAF0036D9999F3A389F490F5E22D369";
+ static const uint8_t binary_fingerprint[16]; // = {0xAC,0xAF,0x00,0x36,0xD9,0x99,0x9F,0x3A,0x38,0x9F,0x49,0x0F,0x5E,0x22,0xD3,0x69};
+
+ NotificationEvent() : eventId(0), eventTime(0), eventType(), dbName(), tableName(), message() {
+ }
+
+ virtual ~NotificationEvent() throw() {}
+
+ int64_t eventId;
+ int32_t eventTime;
+ std::string eventType;
+ std::string dbName;
+ std::string tableName;
+ std::string message;
+
+ _NotificationEvent__isset __isset;
+
+ void __set_eventId(const int64_t val) {
+ eventId = val;
+ }
+
+ void __set_eventTime(const int32_t val) {
+ eventTime = val;
+ }
+
+ void __set_eventType(const std::string& val) {
+ eventType = val;
+ }
+
+ void __set_dbName(const std::string& val) {
+ dbName = val;
+ __isset.dbName = true;
+ }
+
+ void __set_tableName(const std::string& val) {
+ tableName = val;
+ __isset.tableName = true;
+ }
+
+ void __set_message(const std::string& val) {
+ message = val;
+ }
+
+ bool operator == (const NotificationEvent & rhs) const
+ {
+ if (!(eventId == rhs.eventId))
+ return false;
+ if (!(eventTime == rhs.eventTime))
+ return false;
+ if (!(eventType == rhs.eventType))
+ return false;
+ if (__isset.dbName != rhs.__isset.dbName)
+ return false;
+ else if (__isset.dbName && !(dbName == rhs.dbName))
+ return false;
+ if (__isset.tableName != rhs.__isset.tableName)
+ return false;
+ else if (__isset.tableName && !(tableName == rhs.tableName))
+ return false;
+ if (!(message == rhs.message))
+ return false;
+ return true;
+ }
+ bool operator != (const NotificationEvent &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const NotificationEvent & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(NotificationEvent &a, NotificationEvent &b);
+
+
+class NotificationEventResponse {
+ public:
+
+ static const char* ascii_fingerprint; // = "EE3DB23399639114BCD1782A0FB01818";
+ static const uint8_t binary_fingerprint[16]; // = {0xEE,0x3D,0xB2,0x33,0x99,0x63,0x91,0x14,0xBC,0xD1,0x78,0x2A,0x0F,0xB0,0x18,0x18};
+
+ NotificationEventResponse() {
+ }
+
+ virtual ~NotificationEventResponse() throw() {}
+
+ std::vector<NotificationEvent> events;
+
+ void __set_events(const std::vector<NotificationEvent> & val) {
+ events = val;
+ }
+
+ bool operator == (const NotificationEventResponse & rhs) const
+ {
+ if (!(events == rhs.events))
+ return false;
+ return true;
+ }
+ bool operator != (const NotificationEventResponse &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const NotificationEventResponse & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(NotificationEventResponse &a, NotificationEventResponse &b);
+
+
+class CurrentNotificationEventId {
+ public:
+
+ static const char* ascii_fingerprint; // = "56A59CE7FFAF82BCA8A19FAACDE4FB75";
+ static const uint8_t binary_fingerprint[16]; // = {0x56,0xA5,0x9C,0xE7,0xFF,0xAF,0x82,0xBC,0xA8,0xA1,0x9F,0xAA,0xCD,0xE4,0xFB,0x75};
+
+ CurrentNotificationEventId() : eventId(0) {
+ }
+
+ virtual ~CurrentNotificationEventId() throw() {}
+
+ int64_t eventId;
+
+ void __set_eventId(const int64_t val) {
+ eventId = val;
+ }
+
+ bool operator == (const CurrentNotificationEventId & rhs) const
+ {
+ if (!(eventId == rhs.eventId))
+ return false;
+ return true;
+ }
+ bool operator != (const CurrentNotificationEventId &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const CurrentNotificationEventId & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(CurrentNotificationEventId &a, CurrentNotificationEventId &b);
+
typedef struct _MetaException__isset {
_MetaException__isset() : message(false) {}
bool message;
Added: hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/CurrentNotificationEventId.java
URL: http://svn.apache.org/viewvc/hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/CurrentNotificationEventId.java?rev=1650145&view=auto
==============================================================================
--- hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/CurrentNotificationEventId.java (added)
+++ hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/CurrentNotificationEventId.java Wed Jan 7 20:15:10 2015
@@ -0,0 +1,383 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.0)
+ *
+ * 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.commons.lang.builder.HashCodeBuilder;
+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 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 org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class CurrentNotificationEventId implements org.apache.thrift.TBase<CurrentNotificationEventId, CurrentNotificationEventId._Fields>, java.io.Serializable, Cloneable {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("CurrentNotificationEventId");
+
+ private static final org.apache.thrift.protocol.TField EVENT_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("eventId", org.apache.thrift.protocol.TType.I64, (short)1);
+
+ private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
+ static {
+ schemes.put(StandardScheme.class, new CurrentNotificationEventIdStandardSchemeFactory());
+ schemes.put(TupleScheme.class, new CurrentNotificationEventIdTupleSchemeFactory());
+ }
+
+ private long eventId; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ EVENT_ID((short)1, "eventId");
+
+ 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: // EVENT_ID
+ return EVENT_ID;
+ 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 __EVENTID_ISSET_ID = 0;
+ private byte __isset_bitfield = 0;
+ 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.EVENT_ID, new org.apache.thrift.meta_data.FieldMetaData("eventId", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+ metaDataMap = Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(CurrentNotificationEventId.class, metaDataMap);
+ }
+
+ public CurrentNotificationEventId() {
+ }
+
+ public CurrentNotificationEventId(
+ long eventId)
+ {
+ this();
+ this.eventId = eventId;
+ setEventIdIsSet(true);
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public CurrentNotificationEventId(CurrentNotificationEventId other) {
+ __isset_bitfield = other.__isset_bitfield;
+ this.eventId = other.eventId;
+ }
+
+ public CurrentNotificationEventId deepCopy() {
+ return new CurrentNotificationEventId(this);
+ }
+
+ @Override
+ public void clear() {
+ setEventIdIsSet(false);
+ this.eventId = 0;
+ }
+
+ public long getEventId() {
+ return this.eventId;
+ }
+
+ public void setEventId(long eventId) {
+ this.eventId = eventId;
+ setEventIdIsSet(true);
+ }
+
+ public void unsetEventId() {
+ __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __EVENTID_ISSET_ID);
+ }
+
+ /** Returns true if field eventId is set (has been assigned a value) and false otherwise */
+ public boolean isSetEventId() {
+ return EncodingUtils.testBit(__isset_bitfield, __EVENTID_ISSET_ID);
+ }
+
+ public void setEventIdIsSet(boolean value) {
+ __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __EVENTID_ISSET_ID, value);
+ }
+
+ public void setFieldValue(_Fields field, Object value) {
+ switch (field) {
+ case EVENT_ID:
+ if (value == null) {
+ unsetEventId();
+ } else {
+ setEventId((Long)value);
+ }
+ break;
+
+ }
+ }
+
+ public Object getFieldValue(_Fields field) {
+ switch (field) {
+ case EVENT_ID:
+ return Long.valueOf(getEventId());
+
+ }
+ 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 EVENT_ID:
+ return isSetEventId();
+ }
+ throw new IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(Object that) {
+ if (that == null)
+ return false;
+ if (that instanceof CurrentNotificationEventId)
+ return this.equals((CurrentNotificationEventId)that);
+ return false;
+ }
+
+ public boolean equals(CurrentNotificationEventId that) {
+ if (that == null)
+ return false;
+
+ boolean this_present_eventId = true;
+ boolean that_present_eventId = true;
+ if (this_present_eventId || that_present_eventId) {
+ if (!(this_present_eventId && that_present_eventId))
+ return false;
+ if (this.eventId != that.eventId)
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ HashCodeBuilder builder = new HashCodeBuilder();
+
+ boolean present_eventId = true;
+ builder.append(present_eventId);
+ if (present_eventId)
+ builder.append(eventId);
+
+ return builder.toHashCode();
+ }
+
+ public int compareTo(CurrentNotificationEventId other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+ CurrentNotificationEventId typedOther = (CurrentNotificationEventId)other;
+
+ lastComparison = Boolean.valueOf(isSetEventId()).compareTo(typedOther.isSetEventId());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetEventId()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.eventId, typedOther.eventId);
+ 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("CurrentNotificationEventId(");
+ boolean first = true;
+
+ sb.append("eventId:");
+ sb.append(this.eventId);
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (!isSetEventId()) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'eventId' 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 CurrentNotificationEventIdStandardSchemeFactory implements SchemeFactory {
+ public CurrentNotificationEventIdStandardScheme getScheme() {
+ return new CurrentNotificationEventIdStandardScheme();
+ }
+ }
+
+ private static class CurrentNotificationEventIdStandardScheme extends StandardScheme<CurrentNotificationEventId> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, CurrentNotificationEventId 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: // EVENT_ID
+ if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
+ struct.eventId = iprot.readI64();
+ struct.setEventIdIsSet(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, CurrentNotificationEventId struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ oprot.writeFieldBegin(EVENT_ID_FIELD_DESC);
+ oprot.writeI64(struct.eventId);
+ oprot.writeFieldEnd();
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class CurrentNotificationEventIdTupleSchemeFactory implements SchemeFactory {
+ public CurrentNotificationEventIdTupleScheme getScheme() {
+ return new CurrentNotificationEventIdTupleScheme();
+ }
+ }
+
+ private static class CurrentNotificationEventIdTupleScheme extends TupleScheme<CurrentNotificationEventId> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, CurrentNotificationEventId struct) throws org.apache.thrift.TException {
+ TTupleProtocol oprot = (TTupleProtocol) prot;
+ oprot.writeI64(struct.eventId);
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, CurrentNotificationEventId struct) throws org.apache.thrift.TException {
+ TTupleProtocol iprot = (TTupleProtocol) prot;
+ struct.eventId = iprot.readI64();
+ struct.setEventIdIsSet(true);
+ }
+ }
+
+}
+
Added: hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/NotificationEvent.java
URL: http://svn.apache.org/viewvc/hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/NotificationEvent.java?rev=1650145&view=auto
==============================================================================
--- hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/NotificationEvent.java (added)
+++ hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/NotificationEvent.java Wed Jan 7 20:15:10 2015
@@ -0,0 +1,896 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.0)
+ *
+ * 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.commons.lang.builder.HashCodeBuilder;
+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 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 org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class NotificationEvent implements org.apache.thrift.TBase<NotificationEvent, NotificationEvent._Fields>, java.io.Serializable, Cloneable {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("NotificationEvent");
+
+ private static final org.apache.thrift.protocol.TField EVENT_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("eventId", org.apache.thrift.protocol.TType.I64, (short)1);
+ private static final org.apache.thrift.protocol.TField EVENT_TIME_FIELD_DESC = new org.apache.thrift.protocol.TField("eventTime", org.apache.thrift.protocol.TType.I32, (short)2);
+ private static final org.apache.thrift.protocol.TField EVENT_TYPE_FIELD_DESC = new org.apache.thrift.protocol.TField("eventType", org.apache.thrift.protocol.TType.STRING, (short)3);
+ private static final org.apache.thrift.protocol.TField DB_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("dbName", org.apache.thrift.protocol.TType.STRING, (short)4);
+ private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRING, (short)5);
+ private static final org.apache.thrift.protocol.TField MESSAGE_FIELD_DESC = new org.apache.thrift.protocol.TField("message", org.apache.thrift.protocol.TType.STRING, (short)6);
+
+ private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
+ static {
+ schemes.put(StandardScheme.class, new NotificationEventStandardSchemeFactory());
+ schemes.put(TupleScheme.class, new NotificationEventTupleSchemeFactory());
+ }
+
+ private long eventId; // required
+ private int eventTime; // required
+ private String eventType; // required
+ private String dbName; // optional
+ private String tableName; // optional
+ private String message; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ EVENT_ID((short)1, "eventId"),
+ EVENT_TIME((short)2, "eventTime"),
+ EVENT_TYPE((short)3, "eventType"),
+ DB_NAME((short)4, "dbName"),
+ TABLE_NAME((short)5, "tableName"),
+ MESSAGE((short)6, "message");
+
+ 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: // EVENT_ID
+ return EVENT_ID;
+ case 2: // EVENT_TIME
+ return EVENT_TIME;
+ case 3: // EVENT_TYPE
+ return EVENT_TYPE;
+ case 4: // DB_NAME
+ return DB_NAME;
+ case 5: // TABLE_NAME
+ return TABLE_NAME;
+ case 6: // MESSAGE
+ return MESSAGE;
+ 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 __EVENTID_ISSET_ID = 0;
+ private static final int __EVENTTIME_ISSET_ID = 1;
+ private byte __isset_bitfield = 0;
+ private _Fields optionals[] = {_Fields.DB_NAME,_Fields.TABLE_NAME};
+ 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.EVENT_ID, new org.apache.thrift.meta_data.FieldMetaData("eventId", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+ tmpMap.put(_Fields.EVENT_TIME, new org.apache.thrift.meta_data.FieldMetaData("eventTime", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+ tmpMap.put(_Fields.EVENT_TYPE, new org.apache.thrift.meta_data.FieldMetaData("eventType", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ tmpMap.put(_Fields.DB_NAME, new org.apache.thrift.meta_data.FieldMetaData("dbName", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ tmpMap.put(_Fields.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ tmpMap.put(_Fields.MESSAGE, new org.apache.thrift.meta_data.FieldMetaData("message", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ metaDataMap = Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(NotificationEvent.class, metaDataMap);
+ }
+
+ public NotificationEvent() {
+ }
+
+ public NotificationEvent(
+ long eventId,
+ int eventTime,
+ String eventType,
+ String message)
+ {
+ this();
+ this.eventId = eventId;
+ setEventIdIsSet(true);
+ this.eventTime = eventTime;
+ setEventTimeIsSet(true);
+ this.eventType = eventType;
+ this.message = message;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public NotificationEvent(NotificationEvent other) {
+ __isset_bitfield = other.__isset_bitfield;
+ this.eventId = other.eventId;
+ this.eventTime = other.eventTime;
+ if (other.isSetEventType()) {
+ this.eventType = other.eventType;
+ }
+ if (other.isSetDbName()) {
+ this.dbName = other.dbName;
+ }
+ if (other.isSetTableName()) {
+ this.tableName = other.tableName;
+ }
+ if (other.isSetMessage()) {
+ this.message = other.message;
+ }
+ }
+
+ public NotificationEvent deepCopy() {
+ return new NotificationEvent(this);
+ }
+
+ @Override
+ public void clear() {
+ setEventIdIsSet(false);
+ this.eventId = 0;
+ setEventTimeIsSet(false);
+ this.eventTime = 0;
+ this.eventType = null;
+ this.dbName = null;
+ this.tableName = null;
+ this.message = null;
+ }
+
+ public long getEventId() {
+ return this.eventId;
+ }
+
+ public void setEventId(long eventId) {
+ this.eventId = eventId;
+ setEventIdIsSet(true);
+ }
+
+ public void unsetEventId() {
+ __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __EVENTID_ISSET_ID);
+ }
+
+ /** Returns true if field eventId is set (has been assigned a value) and false otherwise */
+ public boolean isSetEventId() {
+ return EncodingUtils.testBit(__isset_bitfield, __EVENTID_ISSET_ID);
+ }
+
+ public void setEventIdIsSet(boolean value) {
+ __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __EVENTID_ISSET_ID, value);
+ }
+
+ public int getEventTime() {
+ return this.eventTime;
+ }
+
+ public void setEventTime(int eventTime) {
+ this.eventTime = eventTime;
+ setEventTimeIsSet(true);
+ }
+
+ public void unsetEventTime() {
+ __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __EVENTTIME_ISSET_ID);
+ }
+
+ /** Returns true if field eventTime is set (has been assigned a value) and false otherwise */
+ public boolean isSetEventTime() {
+ return EncodingUtils.testBit(__isset_bitfield, __EVENTTIME_ISSET_ID);
+ }
+
+ public void setEventTimeIsSet(boolean value) {
+ __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __EVENTTIME_ISSET_ID, value);
+ }
+
+ public String getEventType() {
+ return this.eventType;
+ }
+
+ public void setEventType(String eventType) {
+ this.eventType = eventType;
+ }
+
+ public void unsetEventType() {
+ this.eventType = null;
+ }
+
+ /** Returns true if field eventType is set (has been assigned a value) and false otherwise */
+ public boolean isSetEventType() {
+ return this.eventType != null;
+ }
+
+ public void setEventTypeIsSet(boolean value) {
+ if (!value) {
+ this.eventType = null;
+ }
+ }
+
+ public String getDbName() {
+ return this.dbName;
+ }
+
+ public void setDbName(String dbName) {
+ this.dbName = dbName;
+ }
+
+ public void unsetDbName() {
+ this.dbName = null;
+ }
+
+ /** Returns true if field dbName is set (has been assigned a value) and false otherwise */
+ public boolean isSetDbName() {
+ return this.dbName != null;
+ }
+
+ public void setDbNameIsSet(boolean value) {
+ if (!value) {
+ this.dbName = null;
+ }
+ }
+
+ public String getTableName() {
+ return this.tableName;
+ }
+
+ public void setTableName(String tableName) {
+ this.tableName = tableName;
+ }
+
+ public void unsetTableName() {
+ this.tableName = null;
+ }
+
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
+ }
+
+ public void setTableNameIsSet(boolean value) {
+ if (!value) {
+ this.tableName = null;
+ }
+ }
+
+ public String getMessage() {
+ return this.message;
+ }
+
+ public void setMessage(String message) {
+ this.message = message;
+ }
+
+ public void unsetMessage() {
+ this.message = null;
+ }
+
+ /** Returns true if field message is set (has been assigned a value) and false otherwise */
+ public boolean isSetMessage() {
+ return this.message != null;
+ }
+
+ public void setMessageIsSet(boolean value) {
+ if (!value) {
+ this.message = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, Object value) {
+ switch (field) {
+ case EVENT_ID:
+ if (value == null) {
+ unsetEventId();
+ } else {
+ setEventId((Long)value);
+ }
+ break;
+
+ case EVENT_TIME:
+ if (value == null) {
+ unsetEventTime();
+ } else {
+ setEventTime((Integer)value);
+ }
+ break;
+
+ case EVENT_TYPE:
+ if (value == null) {
+ unsetEventType();
+ } else {
+ setEventType((String)value);
+ }
+ break;
+
+ case DB_NAME:
+ if (value == null) {
+ unsetDbName();
+ } else {
+ setDbName((String)value);
+ }
+ break;
+
+ case TABLE_NAME:
+ if (value == null) {
+ unsetTableName();
+ } else {
+ setTableName((String)value);
+ }
+ break;
+
+ case MESSAGE:
+ if (value == null) {
+ unsetMessage();
+ } else {
+ setMessage((String)value);
+ }
+ break;
+
+ }
+ }
+
+ public Object getFieldValue(_Fields field) {
+ switch (field) {
+ case EVENT_ID:
+ return Long.valueOf(getEventId());
+
+ case EVENT_TIME:
+ return Integer.valueOf(getEventTime());
+
+ case EVENT_TYPE:
+ return getEventType();
+
+ case DB_NAME:
+ return getDbName();
+
+ case TABLE_NAME:
+ return getTableName();
+
+ case MESSAGE:
+ return getMessage();
+
+ }
+ 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 EVENT_ID:
+ return isSetEventId();
+ case EVENT_TIME:
+ return isSetEventTime();
+ case EVENT_TYPE:
+ return isSetEventType();
+ case DB_NAME:
+ return isSetDbName();
+ case TABLE_NAME:
+ return isSetTableName();
+ case MESSAGE:
+ return isSetMessage();
+ }
+ throw new IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(Object that) {
+ if (that == null)
+ return false;
+ if (that instanceof NotificationEvent)
+ return this.equals((NotificationEvent)that);
+ return false;
+ }
+
+ public boolean equals(NotificationEvent that) {
+ if (that == null)
+ return false;
+
+ boolean this_present_eventId = true;
+ boolean that_present_eventId = true;
+ if (this_present_eventId || that_present_eventId) {
+ if (!(this_present_eventId && that_present_eventId))
+ return false;
+ if (this.eventId != that.eventId)
+ return false;
+ }
+
+ boolean this_present_eventTime = true;
+ boolean that_present_eventTime = true;
+ if (this_present_eventTime || that_present_eventTime) {
+ if (!(this_present_eventTime && that_present_eventTime))
+ return false;
+ if (this.eventTime != that.eventTime)
+ return false;
+ }
+
+ boolean this_present_eventType = true && this.isSetEventType();
+ boolean that_present_eventType = true && that.isSetEventType();
+ if (this_present_eventType || that_present_eventType) {
+ if (!(this_present_eventType && that_present_eventType))
+ return false;
+ if (!this.eventType.equals(that.eventType))
+ return false;
+ }
+
+ boolean this_present_dbName = true && this.isSetDbName();
+ boolean that_present_dbName = true && that.isSetDbName();
+ if (this_present_dbName || that_present_dbName) {
+ if (!(this_present_dbName && that_present_dbName))
+ return false;
+ if (!this.dbName.equals(that.dbName))
+ return false;
+ }
+
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
+ return false;
+ if (!this.tableName.equals(that.tableName))
+ return false;
+ }
+
+ boolean this_present_message = true && this.isSetMessage();
+ boolean that_present_message = true && that.isSetMessage();
+ if (this_present_message || that_present_message) {
+ if (!(this_present_message && that_present_message))
+ return false;
+ if (!this.message.equals(that.message))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ HashCodeBuilder builder = new HashCodeBuilder();
+
+ boolean present_eventId = true;
+ builder.append(present_eventId);
+ if (present_eventId)
+ builder.append(eventId);
+
+ boolean present_eventTime = true;
+ builder.append(present_eventTime);
+ if (present_eventTime)
+ builder.append(eventTime);
+
+ boolean present_eventType = true && (isSetEventType());
+ builder.append(present_eventType);
+ if (present_eventType)
+ builder.append(eventType);
+
+ boolean present_dbName = true && (isSetDbName());
+ builder.append(present_dbName);
+ if (present_dbName)
+ builder.append(dbName);
+
+ boolean present_tableName = true && (isSetTableName());
+ builder.append(present_tableName);
+ if (present_tableName)
+ builder.append(tableName);
+
+ boolean present_message = true && (isSetMessage());
+ builder.append(present_message);
+ if (present_message)
+ builder.append(message);
+
+ return builder.toHashCode();
+ }
+
+ public int compareTo(NotificationEvent other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+ NotificationEvent typedOther = (NotificationEvent)other;
+
+ lastComparison = Boolean.valueOf(isSetEventId()).compareTo(typedOther.isSetEventId());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetEventId()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.eventId, typedOther.eventId);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = Boolean.valueOf(isSetEventTime()).compareTo(typedOther.isSetEventTime());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetEventTime()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.eventTime, typedOther.eventTime);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = Boolean.valueOf(isSetEventType()).compareTo(typedOther.isSetEventType());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetEventType()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.eventType, typedOther.eventType);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = Boolean.valueOf(isSetDbName()).compareTo(typedOther.isSetDbName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetDbName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.dbName, typedOther.dbName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = Boolean.valueOf(isSetTableName()).compareTo(typedOther.isSetTableName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, typedOther.tableName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = Boolean.valueOf(isSetMessage()).compareTo(typedOther.isSetMessage());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetMessage()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.message, typedOther.message);
+ 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("NotificationEvent(");
+ boolean first = true;
+
+ sb.append("eventId:");
+ sb.append(this.eventId);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("eventTime:");
+ sb.append(this.eventTime);
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("eventType:");
+ if (this.eventType == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.eventType);
+ }
+ first = false;
+ if (isSetDbName()) {
+ if (!first) sb.append(", ");
+ sb.append("dbName:");
+ if (this.dbName == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.dbName);
+ }
+ first = false;
+ }
+ if (isSetTableName()) {
+ if (!first) sb.append(", ");
+ sb.append("tableName:");
+ if (this.tableName == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.tableName);
+ }
+ first = false;
+ }
+ if (!first) sb.append(", ");
+ sb.append("message:");
+ if (this.message == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.message);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (!isSetEventId()) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'eventId' is unset! Struct:" + toString());
+ }
+
+ if (!isSetEventTime()) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'eventTime' is unset! Struct:" + toString());
+ }
+
+ if (!isSetEventType()) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'eventType' is unset! Struct:" + toString());
+ }
+
+ if (!isSetMessage()) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'message' 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 NotificationEventStandardSchemeFactory implements SchemeFactory {
+ public NotificationEventStandardScheme getScheme() {
+ return new NotificationEventStandardScheme();
+ }
+ }
+
+ private static class NotificationEventStandardScheme extends StandardScheme<NotificationEvent> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, NotificationEvent 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: // EVENT_ID
+ if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
+ struct.eventId = iprot.readI64();
+ struct.setEventIdIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // EVENT_TIME
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.eventTime = iprot.readI32();
+ struct.setEventTimeIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // EVENT_TYPE
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.eventType = iprot.readString();
+ struct.setEventTypeIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 4: // DB_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.dbName = iprot.readString();
+ struct.setDbNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 5: // TABLE_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.tableName = iprot.readString();
+ struct.setTableNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 6: // MESSAGE
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.message = iprot.readString();
+ struct.setMessageIsSet(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, NotificationEvent struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ oprot.writeFieldBegin(EVENT_ID_FIELD_DESC);
+ oprot.writeI64(struct.eventId);
+ oprot.writeFieldEnd();
+ oprot.writeFieldBegin(EVENT_TIME_FIELD_DESC);
+ oprot.writeI32(struct.eventTime);
+ oprot.writeFieldEnd();
+ if (struct.eventType != null) {
+ oprot.writeFieldBegin(EVENT_TYPE_FIELD_DESC);
+ oprot.writeString(struct.eventType);
+ oprot.writeFieldEnd();
+ }
+ if (struct.dbName != null) {
+ if (struct.isSetDbName()) {
+ oprot.writeFieldBegin(DB_NAME_FIELD_DESC);
+ oprot.writeString(struct.dbName);
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.tableName != null) {
+ if (struct.isSetTableName()) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ oprot.writeString(struct.tableName);
+ oprot.writeFieldEnd();
+ }
+ }
+ if (struct.message != null) {
+ oprot.writeFieldBegin(MESSAGE_FIELD_DESC);
+ oprot.writeString(struct.message);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class NotificationEventTupleSchemeFactory implements SchemeFactory {
+ public NotificationEventTupleScheme getScheme() {
+ return new NotificationEventTupleScheme();
+ }
+ }
+
+ private static class NotificationEventTupleScheme extends TupleScheme<NotificationEvent> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, NotificationEvent struct) throws org.apache.thrift.TException {
+ TTupleProtocol oprot = (TTupleProtocol) prot;
+ oprot.writeI64(struct.eventId);
+ oprot.writeI32(struct.eventTime);
+ oprot.writeString(struct.eventType);
+ oprot.writeString(struct.message);
+ BitSet optionals = new BitSet();
+ if (struct.isSetDbName()) {
+ optionals.set(0);
+ }
+ if (struct.isSetTableName()) {
+ optionals.set(1);
+ }
+ oprot.writeBitSet(optionals, 2);
+ if (struct.isSetDbName()) {
+ oprot.writeString(struct.dbName);
+ }
+ if (struct.isSetTableName()) {
+ oprot.writeString(struct.tableName);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, NotificationEvent struct) throws org.apache.thrift.TException {
+ TTupleProtocol iprot = (TTupleProtocol) prot;
+ struct.eventId = iprot.readI64();
+ struct.setEventIdIsSet(true);
+ struct.eventTime = iprot.readI32();
+ struct.setEventTimeIsSet(true);
+ struct.eventType = iprot.readString();
+ struct.setEventTypeIsSet(true);
+ struct.message = iprot.readString();
+ struct.setMessageIsSet(true);
+ BitSet incoming = iprot.readBitSet(2);
+ if (incoming.get(0)) {
+ struct.dbName = iprot.readString();
+ struct.setDbNameIsSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.tableName = iprot.readString();
+ struct.setTableNameIsSet(true);
+ }
+ }
+ }
+
+}
+