hive-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From xu...@apache.org
Subject [18/54] [abbrv] hive git commit: HIVE-9152 - Dynamic Partition Pruning [Spark Branch] (Chao Sun, reviewed by Xuefu Zhang and Chengxiang Li)
Date Fri, 31 Jul 2015 22:57:19 GMT
http://git-wip-us.apache.org/repos/asf/hive/blob/42216997/serde/src/gen/thrift/gen-cpp/megastruct_types.cpp
----------------------------------------------------------------------
diff --git a/serde/src/gen/thrift/gen-cpp/megastruct_types.cpp b/serde/src/gen/thrift/gen-cpp/megastruct_types.cpp
index 2d46b7f..6123f7d 100644
--- a/serde/src/gen/thrift/gen-cpp/megastruct_types.cpp
+++ b/serde/src/gen/thrift/gen-cpp/megastruct_types.cpp
@@ -1,5 +1,5 @@
 /**
- * Autogenerated by Thrift Compiler (0.9.0)
+ * Autogenerated by Thrift Compiler (0.9.2)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  *  @generated
@@ -7,6 +7,9 @@
 #include "megastruct_types.h"
 
 #include <algorithm>
+#include <ostream>
+
+#include <thrift/TToString.h>
 
 
 
@@ -20,6 +23,21 @@ const char* _kMyEnumNames[] = {
 };
 const std::map<int, const char*> _MyEnum_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(2, _kMyEnumValues, _kMyEnumNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
 
+
+MiniStruct::~MiniStruct() throw() {
+}
+
+
+void MiniStruct::__set_my_string(const std::string& val) {
+  this->my_string = val;
+__isset.my_string = true;
+}
+
+void MiniStruct::__set_my_enum(const MyEnum::type val) {
+  this->my_enum = val;
+__isset.my_enum = true;
+}
+
 const char* MiniStruct::ascii_fingerprint = "4ED2B10931906B61ED0B1592EE860A37";
 const uint8_t MiniStruct::binary_fingerprint[16] = {0x4E,0xD2,0xB1,0x09,0x31,0x90,0x6B,0x61,0xED,0x0B,0x15,0x92,0xEE,0x86,0x0A,0x37};
 
@@ -75,6 +93,7 @@ uint32_t MiniStruct::read(::apache::thrift::protocol::TProtocol* iprot) {
 
 uint32_t MiniStruct::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
   xfer += oprot->writeStructBegin("MiniStruct");
 
   if (this->__isset.my_string) {
@@ -89,6 +108,7 @@ uint32_t MiniStruct::write(::apache::thrift::protocol::TProtocol* oprot) const {
   }
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
   return xfer;
 }
 
@@ -99,6 +119,131 @@ void swap(MiniStruct &a, MiniStruct &b) {
   swap(a.__isset, b.__isset);
 }
 
+MiniStruct::MiniStruct(const MiniStruct& other1) {
+  my_string = other1.my_string;
+  my_enum = other1.my_enum;
+  __isset = other1.__isset;
+}
+MiniStruct& MiniStruct::operator=(const MiniStruct& other2) {
+  my_string = other2.my_string;
+  my_enum = other2.my_enum;
+  __isset = other2.__isset;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const MiniStruct& obj) {
+  using apache::thrift::to_string;
+  out << "MiniStruct(";
+  out << "my_string="; (obj.__isset.my_string ? (out << to_string(obj.my_string)) : (out << "<null>"));
+  out << ", " << "my_enum="; (obj.__isset.my_enum ? (out << to_string(obj.my_enum)) : (out << "<null>"));
+  out << ")";
+  return out;
+}
+
+
+MegaStruct::~MegaStruct() throw() {
+}
+
+
+void MegaStruct::__set_my_bool(const bool val) {
+  this->my_bool = val;
+__isset.my_bool = true;
+}
+
+void MegaStruct::__set_my_byte(const int8_t val) {
+  this->my_byte = val;
+__isset.my_byte = true;
+}
+
+void MegaStruct::__set_my_16bit_int(const int16_t val) {
+  this->my_16bit_int = val;
+__isset.my_16bit_int = true;
+}
+
+void MegaStruct::__set_my_32bit_int(const int32_t val) {
+  this->my_32bit_int = val;
+__isset.my_32bit_int = true;
+}
+
+void MegaStruct::__set_my_64bit_int(const int64_t val) {
+  this->my_64bit_int = val;
+__isset.my_64bit_int = true;
+}
+
+void MegaStruct::__set_my_double(const double val) {
+  this->my_double = val;
+__isset.my_double = true;
+}
+
+void MegaStruct::__set_my_string(const std::string& val) {
+  this->my_string = val;
+__isset.my_string = true;
+}
+
+void MegaStruct::__set_my_binary(const std::string& val) {
+  this->my_binary = val;
+__isset.my_binary = true;
+}
+
+void MegaStruct::__set_my_string_string_map(const std::map<std::string, std::string> & val) {
+  this->my_string_string_map = val;
+__isset.my_string_string_map = true;
+}
+
+void MegaStruct::__set_my_string_enum_map(const std::map<std::string, MyEnum::type> & val) {
+  this->my_string_enum_map = val;
+__isset.my_string_enum_map = true;
+}
+
+void MegaStruct::__set_my_enum_string_map(const std::map<MyEnum::type, std::string> & val) {
+  this->my_enum_string_map = val;
+__isset.my_enum_string_map = true;
+}
+
+void MegaStruct::__set_my_enum_struct_map(const std::map<MyEnum::type, MiniStruct> & val) {
+  this->my_enum_struct_map = val;
+__isset.my_enum_struct_map = true;
+}
+
+void MegaStruct::__set_my_enum_stringlist_map(const std::map<MyEnum::type, std::vector<std::string> > & val) {
+  this->my_enum_stringlist_map = val;
+__isset.my_enum_stringlist_map = true;
+}
+
+void MegaStruct::__set_my_enum_structlist_map(const std::map<MyEnum::type, std::vector<MiniStruct> > & val) {
+  this->my_enum_structlist_map = val;
+__isset.my_enum_structlist_map = true;
+}
+
+void MegaStruct::__set_my_stringlist(const std::vector<std::string> & val) {
+  this->my_stringlist = val;
+__isset.my_stringlist = true;
+}
+
+void MegaStruct::__set_my_structlist(const std::vector<MiniStruct> & val) {
+  this->my_structlist = val;
+__isset.my_structlist = true;
+}
+
+void MegaStruct::__set_my_enumlist(const std::vector<MyEnum::type> & val) {
+  this->my_enumlist = val;
+__isset.my_enumlist = true;
+}
+
+void MegaStruct::__set_my_stringset(const std::set<std::string> & val) {
+  this->my_stringset = val;
+__isset.my_stringset = true;
+}
+
+void MegaStruct::__set_my_enumset(const std::set<MyEnum::type> & val) {
+  this->my_enumset = val;
+__isset.my_enumset = true;
+}
+
+void MegaStruct::__set_my_structset(const std::set<MiniStruct> & val) {
+  this->my_structset = val;
+__isset.my_structset = true;
+}
+
 const char* MegaStruct::ascii_fingerprint = "9979EEF0CA19988228E64220A3AA9120";
 const uint8_t MegaStruct::binary_fingerprint[16] = {0x99,0x79,0xEE,0xF0,0xCA,0x19,0x98,0x82,0x28,0xE6,0x42,0x20,0xA3,0xAA,0x91,0x20};
 
@@ -190,17 +335,17 @@ uint32_t MegaStruct::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_MAP) {
           {
             this->my_string_string_map.clear();
-            uint32_t _size1;
-            ::apache::thrift::protocol::TType _ktype2;
-            ::apache::thrift::protocol::TType _vtype3;
-            xfer += iprot->readMapBegin(_ktype2, _vtype3, _size1);
-            uint32_t _i5;
-            for (_i5 = 0; _i5 < _size1; ++_i5)
+            uint32_t _size3;
+            ::apache::thrift::protocol::TType _ktype4;
+            ::apache::thrift::protocol::TType _vtype5;
+            xfer += iprot->readMapBegin(_ktype4, _vtype5, _size3);
+            uint32_t _i7;
+            for (_i7 = 0; _i7 < _size3; ++_i7)
             {
-              std::string _key6;
-              xfer += iprot->readString(_key6);
-              std::string& _val7 = this->my_string_string_map[_key6];
-              xfer += iprot->readString(_val7);
+              std::string _key8;
+              xfer += iprot->readString(_key8);
+              std::string& _val9 = this->my_string_string_map[_key8];
+              xfer += iprot->readString(_val9);
             }
             xfer += iprot->readMapEnd();
           }
@@ -213,19 +358,19 @@ uint32_t MegaStruct::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_MAP) {
           {
             this->my_string_enum_map.clear();
-            uint32_t _size8;
-            ::apache::thrift::protocol::TType _ktype9;
-            ::apache::thrift::protocol::TType _vtype10;
-            xfer += iprot->readMapBegin(_ktype9, _vtype10, _size8);
-            uint32_t _i12;
-            for (_i12 = 0; _i12 < _size8; ++_i12)
+            uint32_t _size10;
+            ::apache::thrift::protocol::TType _ktype11;
+            ::apache::thrift::protocol::TType _vtype12;
+            xfer += iprot->readMapBegin(_ktype11, _vtype12, _size10);
+            uint32_t _i14;
+            for (_i14 = 0; _i14 < _size10; ++_i14)
             {
-              std::string _key13;
-              xfer += iprot->readString(_key13);
-              MyEnum::type& _val14 = this->my_string_enum_map[_key13];
-              int32_t ecast15;
-              xfer += iprot->readI32(ecast15);
-              _val14 = (MyEnum::type)ecast15;
+              std::string _key15;
+              xfer += iprot->readString(_key15);
+              MyEnum::type& _val16 = this->my_string_enum_map[_key15];
+              int32_t ecast17;
+              xfer += iprot->readI32(ecast17);
+              _val16 = (MyEnum::type)ecast17;
             }
             xfer += iprot->readMapEnd();
           }
@@ -238,19 +383,19 @@ uint32_t MegaStruct::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_MAP) {
           {
             this->my_enum_string_map.clear();
-            uint32_t _size16;
-            ::apache::thrift::protocol::TType _ktype17;
-            ::apache::thrift::protocol::TType _vtype18;
-            xfer += iprot->readMapBegin(_ktype17, _vtype18, _size16);
-            uint32_t _i20;
-            for (_i20 = 0; _i20 < _size16; ++_i20)
+            uint32_t _size18;
+            ::apache::thrift::protocol::TType _ktype19;
+            ::apache::thrift::protocol::TType _vtype20;
+            xfer += iprot->readMapBegin(_ktype19, _vtype20, _size18);
+            uint32_t _i22;
+            for (_i22 = 0; _i22 < _size18; ++_i22)
             {
-              MyEnum::type _key21;
-              int32_t ecast23;
-              xfer += iprot->readI32(ecast23);
-              _key21 = (MyEnum::type)ecast23;
-              std::string& _val22 = this->my_enum_string_map[_key21];
-              xfer += iprot->readString(_val22);
+              MyEnum::type _key23;
+              int32_t ecast25;
+              xfer += iprot->readI32(ecast25);
+              _key23 = (MyEnum::type)ecast25;
+              std::string& _val24 = this->my_enum_string_map[_key23];
+              xfer += iprot->readString(_val24);
             }
             xfer += iprot->readMapEnd();
           }
@@ -263,19 +408,19 @@ uint32_t MegaStruct::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_MAP) {
           {
             this->my_enum_struct_map.clear();
-            uint32_t _size24;
-            ::apache::thrift::protocol::TType _ktype25;
-            ::apache::thrift::protocol::TType _vtype26;
-            xfer += iprot->readMapBegin(_ktype25, _vtype26, _size24);
-            uint32_t _i28;
-            for (_i28 = 0; _i28 < _size24; ++_i28)
+            uint32_t _size26;
+            ::apache::thrift::protocol::TType _ktype27;
+            ::apache::thrift::protocol::TType _vtype28;
+            xfer += iprot->readMapBegin(_ktype27, _vtype28, _size26);
+            uint32_t _i30;
+            for (_i30 = 0; _i30 < _size26; ++_i30)
             {
-              MyEnum::type _key29;
-              int32_t ecast31;
-              xfer += iprot->readI32(ecast31);
-              _key29 = (MyEnum::type)ecast31;
-              MiniStruct& _val30 = this->my_enum_struct_map[_key29];
-              xfer += _val30.read(iprot);
+              MyEnum::type _key31;
+              int32_t ecast33;
+              xfer += iprot->readI32(ecast33);
+              _key31 = (MyEnum::type)ecast33;
+              MiniStruct& _val32 = this->my_enum_struct_map[_key31];
+              xfer += _val32.read(iprot);
             }
             xfer += iprot->readMapEnd();
           }
@@ -288,28 +433,28 @@ uint32_t MegaStruct::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_MAP) {
           {
             this->my_enum_stringlist_map.clear();
-            uint32_t _size32;
-            ::apache::thrift::protocol::TType _ktype33;
-            ::apache::thrift::protocol::TType _vtype34;
-            xfer += iprot->readMapBegin(_ktype33, _vtype34, _size32);
-            uint32_t _i36;
-            for (_i36 = 0; _i36 < _size32; ++_i36)
+            uint32_t _size34;
+            ::apache::thrift::protocol::TType _ktype35;
+            ::apache::thrift::protocol::TType _vtype36;
+            xfer += iprot->readMapBegin(_ktype35, _vtype36, _size34);
+            uint32_t _i38;
+            for (_i38 = 0; _i38 < _size34; ++_i38)
             {
-              MyEnum::type _key37;
-              int32_t ecast39;
-              xfer += iprot->readI32(ecast39);
-              _key37 = (MyEnum::type)ecast39;
-              std::vector<std::string> & _val38 = this->my_enum_stringlist_map[_key37];
+              MyEnum::type _key39;
+              int32_t ecast41;
+              xfer += iprot->readI32(ecast41);
+              _key39 = (MyEnum::type)ecast41;
+              std::vector<std::string> & _val40 = this->my_enum_stringlist_map[_key39];
               {
-                _val38.clear();
-                uint32_t _size40;
-                ::apache::thrift::protocol::TType _etype43;
-                xfer += iprot->readListBegin(_etype43, _size40);
-                _val38.resize(_size40);
-                uint32_t _i44;
-                for (_i44 = 0; _i44 < _size40; ++_i44)
+                _val40.clear();
+                uint32_t _size42;
+                ::apache::thrift::protocol::TType _etype45;
+                xfer += iprot->readListBegin(_etype45, _size42);
+                _val40.resize(_size42);
+                uint32_t _i46;
+                for (_i46 = 0; _i46 < _size42; ++_i46)
                 {
-                  xfer += iprot->readString(_val38[_i44]);
+                  xfer += iprot->readString(_val40[_i46]);
                 }
                 xfer += iprot->readListEnd();
               }
@@ -325,28 +470,28 @@ uint32_t MegaStruct::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_MAP) {
           {
             this->my_enum_structlist_map.clear();
-            uint32_t _size45;
-            ::apache::thrift::protocol::TType _ktype46;
-            ::apache::thrift::protocol::TType _vtype47;
-            xfer += iprot->readMapBegin(_ktype46, _vtype47, _size45);
-            uint32_t _i49;
-            for (_i49 = 0; _i49 < _size45; ++_i49)
+            uint32_t _size47;
+            ::apache::thrift::protocol::TType _ktype48;
+            ::apache::thrift::protocol::TType _vtype49;
+            xfer += iprot->readMapBegin(_ktype48, _vtype49, _size47);
+            uint32_t _i51;
+            for (_i51 = 0; _i51 < _size47; ++_i51)
             {
-              MyEnum::type _key50;
-              int32_t ecast52;
-              xfer += iprot->readI32(ecast52);
-              _key50 = (MyEnum::type)ecast52;
-              std::vector<MiniStruct> & _val51 = this->my_enum_structlist_map[_key50];
+              MyEnum::type _key52;
+              int32_t ecast54;
+              xfer += iprot->readI32(ecast54);
+              _key52 = (MyEnum::type)ecast54;
+              std::vector<MiniStruct> & _val53 = this->my_enum_structlist_map[_key52];
               {
-                _val51.clear();
-                uint32_t _size53;
-                ::apache::thrift::protocol::TType _etype56;
-                xfer += iprot->readListBegin(_etype56, _size53);
-                _val51.resize(_size53);
-                uint32_t _i57;
-                for (_i57 = 0; _i57 < _size53; ++_i57)
+                _val53.clear();
+                uint32_t _size55;
+                ::apache::thrift::protocol::TType _etype58;
+                xfer += iprot->readListBegin(_etype58, _size55);
+                _val53.resize(_size55);
+                uint32_t _i59;
+                for (_i59 = 0; _i59 < _size55; ++_i59)
                 {
-                  xfer += _val51[_i57].read(iprot);
+                  xfer += _val53[_i59].read(iprot);
                 }
                 xfer += iprot->readListEnd();
               }
@@ -362,14 +507,14 @@ uint32_t MegaStruct::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->my_stringlist.clear();
-            uint32_t _size58;
-            ::apache::thrift::protocol::TType _etype61;
-            xfer += iprot->readListBegin(_etype61, _size58);
-            this->my_stringlist.resize(_size58);
-            uint32_t _i62;
-            for (_i62 = 0; _i62 < _size58; ++_i62)
+            uint32_t _size60;
+            ::apache::thrift::protocol::TType _etype63;
+            xfer += iprot->readListBegin(_etype63, _size60);
+            this->my_stringlist.resize(_size60);
+            uint32_t _i64;
+            for (_i64 = 0; _i64 < _size60; ++_i64)
             {
-              xfer += iprot->readString(this->my_stringlist[_i62]);
+              xfer += iprot->readString(this->my_stringlist[_i64]);
             }
             xfer += iprot->readListEnd();
           }
@@ -382,14 +527,14 @@ uint32_t MegaStruct::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->my_structlist.clear();
-            uint32_t _size63;
-            ::apache::thrift::protocol::TType _etype66;
-            xfer += iprot->readListBegin(_etype66, _size63);
-            this->my_structlist.resize(_size63);
-            uint32_t _i67;
-            for (_i67 = 0; _i67 < _size63; ++_i67)
+            uint32_t _size65;
+            ::apache::thrift::protocol::TType _etype68;
+            xfer += iprot->readListBegin(_etype68, _size65);
+            this->my_structlist.resize(_size65);
+            uint32_t _i69;
+            for (_i69 = 0; _i69 < _size65; ++_i69)
             {
-              xfer += this->my_structlist[_i67].read(iprot);
+              xfer += this->my_structlist[_i69].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -402,16 +547,16 @@ uint32_t MegaStruct::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->my_enumlist.clear();
-            uint32_t _size68;
-            ::apache::thrift::protocol::TType _etype71;
-            xfer += iprot->readListBegin(_etype71, _size68);
-            this->my_enumlist.resize(_size68);
-            uint32_t _i72;
-            for (_i72 = 0; _i72 < _size68; ++_i72)
+            uint32_t _size70;
+            ::apache::thrift::protocol::TType _etype73;
+            xfer += iprot->readListBegin(_etype73, _size70);
+            this->my_enumlist.resize(_size70);
+            uint32_t _i74;
+            for (_i74 = 0; _i74 < _size70; ++_i74)
             {
-              int32_t ecast73;
-              xfer += iprot->readI32(ecast73);
-              this->my_enumlist[_i72] = (MyEnum::type)ecast73;
+              int32_t ecast75;
+              xfer += iprot->readI32(ecast75);
+              this->my_enumlist[_i74] = (MyEnum::type)ecast75;
             }
             xfer += iprot->readListEnd();
           }
@@ -424,15 +569,15 @@ uint32_t MegaStruct::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_SET) {
           {
             this->my_stringset.clear();
-            uint32_t _size74;
-            ::apache::thrift::protocol::TType _etype77;
-            xfer += iprot->readSetBegin(_etype77, _size74);
-            uint32_t _i78;
-            for (_i78 = 0; _i78 < _size74; ++_i78)
+            uint32_t _size76;
+            ::apache::thrift::protocol::TType _etype79;
+            xfer += iprot->readSetBegin(_etype79, _size76);
+            uint32_t _i80;
+            for (_i80 = 0; _i80 < _size76; ++_i80)
             {
-              std::string _elem79;
-              xfer += iprot->readString(_elem79);
-              this->my_stringset.insert(_elem79);
+              std::string _elem81;
+              xfer += iprot->readString(_elem81);
+              this->my_stringset.insert(_elem81);
             }
             xfer += iprot->readSetEnd();
           }
@@ -445,17 +590,17 @@ uint32_t MegaStruct::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_SET) {
           {
             this->my_enumset.clear();
-            uint32_t _size80;
-            ::apache::thrift::protocol::TType _etype83;
-            xfer += iprot->readSetBegin(_etype83, _size80);
-            uint32_t _i84;
-            for (_i84 = 0; _i84 < _size80; ++_i84)
+            uint32_t _size82;
+            ::apache::thrift::protocol::TType _etype85;
+            xfer += iprot->readSetBegin(_etype85, _size82);
+            uint32_t _i86;
+            for (_i86 = 0; _i86 < _size82; ++_i86)
             {
-              MyEnum::type _elem85;
-              int32_t ecast86;
-              xfer += iprot->readI32(ecast86);
-              _elem85 = (MyEnum::type)ecast86;
-              this->my_enumset.insert(_elem85);
+              MyEnum::type _elem87;
+              int32_t ecast88;
+              xfer += iprot->readI32(ecast88);
+              _elem87 = (MyEnum::type)ecast88;
+              this->my_enumset.insert(_elem87);
             }
             xfer += iprot->readSetEnd();
           }
@@ -468,15 +613,15 @@ uint32_t MegaStruct::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_SET) {
           {
             this->my_structset.clear();
-            uint32_t _size87;
-            ::apache::thrift::protocol::TType _etype90;
-            xfer += iprot->readSetBegin(_etype90, _size87);
-            uint32_t _i91;
-            for (_i91 = 0; _i91 < _size87; ++_i91)
+            uint32_t _size89;
+            ::apache::thrift::protocol::TType _etype92;
+            xfer += iprot->readSetBegin(_etype92, _size89);
+            uint32_t _i93;
+            for (_i93 = 0; _i93 < _size89; ++_i93)
             {
-              MiniStruct _elem92;
-              xfer += _elem92.read(iprot);
-              this->my_structset.insert(_elem92);
+              MiniStruct _elem94;
+              xfer += _elem94.read(iprot);
+              this->my_structset.insert(_elem94);
             }
             xfer += iprot->readSetEnd();
           }
@@ -499,6 +644,7 @@ uint32_t MegaStruct::read(::apache::thrift::protocol::TProtocol* iprot) {
 
 uint32_t MegaStruct::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
   xfer += oprot->writeStructBegin("MegaStruct");
 
   if (this->__isset.my_bool) {
@@ -545,11 +691,11 @@ uint32_t MegaStruct::write(::apache::thrift::protocol::TProtocol* oprot) const {
     xfer += oprot->writeFieldBegin("my_string_string_map", ::apache::thrift::protocol::T_MAP, 9);
     {
       xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->my_string_string_map.size()));
-      std::map<std::string, std::string> ::const_iterator _iter93;
-      for (_iter93 = this->my_string_string_map.begin(); _iter93 != this->my_string_string_map.end(); ++_iter93)
+      std::map<std::string, std::string> ::const_iterator _iter95;
+      for (_iter95 = this->my_string_string_map.begin(); _iter95 != this->my_string_string_map.end(); ++_iter95)
       {
-        xfer += oprot->writeString(_iter93->first);
-        xfer += oprot->writeString(_iter93->second);
+        xfer += oprot->writeString(_iter95->first);
+        xfer += oprot->writeString(_iter95->second);
       }
       xfer += oprot->writeMapEnd();
     }
@@ -559,11 +705,11 @@ uint32_t MegaStruct::write(::apache::thrift::protocol::TProtocol* oprot) const {
     xfer += oprot->writeFieldBegin("my_string_enum_map", ::apache::thrift::protocol::T_MAP, 10);
     {
       xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_I32, static_cast<uint32_t>(this->my_string_enum_map.size()));
-      std::map<std::string, MyEnum::type> ::const_iterator _iter94;
-      for (_iter94 = this->my_string_enum_map.begin(); _iter94 != this->my_string_enum_map.end(); ++_iter94)
+      std::map<std::string, MyEnum::type> ::const_iterator _iter96;
+      for (_iter96 = this->my_string_enum_map.begin(); _iter96 != this->my_string_enum_map.end(); ++_iter96)
       {
-        xfer += oprot->writeString(_iter94->first);
-        xfer += oprot->writeI32((int32_t)_iter94->second);
+        xfer += oprot->writeString(_iter96->first);
+        xfer += oprot->writeI32((int32_t)_iter96->second);
       }
       xfer += oprot->writeMapEnd();
     }
@@ -573,11 +719,11 @@ uint32_t MegaStruct::write(::apache::thrift::protocol::TProtocol* oprot) const {
     xfer += oprot->writeFieldBegin("my_enum_string_map", ::apache::thrift::protocol::T_MAP, 11);
     {
       xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_I32, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->my_enum_string_map.size()));
-      std::map<MyEnum::type, std::string> ::const_iterator _iter95;
-      for (_iter95 = this->my_enum_string_map.begin(); _iter95 != this->my_enum_string_map.end(); ++_iter95)
+      std::map<MyEnum::type, std::string> ::const_iterator _iter97;
+      for (_iter97 = this->my_enum_string_map.begin(); _iter97 != this->my_enum_string_map.end(); ++_iter97)
       {
-        xfer += oprot->writeI32((int32_t)_iter95->first);
-        xfer += oprot->writeString(_iter95->second);
+        xfer += oprot->writeI32((int32_t)_iter97->first);
+        xfer += oprot->writeString(_iter97->second);
       }
       xfer += oprot->writeMapEnd();
     }
@@ -587,11 +733,11 @@ uint32_t MegaStruct::write(::apache::thrift::protocol::TProtocol* oprot) const {
     xfer += oprot->writeFieldBegin("my_enum_struct_map", ::apache::thrift::protocol::T_MAP, 12);
     {
       xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_I32, ::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->my_enum_struct_map.size()));
-      std::map<MyEnum::type, MiniStruct> ::const_iterator _iter96;
-      for (_iter96 = this->my_enum_struct_map.begin(); _iter96 != this->my_enum_struct_map.end(); ++_iter96)
+      std::map<MyEnum::type, MiniStruct> ::const_iterator _iter98;
+      for (_iter98 = this->my_enum_struct_map.begin(); _iter98 != this->my_enum_struct_map.end(); ++_iter98)
       {
-        xfer += oprot->writeI32((int32_t)_iter96->first);
-        xfer += _iter96->second.write(oprot);
+        xfer += oprot->writeI32((int32_t)_iter98->first);
+        xfer += _iter98->second.write(oprot);
       }
       xfer += oprot->writeMapEnd();
     }
@@ -601,16 +747,16 @@ uint32_t MegaStruct::write(::apache::thrift::protocol::TProtocol* oprot) const {
     xfer += oprot->writeFieldBegin("my_enum_stringlist_map", ::apache::thrift::protocol::T_MAP, 13);
     {
       xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_I32, ::apache::thrift::protocol::T_LIST, static_cast<uint32_t>(this->my_enum_stringlist_map.size()));
-      std::map<MyEnum::type, std::vector<std::string> > ::const_iterator _iter97;
-      for (_iter97 = this->my_enum_stringlist_map.begin(); _iter97 != this->my_enum_stringlist_map.end(); ++_iter97)
+      std::map<MyEnum::type, std::vector<std::string> > ::const_iterator _iter99;
+      for (_iter99 = this->my_enum_stringlist_map.begin(); _iter99 != this->my_enum_stringlist_map.end(); ++_iter99)
       {
-        xfer += oprot->writeI32((int32_t)_iter97->first);
+        xfer += oprot->writeI32((int32_t)_iter99->first);
         {
-          xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(_iter97->second.size()));
-          std::vector<std::string> ::const_iterator _iter98;
-          for (_iter98 = _iter97->second.begin(); _iter98 != _iter97->second.end(); ++_iter98)
+          xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(_iter99->second.size()));
+          std::vector<std::string> ::const_iterator _iter100;
+          for (_iter100 = _iter99->second.begin(); _iter100 != _iter99->second.end(); ++_iter100)
           {
-            xfer += oprot->writeString((*_iter98));
+            xfer += oprot->writeString((*_iter100));
           }
           xfer += oprot->writeListEnd();
         }
@@ -623,16 +769,16 @@ uint32_t MegaStruct::write(::apache::thrift::protocol::TProtocol* oprot) const {
     xfer += oprot->writeFieldBegin("my_enum_structlist_map", ::apache::thrift::protocol::T_MAP, 14);
     {
       xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_I32, ::apache::thrift::protocol::T_LIST, static_cast<uint32_t>(this->my_enum_structlist_map.size()));
-      std::map<MyEnum::type, std::vector<MiniStruct> > ::const_iterator _iter99;
-      for (_iter99 = this->my_enum_structlist_map.begin(); _iter99 != this->my_enum_structlist_map.end(); ++_iter99)
+      std::map<MyEnum::type, std::vector<MiniStruct> > ::const_iterator _iter101;
+      for (_iter101 = this->my_enum_structlist_map.begin(); _iter101 != this->my_enum_structlist_map.end(); ++_iter101)
       {
-        xfer += oprot->writeI32((int32_t)_iter99->first);
+        xfer += oprot->writeI32((int32_t)_iter101->first);
         {
-          xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(_iter99->second.size()));
-          std::vector<MiniStruct> ::const_iterator _iter100;
-          for (_iter100 = _iter99->second.begin(); _iter100 != _iter99->second.end(); ++_iter100)
+          xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(_iter101->second.size()));
+          std::vector<MiniStruct> ::const_iterator _iter102;
+          for (_iter102 = _iter101->second.begin(); _iter102 != _iter101->second.end(); ++_iter102)
           {
-            xfer += (*_iter100).write(oprot);
+            xfer += (*_iter102).write(oprot);
           }
           xfer += oprot->writeListEnd();
         }
@@ -645,10 +791,10 @@ uint32_t MegaStruct::write(::apache::thrift::protocol::TProtocol* oprot) const {
     xfer += oprot->writeFieldBegin("my_stringlist", ::apache::thrift::protocol::T_LIST, 15);
     {
       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->my_stringlist.size()));
-      std::vector<std::string> ::const_iterator _iter101;
-      for (_iter101 = this->my_stringlist.begin(); _iter101 != this->my_stringlist.end(); ++_iter101)
+      std::vector<std::string> ::const_iterator _iter103;
+      for (_iter103 = this->my_stringlist.begin(); _iter103 != this->my_stringlist.end(); ++_iter103)
       {
-        xfer += oprot->writeString((*_iter101));
+        xfer += oprot->writeString((*_iter103));
       }
       xfer += oprot->writeListEnd();
     }
@@ -658,10 +804,10 @@ uint32_t MegaStruct::write(::apache::thrift::protocol::TProtocol* oprot) const {
     xfer += oprot->writeFieldBegin("my_structlist", ::apache::thrift::protocol::T_LIST, 16);
     {
       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->my_structlist.size()));
-      std::vector<MiniStruct> ::const_iterator _iter102;
-      for (_iter102 = this->my_structlist.begin(); _iter102 != this->my_structlist.end(); ++_iter102)
+      std::vector<MiniStruct> ::const_iterator _iter104;
+      for (_iter104 = this->my_structlist.begin(); _iter104 != this->my_structlist.end(); ++_iter104)
       {
-        xfer += (*_iter102).write(oprot);
+        xfer += (*_iter104).write(oprot);
       }
       xfer += oprot->writeListEnd();
     }
@@ -671,10 +817,10 @@ uint32_t MegaStruct::write(::apache::thrift::protocol::TProtocol* oprot) const {
     xfer += oprot->writeFieldBegin("my_enumlist", ::apache::thrift::protocol::T_LIST, 17);
     {
       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I32, static_cast<uint32_t>(this->my_enumlist.size()));
-      std::vector<MyEnum::type> ::const_iterator _iter103;
-      for (_iter103 = this->my_enumlist.begin(); _iter103 != this->my_enumlist.end(); ++_iter103)
+      std::vector<MyEnum::type> ::const_iterator _iter105;
+      for (_iter105 = this->my_enumlist.begin(); _iter105 != this->my_enumlist.end(); ++_iter105)
       {
-        xfer += oprot->writeI32((int32_t)(*_iter103));
+        xfer += oprot->writeI32((int32_t)(*_iter105));
       }
       xfer += oprot->writeListEnd();
     }
@@ -684,10 +830,10 @@ uint32_t MegaStruct::write(::apache::thrift::protocol::TProtocol* oprot) const {
     xfer += oprot->writeFieldBegin("my_stringset", ::apache::thrift::protocol::T_SET, 18);
     {
       xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->my_stringset.size()));
-      std::set<std::string> ::const_iterator _iter104;
-      for (_iter104 = this->my_stringset.begin(); _iter104 != this->my_stringset.end(); ++_iter104)
+      std::set<std::string> ::const_iterator _iter106;
+      for (_iter106 = this->my_stringset.begin(); _iter106 != this->my_stringset.end(); ++_iter106)
       {
-        xfer += oprot->writeString((*_iter104));
+        xfer += oprot->writeString((*_iter106));
       }
       xfer += oprot->writeSetEnd();
     }
@@ -697,10 +843,10 @@ uint32_t MegaStruct::write(::apache::thrift::protocol::TProtocol* oprot) const {
     xfer += oprot->writeFieldBegin("my_enumset", ::apache::thrift::protocol::T_SET, 19);
     {
       xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_I32, static_cast<uint32_t>(this->my_enumset.size()));
-      std::set<MyEnum::type> ::const_iterator _iter105;
-      for (_iter105 = this->my_enumset.begin(); _iter105 != this->my_enumset.end(); ++_iter105)
+      std::set<MyEnum::type> ::const_iterator _iter107;
+      for (_iter107 = this->my_enumset.begin(); _iter107 != this->my_enumset.end(); ++_iter107)
       {
-        xfer += oprot->writeI32((int32_t)(*_iter105));
+        xfer += oprot->writeI32((int32_t)(*_iter107));
       }
       xfer += oprot->writeSetEnd();
     }
@@ -710,10 +856,10 @@ uint32_t MegaStruct::write(::apache::thrift::protocol::TProtocol* oprot) const {
     xfer += oprot->writeFieldBegin("my_structset", ::apache::thrift::protocol::T_SET, 20);
     {
       xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->my_structset.size()));
-      std::set<MiniStruct> ::const_iterator _iter106;
-      for (_iter106 = this->my_structset.begin(); _iter106 != this->my_structset.end(); ++_iter106)
+      std::set<MiniStruct> ::const_iterator _iter108;
+      for (_iter108 = this->my_structset.begin(); _iter108 != this->my_structset.end(); ++_iter108)
       {
-        xfer += (*_iter106).write(oprot);
+        xfer += (*_iter108).write(oprot);
       }
       xfer += oprot->writeSetEnd();
     }
@@ -721,6 +867,7 @@ uint32_t MegaStruct::write(::apache::thrift::protocol::TProtocol* oprot) const {
   }
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
   return xfer;
 }
 
@@ -749,4 +896,78 @@ void swap(MegaStruct &a, MegaStruct &b) {
   swap(a.__isset, b.__isset);
 }
 
+MegaStruct::MegaStruct(const MegaStruct& other109) {
+  my_bool = other109.my_bool;
+  my_byte = other109.my_byte;
+  my_16bit_int = other109.my_16bit_int;
+  my_32bit_int = other109.my_32bit_int;
+  my_64bit_int = other109.my_64bit_int;
+  my_double = other109.my_double;
+  my_string = other109.my_string;
+  my_binary = other109.my_binary;
+  my_string_string_map = other109.my_string_string_map;
+  my_string_enum_map = other109.my_string_enum_map;
+  my_enum_string_map = other109.my_enum_string_map;
+  my_enum_struct_map = other109.my_enum_struct_map;
+  my_enum_stringlist_map = other109.my_enum_stringlist_map;
+  my_enum_structlist_map = other109.my_enum_structlist_map;
+  my_stringlist = other109.my_stringlist;
+  my_structlist = other109.my_structlist;
+  my_enumlist = other109.my_enumlist;
+  my_stringset = other109.my_stringset;
+  my_enumset = other109.my_enumset;
+  my_structset = other109.my_structset;
+  __isset = other109.__isset;
+}
+MegaStruct& MegaStruct::operator=(const MegaStruct& other110) {
+  my_bool = other110.my_bool;
+  my_byte = other110.my_byte;
+  my_16bit_int = other110.my_16bit_int;
+  my_32bit_int = other110.my_32bit_int;
+  my_64bit_int = other110.my_64bit_int;
+  my_double = other110.my_double;
+  my_string = other110.my_string;
+  my_binary = other110.my_binary;
+  my_string_string_map = other110.my_string_string_map;
+  my_string_enum_map = other110.my_string_enum_map;
+  my_enum_string_map = other110.my_enum_string_map;
+  my_enum_struct_map = other110.my_enum_struct_map;
+  my_enum_stringlist_map = other110.my_enum_stringlist_map;
+  my_enum_structlist_map = other110.my_enum_structlist_map;
+  my_stringlist = other110.my_stringlist;
+  my_structlist = other110.my_structlist;
+  my_enumlist = other110.my_enumlist;
+  my_stringset = other110.my_stringset;
+  my_enumset = other110.my_enumset;
+  my_structset = other110.my_structset;
+  __isset = other110.__isset;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const MegaStruct& obj) {
+  using apache::thrift::to_string;
+  out << "MegaStruct(";
+  out << "my_bool="; (obj.__isset.my_bool ? (out << to_string(obj.my_bool)) : (out << "<null>"));
+  out << ", " << "my_byte="; (obj.__isset.my_byte ? (out << to_string(obj.my_byte)) : (out << "<null>"));
+  out << ", " << "my_16bit_int="; (obj.__isset.my_16bit_int ? (out << to_string(obj.my_16bit_int)) : (out << "<null>"));
+  out << ", " << "my_32bit_int="; (obj.__isset.my_32bit_int ? (out << to_string(obj.my_32bit_int)) : (out << "<null>"));
+  out << ", " << "my_64bit_int="; (obj.__isset.my_64bit_int ? (out << to_string(obj.my_64bit_int)) : (out << "<null>"));
+  out << ", " << "my_double="; (obj.__isset.my_double ? (out << to_string(obj.my_double)) : (out << "<null>"));
+  out << ", " << "my_string="; (obj.__isset.my_string ? (out << to_string(obj.my_string)) : (out << "<null>"));
+  out << ", " << "my_binary="; (obj.__isset.my_binary ? (out << to_string(obj.my_binary)) : (out << "<null>"));
+  out << ", " << "my_string_string_map="; (obj.__isset.my_string_string_map ? (out << to_string(obj.my_string_string_map)) : (out << "<null>"));
+  out << ", " << "my_string_enum_map="; (obj.__isset.my_string_enum_map ? (out << to_string(obj.my_string_enum_map)) : (out << "<null>"));
+  out << ", " << "my_enum_string_map="; (obj.__isset.my_enum_string_map ? (out << to_string(obj.my_enum_string_map)) : (out << "<null>"));
+  out << ", " << "my_enum_struct_map="; (obj.__isset.my_enum_struct_map ? (out << to_string(obj.my_enum_struct_map)) : (out << "<null>"));
+  out << ", " << "my_enum_stringlist_map="; (obj.__isset.my_enum_stringlist_map ? (out << to_string(obj.my_enum_stringlist_map)) : (out << "<null>"));
+  out << ", " << "my_enum_structlist_map="; (obj.__isset.my_enum_structlist_map ? (out << to_string(obj.my_enum_structlist_map)) : (out << "<null>"));
+  out << ", " << "my_stringlist="; (obj.__isset.my_stringlist ? (out << to_string(obj.my_stringlist)) : (out << "<null>"));
+  out << ", " << "my_structlist="; (obj.__isset.my_structlist ? (out << to_string(obj.my_structlist)) : (out << "<null>"));
+  out << ", " << "my_enumlist="; (obj.__isset.my_enumlist ? (out << to_string(obj.my_enumlist)) : (out << "<null>"));
+  out << ", " << "my_stringset="; (obj.__isset.my_stringset ? (out << to_string(obj.my_stringset)) : (out << "<null>"));
+  out << ", " << "my_enumset="; (obj.__isset.my_enumset ? (out << to_string(obj.my_enumset)) : (out << "<null>"));
+  out << ", " << "my_structset="; (obj.__isset.my_structset ? (out << to_string(obj.my_structset)) : (out << "<null>"));
+  out << ")";
+  return out;
+}
+
 

http://git-wip-us.apache.org/repos/asf/hive/blob/42216997/serde/src/gen/thrift/gen-cpp/megastruct_types.h
----------------------------------------------------------------------
diff --git a/serde/src/gen/thrift/gen-cpp/megastruct_types.h b/serde/src/gen/thrift/gen-cpp/megastruct_types.h
index b5a8295..e4985dc 100644
--- a/serde/src/gen/thrift/gen-cpp/megastruct_types.h
+++ b/serde/src/gen/thrift/gen-cpp/megastruct_types.h
@@ -1,5 +1,5 @@
 /**
- * Autogenerated by Thrift Compiler (0.9.0)
+ * Autogenerated by Thrift Compiler (0.9.2)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  *  @generated
@@ -7,11 +7,14 @@
 #ifndef megastruct_TYPES_H
 #define megastruct_TYPES_H
 
+#include <iosfwd>
+
 #include <thrift/Thrift.h>
 #include <thrift/TApplicationException.h>
 #include <thrift/protocol/TProtocol.h>
 #include <thrift/transport/TTransport.h>
 
+#include <thrift/cxxfunctional.h>
 
 
 
@@ -25,10 +28,14 @@ struct MyEnum {
 
 extern const std::map<int, const char*> _MyEnum_VALUES_TO_NAMES;
 
+class MiniStruct;
+
+class MegaStruct;
+
 typedef struct _MiniStruct__isset {
   _MiniStruct__isset() : my_string(false), my_enum(false) {}
-  bool my_string;
-  bool my_enum;
+  bool my_string :1;
+  bool my_enum :1;
 } _MiniStruct__isset;
 
 class MiniStruct {
@@ -37,25 +44,20 @@ class MiniStruct {
   static const char* ascii_fingerprint; // = "4ED2B10931906B61ED0B1592EE860A37";
   static const uint8_t binary_fingerprint[16]; // = {0x4E,0xD2,0xB1,0x09,0x31,0x90,0x6B,0x61,0xED,0x0B,0x15,0x92,0xEE,0x86,0x0A,0x37};
 
+  MiniStruct(const MiniStruct&);
+  MiniStruct& operator=(const MiniStruct&);
   MiniStruct() : my_string(), my_enum((MyEnum::type)0) {
   }
 
-  virtual ~MiniStruct() throw() {}
-
+  virtual ~MiniStruct() throw();
   std::string my_string;
   MyEnum::type my_enum;
 
   _MiniStruct__isset __isset;
 
-  void __set_my_string(const std::string& val) {
-    my_string = val;
-    __isset.my_string = true;
-  }
+  void __set_my_string(const std::string& val);
 
-  void __set_my_enum(const MyEnum::type val) {
-    my_enum = val;
-    __isset.my_enum = true;
-  }
+  void __set_my_enum(const MyEnum::type val);
 
   bool operator == (const MiniStruct & rhs) const
   {
@@ -78,32 +80,33 @@ class MiniStruct {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const MiniStruct& obj);
 };
 
 void swap(MiniStruct &a, MiniStruct &b);
 
 typedef struct _MegaStruct__isset {
   _MegaStruct__isset() : my_bool(false), my_byte(false), my_16bit_int(false), my_32bit_int(false), my_64bit_int(false), my_double(false), my_string(false), my_binary(false), my_string_string_map(false), my_string_enum_map(false), my_enum_string_map(false), my_enum_struct_map(false), my_enum_stringlist_map(false), my_enum_structlist_map(false), my_stringlist(false), my_structlist(false), my_enumlist(false), my_stringset(false), my_enumset(false), my_structset(false) {}
-  bool my_bool;
-  bool my_byte;
-  bool my_16bit_int;
-  bool my_32bit_int;
-  bool my_64bit_int;
-  bool my_double;
-  bool my_string;
-  bool my_binary;
-  bool my_string_string_map;
-  bool my_string_enum_map;
-  bool my_enum_string_map;
-  bool my_enum_struct_map;
-  bool my_enum_stringlist_map;
-  bool my_enum_structlist_map;
-  bool my_stringlist;
-  bool my_structlist;
-  bool my_enumlist;
-  bool my_stringset;
-  bool my_enumset;
-  bool my_structset;
+  bool my_bool :1;
+  bool my_byte :1;
+  bool my_16bit_int :1;
+  bool my_32bit_int :1;
+  bool my_64bit_int :1;
+  bool my_double :1;
+  bool my_string :1;
+  bool my_binary :1;
+  bool my_string_string_map :1;
+  bool my_string_enum_map :1;
+  bool my_enum_string_map :1;
+  bool my_enum_struct_map :1;
+  bool my_enum_stringlist_map :1;
+  bool my_enum_structlist_map :1;
+  bool my_stringlist :1;
+  bool my_structlist :1;
+  bool my_enumlist :1;
+  bool my_stringset :1;
+  bool my_enumset :1;
+  bool my_structset :1;
 } _MegaStruct__isset;
 
 class MegaStruct {
@@ -112,11 +115,12 @@ class MegaStruct {
   static const char* ascii_fingerprint; // = "9979EEF0CA19988228E64220A3AA9120";
   static const uint8_t binary_fingerprint[16]; // = {0x99,0x79,0xEE,0xF0,0xCA,0x19,0x98,0x82,0x28,0xE6,0x42,0x20,0xA3,0xAA,0x91,0x20};
 
+  MegaStruct(const MegaStruct&);
+  MegaStruct& operator=(const MegaStruct&);
   MegaStruct() : my_bool(0), my_byte(0), my_16bit_int(0), my_32bit_int(0), my_64bit_int(0), my_double(0), my_string(), my_binary() {
   }
 
-  virtual ~MegaStruct() throw() {}
-
+  virtual ~MegaStruct() throw();
   bool my_bool;
   int8_t my_byte;
   int16_t my_16bit_int;
@@ -140,105 +144,45 @@ class MegaStruct {
 
   _MegaStruct__isset __isset;
 
-  void __set_my_bool(const bool val) {
-    my_bool = val;
-    __isset.my_bool = true;
-  }
+  void __set_my_bool(const bool val);
 
-  void __set_my_byte(const int8_t val) {
-    my_byte = val;
-    __isset.my_byte = true;
-  }
+  void __set_my_byte(const int8_t val);
 
-  void __set_my_16bit_int(const int16_t val) {
-    my_16bit_int = val;
-    __isset.my_16bit_int = true;
-  }
+  void __set_my_16bit_int(const int16_t val);
 
-  void __set_my_32bit_int(const int32_t val) {
-    my_32bit_int = val;
-    __isset.my_32bit_int = true;
-  }
+  void __set_my_32bit_int(const int32_t val);
 
-  void __set_my_64bit_int(const int64_t val) {
-    my_64bit_int = val;
-    __isset.my_64bit_int = true;
-  }
+  void __set_my_64bit_int(const int64_t val);
 
-  void __set_my_double(const double val) {
-    my_double = val;
-    __isset.my_double = true;
-  }
+  void __set_my_double(const double val);
 
-  void __set_my_string(const std::string& val) {
-    my_string = val;
-    __isset.my_string = true;
-  }
+  void __set_my_string(const std::string& val);
 
-  void __set_my_binary(const std::string& val) {
-    my_binary = val;
-    __isset.my_binary = true;
-  }
+  void __set_my_binary(const std::string& val);
 
-  void __set_my_string_string_map(const std::map<std::string, std::string> & val) {
-    my_string_string_map = val;
-    __isset.my_string_string_map = true;
-  }
+  void __set_my_string_string_map(const std::map<std::string, std::string> & val);
 
-  void __set_my_string_enum_map(const std::map<std::string, MyEnum::type> & val) {
-    my_string_enum_map = val;
-    __isset.my_string_enum_map = true;
-  }
+  void __set_my_string_enum_map(const std::map<std::string, MyEnum::type> & val);
 
-  void __set_my_enum_string_map(const std::map<MyEnum::type, std::string> & val) {
-    my_enum_string_map = val;
-    __isset.my_enum_string_map = true;
-  }
+  void __set_my_enum_string_map(const std::map<MyEnum::type, std::string> & val);
 
-  void __set_my_enum_struct_map(const std::map<MyEnum::type, MiniStruct> & val) {
-    my_enum_struct_map = val;
-    __isset.my_enum_struct_map = true;
-  }
+  void __set_my_enum_struct_map(const std::map<MyEnum::type, MiniStruct> & val);
 
-  void __set_my_enum_stringlist_map(const std::map<MyEnum::type, std::vector<std::string> > & val) {
-    my_enum_stringlist_map = val;
-    __isset.my_enum_stringlist_map = true;
-  }
+  void __set_my_enum_stringlist_map(const std::map<MyEnum::type, std::vector<std::string> > & val);
 
-  void __set_my_enum_structlist_map(const std::map<MyEnum::type, std::vector<MiniStruct> > & val) {
-    my_enum_structlist_map = val;
-    __isset.my_enum_structlist_map = true;
-  }
+  void __set_my_enum_structlist_map(const std::map<MyEnum::type, std::vector<MiniStruct> > & val);
 
-  void __set_my_stringlist(const std::vector<std::string> & val) {
-    my_stringlist = val;
-    __isset.my_stringlist = true;
-  }
+  void __set_my_stringlist(const std::vector<std::string> & val);
 
-  void __set_my_structlist(const std::vector<MiniStruct> & val) {
-    my_structlist = val;
-    __isset.my_structlist = true;
-  }
+  void __set_my_structlist(const std::vector<MiniStruct> & val);
 
-  void __set_my_enumlist(const std::vector<MyEnum::type> & val) {
-    my_enumlist = val;
-    __isset.my_enumlist = true;
-  }
+  void __set_my_enumlist(const std::vector<MyEnum::type> & val);
 
-  void __set_my_stringset(const std::set<std::string> & val) {
-    my_stringset = val;
-    __isset.my_stringset = true;
-  }
+  void __set_my_stringset(const std::set<std::string> & val);
 
-  void __set_my_enumset(const std::set<MyEnum::type> & val) {
-    my_enumset = val;
-    __isset.my_enumset = true;
-  }
+  void __set_my_enumset(const std::set<MyEnum::type> & val);
 
-  void __set_my_structset(const std::set<MiniStruct> & val) {
-    my_structset = val;
-    __isset.my_structset = true;
-  }
+  void __set_my_structset(const std::set<MiniStruct> & val);
 
   bool operator == (const MegaStruct & rhs) const
   {
@@ -333,6 +277,7 @@ class MegaStruct {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const MegaStruct& obj);
 };
 
 void swap(MegaStruct &a, MegaStruct &b);

http://git-wip-us.apache.org/repos/asf/hive/blob/42216997/serde/src/gen/thrift/gen-cpp/serde_constants.cpp
----------------------------------------------------------------------
diff --git a/serde/src/gen/thrift/gen-cpp/serde_constants.cpp b/serde/src/gen/thrift/gen-cpp/serde_constants.cpp
index 5f8873b..196a46f 100644
--- a/serde/src/gen/thrift/gen-cpp/serde_constants.cpp
+++ b/serde/src/gen/thrift/gen-cpp/serde_constants.cpp
@@ -1,5 +1,5 @@
 /**
- * Autogenerated by Thrift Compiler (0.9.0)
+ * Autogenerated by Thrift Compiler (0.9.2)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  *  @generated

http://git-wip-us.apache.org/repos/asf/hive/blob/42216997/serde/src/gen/thrift/gen-cpp/serde_constants.h
----------------------------------------------------------------------
diff --git a/serde/src/gen/thrift/gen-cpp/serde_constants.h b/serde/src/gen/thrift/gen-cpp/serde_constants.h
index 4f2018b..36bd175 100644
--- a/serde/src/gen/thrift/gen-cpp/serde_constants.h
+++ b/serde/src/gen/thrift/gen-cpp/serde_constants.h
@@ -1,5 +1,5 @@
 /**
- * Autogenerated by Thrift Compiler (0.9.0)
+ * Autogenerated by Thrift Compiler (0.9.2)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  *  @generated

http://git-wip-us.apache.org/repos/asf/hive/blob/42216997/serde/src/gen/thrift/gen-cpp/serde_types.cpp
----------------------------------------------------------------------
diff --git a/serde/src/gen/thrift/gen-cpp/serde_types.cpp b/serde/src/gen/thrift/gen-cpp/serde_types.cpp
index 20d1fbd..a37ff7c 100644
--- a/serde/src/gen/thrift/gen-cpp/serde_types.cpp
+++ b/serde/src/gen/thrift/gen-cpp/serde_types.cpp
@@ -1,5 +1,5 @@
 /**
- * Autogenerated by Thrift Compiler (0.9.0)
+ * Autogenerated by Thrift Compiler (0.9.2)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  *  @generated
@@ -7,6 +7,9 @@
 #include "serde_types.h"
 
 #include <algorithm>
+#include <ostream>
+
+#include <thrift/TToString.h>
 
 namespace Hive {
 

http://git-wip-us.apache.org/repos/asf/hive/blob/42216997/serde/src/gen/thrift/gen-cpp/serde_types.h
----------------------------------------------------------------------
diff --git a/serde/src/gen/thrift/gen-cpp/serde_types.h b/serde/src/gen/thrift/gen-cpp/serde_types.h
index 7fafa7d..eb7659a 100644
--- a/serde/src/gen/thrift/gen-cpp/serde_types.h
+++ b/serde/src/gen/thrift/gen-cpp/serde_types.h
@@ -1,5 +1,5 @@
 /**
- * Autogenerated by Thrift Compiler (0.9.0)
+ * Autogenerated by Thrift Compiler (0.9.2)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  *  @generated
@@ -7,11 +7,14 @@
 #ifndef serde_TYPES_H
 #define serde_TYPES_H
 
+#include <iosfwd>
+
 #include <thrift/Thrift.h>
 #include <thrift/TApplicationException.h>
 #include <thrift/protocol/TProtocol.h>
 #include <thrift/transport/TTransport.h>
 
+#include <thrift/cxxfunctional.h>
 
 
 namespace Hive {

http://git-wip-us.apache.org/repos/asf/hive/blob/42216997/serde/src/gen/thrift/gen-cpp/testthrift_constants.cpp
----------------------------------------------------------------------
diff --git a/serde/src/gen/thrift/gen-cpp/testthrift_constants.cpp b/serde/src/gen/thrift/gen-cpp/testthrift_constants.cpp
index 3dbbf1b..0fa57e7 100644
--- a/serde/src/gen/thrift/gen-cpp/testthrift_constants.cpp
+++ b/serde/src/gen/thrift/gen-cpp/testthrift_constants.cpp
@@ -1,5 +1,5 @@
 /**
- * Autogenerated by Thrift Compiler (0.9.0)
+ * Autogenerated by Thrift Compiler (0.9.2)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  *  @generated

http://git-wip-us.apache.org/repos/asf/hive/blob/42216997/serde/src/gen/thrift/gen-cpp/testthrift_constants.h
----------------------------------------------------------------------
diff --git a/serde/src/gen/thrift/gen-cpp/testthrift_constants.h b/serde/src/gen/thrift/gen-cpp/testthrift_constants.h
index 76e5f0c..cba3296 100644
--- a/serde/src/gen/thrift/gen-cpp/testthrift_constants.h
+++ b/serde/src/gen/thrift/gen-cpp/testthrift_constants.h
@@ -1,5 +1,5 @@
 /**
- * Autogenerated by Thrift Compiler (0.9.0)
+ * Autogenerated by Thrift Compiler (0.9.2)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  *  @generated

http://git-wip-us.apache.org/repos/asf/hive/blob/42216997/serde/src/gen/thrift/gen-cpp/testthrift_types.cpp
----------------------------------------------------------------------
diff --git a/serde/src/gen/thrift/gen-cpp/testthrift_types.cpp b/serde/src/gen/thrift/gen-cpp/testthrift_types.cpp
index 7949f23..0cd19b9 100644
--- a/serde/src/gen/thrift/gen-cpp/testthrift_types.cpp
+++ b/serde/src/gen/thrift/gen-cpp/testthrift_types.cpp
@@ -1,5 +1,5 @@
 /**
- * Autogenerated by Thrift Compiler (0.9.0)
+ * Autogenerated by Thrift Compiler (0.9.2)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  *  @generated
@@ -7,9 +7,21 @@
 #include "testthrift_types.h"
 
 #include <algorithm>
+#include <ostream>
 
+#include <thrift/TToString.h>
 
 
+
+
+InnerStruct::~InnerStruct() throw() {
+}
+
+
+void InnerStruct::__set_field0(const int32_t val) {
+  this->field0 = val;
+}
+
 const char* InnerStruct::ascii_fingerprint = "E86CACEB22240450EDCBEFC3A83970E4";
 const uint8_t InnerStruct::binary_fingerprint[16] = {0xE8,0x6C,0xAC,0xEB,0x22,0x24,0x04,0x50,0xED,0xCB,0xEF,0xC3,0xA8,0x39,0x70,0xE4};
 
@@ -55,6 +67,7 @@ uint32_t InnerStruct::read(::apache::thrift::protocol::TProtocol* iprot) {
 
 uint32_t InnerStruct::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
   xfer += oprot->writeStructBegin("InnerStruct");
 
   xfer += oprot->writeFieldBegin("field0", ::apache::thrift::protocol::T_I32, 1);
@@ -63,6 +76,7 @@ uint32_t InnerStruct::write(::apache::thrift::protocol::TProtocol* oprot) const
 
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
   return xfer;
 }
 
@@ -72,6 +86,40 @@ void swap(InnerStruct &a, InnerStruct &b) {
   swap(a.__isset, b.__isset);
 }
 
+InnerStruct::InnerStruct(const InnerStruct& other0) {
+  field0 = other0.field0;
+  __isset = other0.__isset;
+}
+InnerStruct& InnerStruct::operator=(const InnerStruct& other1) {
+  field0 = other1.field0;
+  __isset = other1.__isset;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const InnerStruct& obj) {
+  using apache::thrift::to_string;
+  out << "InnerStruct(";
+  out << "field0=" << to_string(obj.field0);
+  out << ")";
+  return out;
+}
+
+
+ThriftTestObj::~ThriftTestObj() throw() {
+}
+
+
+void ThriftTestObj::__set_field1(const int32_t val) {
+  this->field1 = val;
+}
+
+void ThriftTestObj::__set_field2(const std::string& val) {
+  this->field2 = val;
+}
+
+void ThriftTestObj::__set_field3(const std::vector<InnerStruct> & val) {
+  this->field3 = val;
+}
+
 const char* ThriftTestObj::ascii_fingerprint = "2BA5D8DAACFBBE6599779830A6185706";
 const uint8_t ThriftTestObj::binary_fingerprint[16] = {0x2B,0xA5,0xD8,0xDA,0xAC,0xFB,0xBE,0x65,0x99,0x77,0x98,0x30,0xA6,0x18,0x57,0x06};
 
@@ -115,14 +163,14 @@ uint32_t ThriftTestObj::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->field3.clear();
-            uint32_t _size0;
-            ::apache::thrift::protocol::TType _etype3;
-            xfer += iprot->readListBegin(_etype3, _size0);
-            this->field3.resize(_size0);
-            uint32_t _i4;
-            for (_i4 = 0; _i4 < _size0; ++_i4)
+            uint32_t _size2;
+            ::apache::thrift::protocol::TType _etype5;
+            xfer += iprot->readListBegin(_etype5, _size2);
+            this->field3.resize(_size2);
+            uint32_t _i6;
+            for (_i6 = 0; _i6 < _size2; ++_i6)
             {
-              xfer += this->field3[_i4].read(iprot);
+              xfer += this->field3[_i6].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -145,6 +193,7 @@ uint32_t ThriftTestObj::read(::apache::thrift::protocol::TProtocol* iprot) {
 
 uint32_t ThriftTestObj::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
   xfer += oprot->writeStructBegin("ThriftTestObj");
 
   xfer += oprot->writeFieldBegin("field1", ::apache::thrift::protocol::T_I32, 1);
@@ -158,10 +207,10 @@ uint32_t ThriftTestObj::write(::apache::thrift::protocol::TProtocol* oprot) cons
   xfer += oprot->writeFieldBegin("field3", ::apache::thrift::protocol::T_LIST, 3);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->field3.size()));
-    std::vector<InnerStruct> ::const_iterator _iter5;
-    for (_iter5 = this->field3.begin(); _iter5 != this->field3.end(); ++_iter5)
+    std::vector<InnerStruct> ::const_iterator _iter7;
+    for (_iter7 = this->field3.begin(); _iter7 != this->field3.end(); ++_iter7)
     {
-      xfer += (*_iter5).write(oprot);
+      xfer += (*_iter7).write(oprot);
     }
     xfer += oprot->writeListEnd();
   }
@@ -169,6 +218,7 @@ uint32_t ThriftTestObj::write(::apache::thrift::protocol::TProtocol* oprot) cons
 
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
   return xfer;
 }
 
@@ -180,4 +230,27 @@ void swap(ThriftTestObj &a, ThriftTestObj &b) {
   swap(a.__isset, b.__isset);
 }
 
+ThriftTestObj::ThriftTestObj(const ThriftTestObj& other8) {
+  field1 = other8.field1;
+  field2 = other8.field2;
+  field3 = other8.field3;
+  __isset = other8.__isset;
+}
+ThriftTestObj& ThriftTestObj::operator=(const ThriftTestObj& other9) {
+  field1 = other9.field1;
+  field2 = other9.field2;
+  field3 = other9.field3;
+  __isset = other9.__isset;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const ThriftTestObj& obj) {
+  using apache::thrift::to_string;
+  out << "ThriftTestObj(";
+  out << "field1=" << to_string(obj.field1);
+  out << ", " << "field2=" << to_string(obj.field2);
+  out << ", " << "field3=" << to_string(obj.field3);
+  out << ")";
+  return out;
+}
+
 

http://git-wip-us.apache.org/repos/asf/hive/blob/42216997/serde/src/gen/thrift/gen-cpp/testthrift_types.h
----------------------------------------------------------------------
diff --git a/serde/src/gen/thrift/gen-cpp/testthrift_types.h b/serde/src/gen/thrift/gen-cpp/testthrift_types.h
index 6c84b9f..8c57e48 100644
--- a/serde/src/gen/thrift/gen-cpp/testthrift_types.h
+++ b/serde/src/gen/thrift/gen-cpp/testthrift_types.h
@@ -1,5 +1,5 @@
 /**
- * Autogenerated by Thrift Compiler (0.9.0)
+ * Autogenerated by Thrift Compiler (0.9.2)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  *  @generated
@@ -7,18 +7,25 @@
 #ifndef testthrift_TYPES_H
 #define testthrift_TYPES_H
 
+#include <iosfwd>
+
 #include <thrift/Thrift.h>
 #include <thrift/TApplicationException.h>
 #include <thrift/protocol/TProtocol.h>
 #include <thrift/transport/TTransport.h>
 
+#include <thrift/cxxfunctional.h>
+
+
 
 
+class InnerStruct;
 
+class ThriftTestObj;
 
 typedef struct _InnerStruct__isset {
   _InnerStruct__isset() : field0(false) {}
-  bool field0;
+  bool field0 :1;
 } _InnerStruct__isset;
 
 class InnerStruct {
@@ -27,18 +34,17 @@ class InnerStruct {
   static const char* ascii_fingerprint; // = "E86CACEB22240450EDCBEFC3A83970E4";
   static const uint8_t binary_fingerprint[16]; // = {0xE8,0x6C,0xAC,0xEB,0x22,0x24,0x04,0x50,0xED,0xCB,0xEF,0xC3,0xA8,0x39,0x70,0xE4};
 
+  InnerStruct(const InnerStruct&);
+  InnerStruct& operator=(const InnerStruct&);
   InnerStruct() : field0(0) {
   }
 
-  virtual ~InnerStruct() throw() {}
-
+  virtual ~InnerStruct() throw();
   int32_t field0;
 
   _InnerStruct__isset __isset;
 
-  void __set_field0(const int32_t val) {
-    field0 = val;
-  }
+  void __set_field0(const int32_t val);
 
   bool operator == (const InnerStruct & rhs) const
   {
@@ -55,15 +61,16 @@ class InnerStruct {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const InnerStruct& obj);
 };
 
 void swap(InnerStruct &a, InnerStruct &b);
 
 typedef struct _ThriftTestObj__isset {
   _ThriftTestObj__isset() : field1(false), field2(false), field3(false) {}
-  bool field1;
-  bool field2;
-  bool field3;
+  bool field1 :1;
+  bool field2 :1;
+  bool field3 :1;
 } _ThriftTestObj__isset;
 
 class ThriftTestObj {
@@ -72,28 +79,23 @@ class ThriftTestObj {
   static const char* ascii_fingerprint; // = "2BA5D8DAACFBBE6599779830A6185706";
   static const uint8_t binary_fingerprint[16]; // = {0x2B,0xA5,0xD8,0xDA,0xAC,0xFB,0xBE,0x65,0x99,0x77,0x98,0x30,0xA6,0x18,0x57,0x06};
 
+  ThriftTestObj(const ThriftTestObj&);
+  ThriftTestObj& operator=(const ThriftTestObj&);
   ThriftTestObj() : field1(0), field2() {
   }
 
-  virtual ~ThriftTestObj() throw() {}
-
+  virtual ~ThriftTestObj() throw();
   int32_t field1;
   std::string field2;
   std::vector<InnerStruct>  field3;
 
   _ThriftTestObj__isset __isset;
 
-  void __set_field1(const int32_t val) {
-    field1 = val;
-  }
+  void __set_field1(const int32_t val);
 
-  void __set_field2(const std::string& val) {
-    field2 = val;
-  }
+  void __set_field2(const std::string& val);
 
-  void __set_field3(const std::vector<InnerStruct> & val) {
-    field3 = val;
-  }
+  void __set_field3(const std::vector<InnerStruct> & val);
 
   bool operator == (const ThriftTestObj & rhs) const
   {
@@ -114,6 +116,7 @@ class ThriftTestObj {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
+  friend std::ostream& operator<<(std::ostream& out, const ThriftTestObj& obj);
 };
 
 void swap(ThriftTestObj &a, ThriftTestObj &b);

http://git-wip-us.apache.org/repos/asf/hive/blob/42216997/serde/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/serde/serdeConstants.java
----------------------------------------------------------------------
diff --git a/serde/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/serde/serdeConstants.java b/serde/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/serde/serdeConstants.java
index 5f3001d..f12d4c7 100644
--- a/serde/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/serde/serdeConstants.java
+++ b/serde/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/serde/serdeConstants.java
@@ -1,12 +1,11 @@
 /**
- * Autogenerated by Thrift Compiler (0.9.0)
+ * Autogenerated by Thrift Compiler (0.9.2)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  *  @generated
  */
 package org.apache.hadoop.hive.serde;
 
-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;
@@ -16,6 +15,8 @@ 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;
@@ -28,9 +29,11 @@ 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"})
 public class serdeConstants {
 
   public static final String SERIALIZATION_LIB = "serialization.lib";

http://git-wip-us.apache.org/repos/asf/hive/blob/42216997/serde/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/serde/test/InnerStruct.java
----------------------------------------------------------------------
diff --git a/serde/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/serde/test/InnerStruct.java b/serde/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/serde/test/InnerStruct.java
index 72a28ae..37e228c 100644
--- a/serde/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/serde/test/InnerStruct.java
+++ b/serde/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/serde/test/InnerStruct.java
@@ -1,12 +1,11 @@
 /**
- * Autogenerated by Thrift Compiler (0.9.0)
+ * Autogenerated by Thrift Compiler (0.9.2)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  *  @generated
  */
 package org.apache.hadoop.hive.serde.test;
 
-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;
@@ -16,6 +15,8 @@ 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;
@@ -28,10 +29,13 @@ 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;
 
-public class InnerStruct implements org.apache.thrift.TBase<InnerStruct, InnerStruct._Fields>, java.io.Serializable, Cloneable {
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"})
+@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2015-7-14")
+public class InnerStruct implements org.apache.thrift.TBase<InnerStruct, InnerStruct._Fields>, java.io.Serializable, Cloneable, Comparable<InnerStruct> {
   private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("InnerStruct");
 
   private static final org.apache.thrift.protocol.TField FIELD0_FIELD_DESC = new org.apache.thrift.protocol.TField("field0", org.apache.thrift.protocol.TType.I32, (short)1);
@@ -227,30 +231,30 @@ public class InnerStruct implements org.apache.thrift.TBase<InnerStruct, InnerSt
 
   @Override
   public int hashCode() {
-    HashCodeBuilder builder = new HashCodeBuilder();
+    List<Object> list = new ArrayList<Object>();
 
     boolean present_field0 = true;
-    builder.append(present_field0);
+    list.add(present_field0);
     if (present_field0)
-      builder.append(field0);
+      list.add(field0);
 
-    return builder.toHashCode();
+    return list.hashCode();
   }
 
+  @Override
   public int compareTo(InnerStruct other) {
     if (!getClass().equals(other.getClass())) {
       return getClass().getName().compareTo(other.getClass().getName());
     }
 
     int lastComparison = 0;
-    InnerStruct typedOther = (InnerStruct)other;
 
-    lastComparison = Boolean.valueOf(isSetField0()).compareTo(typedOther.isSetField0());
+    lastComparison = Boolean.valueOf(isSetField0()).compareTo(other.isSetField0());
     if (lastComparison != 0) {
       return lastComparison;
     }
     if (isSetField0()) {
-      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.field0, typedOther.field0);
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.field0, other.field0);
       if (lastComparison != 0) {
         return lastComparison;
       }

http://git-wip-us.apache.org/repos/asf/hive/blob/42216997/serde/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/serde/test/ThriftTestObj.java
----------------------------------------------------------------------
diff --git a/serde/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/serde/test/ThriftTestObj.java b/serde/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/serde/test/ThriftTestObj.java
index dda3c5f..747e6e1 100644
--- a/serde/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/serde/test/ThriftTestObj.java
+++ b/serde/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/serde/test/ThriftTestObj.java
@@ -1,12 +1,11 @@
 /**
- * Autogenerated by Thrift Compiler (0.9.0)
+ * Autogenerated by Thrift Compiler (0.9.2)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  *  @generated
  */
 package org.apache.hadoop.hive.serde.test;
 
-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;
@@ -16,6 +15,8 @@ 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;
@@ -28,10 +29,13 @@ 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;
 
-public class ThriftTestObj implements org.apache.thrift.TBase<ThriftTestObj, ThriftTestObj._Fields>, java.io.Serializable, Cloneable {
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"})
+@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2015-7-14")
+public class ThriftTestObj implements org.apache.thrift.TBase<ThriftTestObj, ThriftTestObj._Fields>, java.io.Serializable, Cloneable, Comparable<ThriftTestObj> {
   private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("ThriftTestObj");
 
   private static final org.apache.thrift.protocol.TField FIELD1_FIELD_DESC = new org.apache.thrift.protocol.TField("field1", org.apache.thrift.protocol.TType.I32, (short)1);
@@ -154,7 +158,7 @@ public class ThriftTestObj implements org.apache.thrift.TBase<ThriftTestObj, Thr
       this.field2 = other.field2;
     }
     if (other.isSetField3()) {
-      List<InnerStruct> __this__field3 = new ArrayList<InnerStruct>();
+      List<InnerStruct> __this__field3 = new ArrayList<InnerStruct>(other.field3.size());
       for (InnerStruct other_element : other.field3) {
         __this__field3.add(new InnerStruct(other_element));
       }
@@ -363,60 +367,60 @@ public class ThriftTestObj implements org.apache.thrift.TBase<ThriftTestObj, Thr
 
   @Override
   public int hashCode() {
-    HashCodeBuilder builder = new HashCodeBuilder();
+    List<Object> list = new ArrayList<Object>();
 
     boolean present_field1 = true;
-    builder.append(present_field1);
+    list.add(present_field1);
     if (present_field1)
-      builder.append(field1);
+      list.add(field1);
 
     boolean present_field2 = true && (isSetField2());
-    builder.append(present_field2);
+    list.add(present_field2);
     if (present_field2)
-      builder.append(field2);
+      list.add(field2);
 
     boolean present_field3 = true && (isSetField3());
-    builder.append(present_field3);
+    list.add(present_field3);
     if (present_field3)
-      builder.append(field3);
+      list.add(field3);
 
-    return builder.toHashCode();
+    return list.hashCode();
   }
 
+  @Override
   public int compareTo(ThriftTestObj other) {
     if (!getClass().equals(other.getClass())) {
       return getClass().getName().compareTo(other.getClass().getName());
     }
 
     int lastComparison = 0;
-    ThriftTestObj typedOther = (ThriftTestObj)other;
 
-    lastComparison = Boolean.valueOf(isSetField1()).compareTo(typedOther.isSetField1());
+    lastComparison = Boolean.valueOf(isSetField1()).compareTo(other.isSetField1());
     if (lastComparison != 0) {
       return lastComparison;
     }
     if (isSetField1()) {
-      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.field1, typedOther.field1);
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.field1, other.field1);
       if (lastComparison != 0) {
         return lastComparison;
       }
     }
-    lastComparison = Boolean.valueOf(isSetField2()).compareTo(typedOther.isSetField2());
+    lastComparison = Boolean.valueOf(isSetField2()).compareTo(other.isSetField2());
     if (lastComparison != 0) {
       return lastComparison;
     }
     if (isSetField2()) {
-      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.field2, typedOther.field2);
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.field2, other.field2);
       if (lastComparison != 0) {
         return lastComparison;
       }
     }
-    lastComparison = Boolean.valueOf(isSetField3()).compareTo(typedOther.isSetField3());
+    lastComparison = Boolean.valueOf(isSetField3()).compareTo(other.isSetField3());
     if (lastComparison != 0) {
       return lastComparison;
     }
     if (isSetField3()) {
-      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.field3, typedOther.field3);
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.field3, other.field3);
       if (lastComparison != 0) {
         return lastComparison;
       }
@@ -526,12 +530,12 @@ public class ThriftTestObj implements org.apache.thrift.TBase<ThriftTestObj, Thr
               {
                 org.apache.thrift.protocol.TList _list0 = iprot.readListBegin();
                 struct.field3 = new ArrayList<InnerStruct>(_list0.size);
-                for (int _i1 = 0; _i1 < _list0.size; ++_i1)
+                InnerStruct _elem1;
+                for (int _i2 = 0; _i2 < _list0.size; ++_i2)
                 {
-                  InnerStruct _elem2; // optional
-                  _elem2 = new InnerStruct();
-                  _elem2.read(iprot);
-                  struct.field3.add(_elem2);
+                  _elem1 = new InnerStruct();
+                  _elem1.read(iprot);
+                  struct.field3.add(_elem1);
                 }
                 iprot.readListEnd();
               }
@@ -634,12 +638,12 @@ public class ThriftTestObj implements org.apache.thrift.TBase<ThriftTestObj, Thr
         {
           org.apache.thrift.protocol.TList _list5 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
           struct.field3 = new ArrayList<InnerStruct>(_list5.size);
-          for (int _i6 = 0; _i6 < _list5.size; ++_i6)
+          InnerStruct _elem6;
+          for (int _i7 = 0; _i7 < _list5.size; ++_i7)
           {
-            InnerStruct _elem7; // optional
-            _elem7 = new InnerStruct();
-            _elem7.read(iprot);
-            struct.field3.add(_elem7);
+            _elem6 = new InnerStruct();
+            _elem6.read(iprot);
+            struct.field3.add(_elem6);
           }
         }
         struct.setField3IsSet(true);


Mime
View raw message