You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hive.apache.org by na...@apache.org on 2013/04/24 08:06:07 UTC
svn commit: r1471260 [1/2] - in /hive/trunk:
metastore/src/gen/thrift/gen-php/
metastore/src/gen/thrift/gen-php/hive_metastore/
ql/src/gen/thrift/gen-php/queryplan/ serde/src/gen/thrift/gen-cpp/
serde/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/...
Author: namit
Date: Wed Apr 24 06:06:06 2013
New Revision: 1471260
URL: http://svn.apache.org/r1471260
Log:
HIVE-4300 ant thriftif generated code that is checkedin is not up-to-date
(Roshan Naik via namit)
Added:
hive/trunk/serde/src/gen/thrift/gen-cpp/complex_constants.cpp
hive/trunk/serde/src/gen/thrift/gen-cpp/complex_constants.h
hive/trunk/serde/src/gen/thrift/gen-cpp/complex_types.cpp
hive/trunk/serde/src/gen/thrift/gen-cpp/complex_types.h
hive/trunk/serde/src/gen/thrift/gen-cpp/megastruct_constants.cpp
hive/trunk/serde/src/gen/thrift/gen-cpp/megastruct_constants.h
hive/trunk/serde/src/gen/thrift/gen-cpp/megastruct_types.cpp
hive/trunk/serde/src/gen/thrift/gen-cpp/megastruct_types.h
hive/trunk/serde/src/gen/thrift/gen-cpp/testthrift_constants.cpp
hive/trunk/serde/src/gen/thrift/gen-cpp/testthrift_constants.h
hive/trunk/serde/src/gen/thrift/gen-cpp/testthrift_types.cpp
hive/trunk/serde/src/gen/thrift/gen-cpp/testthrift_types.h
hive/trunk/serde/src/gen/thrift/gen-php/Types.php
hive/trunk/serde/src/gen/thrift/gen-py/complex/
hive/trunk/serde/src/gen/thrift/gen-py/complex/__init__.py
hive/trunk/serde/src/gen/thrift/gen-py/complex/constants.py
hive/trunk/serde/src/gen/thrift/gen-py/complex/ttypes.py
hive/trunk/serde/src/gen/thrift/gen-py/megastruct/
hive/trunk/serde/src/gen/thrift/gen-py/megastruct/__init__.py
hive/trunk/serde/src/gen/thrift/gen-py/megastruct/constants.py
hive/trunk/serde/src/gen/thrift/gen-py/megastruct/ttypes.py
hive/trunk/serde/src/gen/thrift/gen-py/testthrift/
hive/trunk/serde/src/gen/thrift/gen-py/testthrift/__init__.py
hive/trunk/serde/src/gen/thrift/gen-py/testthrift/constants.py
hive/trunk/serde/src/gen/thrift/gen-py/testthrift/ttypes.py
hive/trunk/serde/src/gen/thrift/gen-rb/complex_constants.rb
hive/trunk/serde/src/gen/thrift/gen-rb/complex_types.rb
hive/trunk/serde/src/gen/thrift/gen-rb/megastruct_constants.rb
hive/trunk/serde/src/gen/thrift/gen-rb/megastruct_types.rb
hive/trunk/serde/src/gen/thrift/gen-rb/testthrift_constants.rb
hive/trunk/serde/src/gen/thrift/gen-rb/testthrift_types.rb
Removed:
hive/trunk/metastore/src/gen/thrift/gen-php/ThriftHiveMetastore.php
hive/trunk/metastore/src/gen/thrift/gen-php/hive_metastore/
hive/trunk/metastore/src/gen/thrift/gen-php/hive_metastore_constants.php
hive/trunk/metastore/src/gen/thrift/gen-php/hive_metastore_types.php
hive/trunk/ql/src/gen/thrift/gen-php/queryplan/
hive/trunk/serde/src/gen/thrift/gen-php/serde/
hive/trunk/service/src/gen/thrift/gen-php/hive_service/
Modified:
hive/trunk/serde/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/serde/test/InnerStruct.java
hive/trunk/serde/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/serde/test/ThriftTestObj.java
hive/trunk/serde/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/serde2/thrift/test/Complex.java
hive/trunk/serde/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/serde2/thrift/test/IntString.java
hive/trunk/serde/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/serde2/thrift/test/MegaStruct.java
hive/trunk/serde/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/serde2/thrift/test/MiniStruct.java
Added: hive/trunk/serde/src/gen/thrift/gen-cpp/complex_constants.cpp
URL: http://svn.apache.org/viewvc/hive/trunk/serde/src/gen/thrift/gen-cpp/complex_constants.cpp?rev=1471260&view=auto
==============================================================================
--- hive/trunk/serde/src/gen/thrift/gen-cpp/complex_constants.cpp (added)
+++ hive/trunk/serde/src/gen/thrift/gen-cpp/complex_constants.cpp Wed Apr 24 06:06:06 2013
@@ -0,0 +1,17 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+#include "complex_constants.h"
+
+
+
+const complexConstants g_complex_constants;
+
+complexConstants::complexConstants() {
+}
+
+
+
Added: hive/trunk/serde/src/gen/thrift/gen-cpp/complex_constants.h
URL: http://svn.apache.org/viewvc/hive/trunk/serde/src/gen/thrift/gen-cpp/complex_constants.h?rev=1471260&view=auto
==============================================================================
--- hive/trunk/serde/src/gen/thrift/gen-cpp/complex_constants.h (added)
+++ hive/trunk/serde/src/gen/thrift/gen-cpp/complex_constants.h Wed Apr 24 06:06:06 2013
@@ -0,0 +1,24 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+#ifndef complex_CONSTANTS_H
+#define complex_CONSTANTS_H
+
+#include "complex_types.h"
+
+
+
+class complexConstants {
+ public:
+ complexConstants();
+
+};
+
+extern const complexConstants g_complex_constants;
+
+
+
+#endif
Added: hive/trunk/serde/src/gen/thrift/gen-cpp/complex_types.cpp
URL: http://svn.apache.org/viewvc/hive/trunk/serde/src/gen/thrift/gen-cpp/complex_types.cpp?rev=1471260&view=auto
==============================================================================
--- hive/trunk/serde/src/gen/thrift/gen-cpp/complex_types.cpp (added)
+++ hive/trunk/serde/src/gen/thrift/gen-cpp/complex_types.cpp Wed Apr 24 06:06:06 2013
@@ -0,0 +1,312 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+#include "complex_types.h"
+
+#include <algorithm>
+
+
+
+const char* IntString::ascii_fingerprint = "52C6DAB6CF51AF617111F6D3964C6503";
+const uint8_t IntString::binary_fingerprint[16] = {0x52,0xC6,0xDA,0xB6,0xCF,0x51,0xAF,0x61,0x71,0x11,0xF6,0xD3,0x96,0x4C,0x65,0x03};
+
+uint32_t IntString::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;
+
+
+ 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_I32) {
+ xfer += iprot->readI32(this->myint);
+ this->__isset.myint = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->myString);
+ this->__isset.myString = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ xfer += iprot->readI32(this->underscore_int);
+ this->__isset.underscore_int = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t IntString::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("IntString");
+
+ xfer += oprot->writeFieldBegin("myint", ::apache::thrift::protocol::T_I32, 1);
+ xfer += oprot->writeI32(this->myint);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("myString", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->myString);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("underscore_int", ::apache::thrift::protocol::T_I32, 3);
+ xfer += oprot->writeI32(this->underscore_int);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(IntString &a, IntString &b) {
+ using ::std::swap;
+ swap(a.myint, b.myint);
+ swap(a.myString, b.myString);
+ swap(a.underscore_int, b.underscore_int);
+ swap(a.__isset, b.__isset);
+}
+
+const char* Complex::ascii_fingerprint = "B6556501F2F746F0BF83D55B0A9824DE";
+const uint8_t Complex::binary_fingerprint[16] = {0xB6,0x55,0x65,0x01,0xF2,0xF7,0x46,0xF0,0xBF,0x83,0xD5,0x5B,0x0A,0x98,0x24,0xDE};
+
+uint32_t Complex::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;
+
+
+ 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_I32) {
+ xfer += iprot->readI32(this->aint);
+ this->__isset.aint = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->aString);
+ this->__isset.aString = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->lint.clear();
+ uint32_t _size0;
+ ::apache::thrift::protocol::TType _etype3;
+ xfer += iprot->readListBegin(_etype3, _size0);
+ this->lint.resize(_size0);
+ uint32_t _i4;
+ for (_i4 = 0; _i4 < _size0; ++_i4)
+ {
+ xfer += iprot->readI32(this->lint[_i4]);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.lint = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->lString.clear();
+ uint32_t _size5;
+ ::apache::thrift::protocol::TType _etype8;
+ xfer += iprot->readListBegin(_etype8, _size5);
+ this->lString.resize(_size5);
+ uint32_t _i9;
+ for (_i9 = 0; _i9 < _size5; ++_i9)
+ {
+ xfer += iprot->readString(this->lString[_i9]);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.lString = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 5:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->lintString.clear();
+ uint32_t _size10;
+ ::apache::thrift::protocol::TType _etype13;
+ xfer += iprot->readListBegin(_etype13, _size10);
+ this->lintString.resize(_size10);
+ uint32_t _i14;
+ for (_i14 = 0; _i14 < _size10; ++_i14)
+ {
+ xfer += this->lintString[_i14].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.lintString = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 6:
+ if (ftype == ::apache::thrift::protocol::T_MAP) {
+ {
+ this->mStringString.clear();
+ uint32_t _size15;
+ ::apache::thrift::protocol::TType _ktype16;
+ ::apache::thrift::protocol::TType _vtype17;
+ xfer += iprot->readMapBegin(_ktype16, _vtype17, _size15);
+ uint32_t _i19;
+ for (_i19 = 0; _i19 < _size15; ++_i19)
+ {
+ std::string _key20;
+ xfer += iprot->readString(_key20);
+ std::string& _val21 = this->mStringString[_key20];
+ xfer += iprot->readString(_val21);
+ }
+ xfer += iprot->readMapEnd();
+ }
+ this->__isset.mStringString = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Complex::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Complex");
+
+ xfer += oprot->writeFieldBegin("aint", ::apache::thrift::protocol::T_I32, 1);
+ xfer += oprot->writeI32(this->aint);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("aString", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->aString);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("lint", ::apache::thrift::protocol::T_LIST, 3);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I32, static_cast<uint32_t>(this->lint.size()));
+ std::vector<int32_t> ::const_iterator _iter22;
+ for (_iter22 = this->lint.begin(); _iter22 != this->lint.end(); ++_iter22)
+ {
+ xfer += oprot->writeI32((*_iter22));
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("lString", ::apache::thrift::protocol::T_LIST, 4);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->lString.size()));
+ std::vector<std::string> ::const_iterator _iter23;
+ for (_iter23 = this->lString.begin(); _iter23 != this->lString.end(); ++_iter23)
+ {
+ xfer += oprot->writeString((*_iter23));
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("lintString", ::apache::thrift::protocol::T_LIST, 5);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->lintString.size()));
+ std::vector<IntString> ::const_iterator _iter24;
+ for (_iter24 = this->lintString.begin(); _iter24 != this->lintString.end(); ++_iter24)
+ {
+ xfer += (*_iter24).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("mStringString", ::apache::thrift::protocol::T_MAP, 6);
+ {
+ xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->mStringString.size()));
+ std::map<std::string, std::string> ::const_iterator _iter25;
+ for (_iter25 = this->mStringString.begin(); _iter25 != this->mStringString.end(); ++_iter25)
+ {
+ xfer += oprot->writeString(_iter25->first);
+ xfer += oprot->writeString(_iter25->second);
+ }
+ xfer += oprot->writeMapEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(Complex &a, Complex &b) {
+ using ::std::swap;
+ swap(a.aint, b.aint);
+ swap(a.aString, b.aString);
+ swap(a.lint, b.lint);
+ swap(a.lString, b.lString);
+ swap(a.lintString, b.lintString);
+ swap(a.mStringString, b.mStringString);
+ swap(a.__isset, b.__isset);
+}
+
+
Added: hive/trunk/serde/src/gen/thrift/gen-cpp/complex_types.h
URL: http://svn.apache.org/viewvc/hive/trunk/serde/src/gen/thrift/gen-cpp/complex_types.h?rev=1471260&view=auto
==============================================================================
--- hive/trunk/serde/src/gen/thrift/gen-cpp/complex_types.h (added)
+++ hive/trunk/serde/src/gen/thrift/gen-cpp/complex_types.h Wed Apr 24 06:06:06 2013
@@ -0,0 +1,163 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+#ifndef complex_TYPES_H
+#define complex_TYPES_H
+
+#include <thrift/Thrift.h>
+#include <thrift/TApplicationException.h>
+#include <thrift/protocol/TProtocol.h>
+#include <thrift/transport/TTransport.h>
+
+
+
+
+
+typedef struct _IntString__isset {
+ _IntString__isset() : myint(false), myString(false), underscore_int(false) {}
+ bool myint;
+ bool myString;
+ bool underscore_int;
+} _IntString__isset;
+
+class IntString {
+ public:
+
+ static const char* ascii_fingerprint; // = "52C6DAB6CF51AF617111F6D3964C6503";
+ static const uint8_t binary_fingerprint[16]; // = {0x52,0xC6,0xDA,0xB6,0xCF,0x51,0xAF,0x61,0x71,0x11,0xF6,0xD3,0x96,0x4C,0x65,0x03};
+
+ IntString() : myint(0), myString(), underscore_int(0) {
+ }
+
+ virtual ~IntString() throw() {}
+
+ int32_t myint;
+ std::string myString;
+ int32_t underscore_int;
+
+ _IntString__isset __isset;
+
+ void __set_myint(const int32_t val) {
+ myint = val;
+ }
+
+ void __set_myString(const std::string& val) {
+ myString = val;
+ }
+
+ void __set_underscore_int(const int32_t val) {
+ underscore_int = val;
+ }
+
+ bool operator == (const IntString & rhs) const
+ {
+ if (!(myint == rhs.myint))
+ return false;
+ if (!(myString == rhs.myString))
+ return false;
+ if (!(underscore_int == rhs.underscore_int))
+ return false;
+ return true;
+ }
+ bool operator != (const IntString &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const IntString & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(IntString &a, IntString &b);
+
+typedef struct _Complex__isset {
+ _Complex__isset() : aint(false), aString(false), lint(false), lString(false), lintString(false), mStringString(false) {}
+ bool aint;
+ bool aString;
+ bool lint;
+ bool lString;
+ bool lintString;
+ bool mStringString;
+} _Complex__isset;
+
+class Complex {
+ public:
+
+ static const char* ascii_fingerprint; // = "B6556501F2F746F0BF83D55B0A9824DE";
+ static const uint8_t binary_fingerprint[16]; // = {0xB6,0x55,0x65,0x01,0xF2,0xF7,0x46,0xF0,0xBF,0x83,0xD5,0x5B,0x0A,0x98,0x24,0xDE};
+
+ Complex() : aint(0), aString() {
+ }
+
+ virtual ~Complex() throw() {}
+
+ int32_t aint;
+ std::string aString;
+ std::vector<int32_t> lint;
+ std::vector<std::string> lString;
+ std::vector<IntString> lintString;
+ std::map<std::string, std::string> mStringString;
+
+ _Complex__isset __isset;
+
+ void __set_aint(const int32_t val) {
+ aint = val;
+ }
+
+ void __set_aString(const std::string& val) {
+ aString = val;
+ }
+
+ void __set_lint(const std::vector<int32_t> & val) {
+ lint = val;
+ }
+
+ void __set_lString(const std::vector<std::string> & val) {
+ lString = val;
+ }
+
+ void __set_lintString(const std::vector<IntString> & val) {
+ lintString = val;
+ }
+
+ void __set_mStringString(const std::map<std::string, std::string> & val) {
+ mStringString = val;
+ }
+
+ bool operator == (const Complex & rhs) const
+ {
+ if (!(aint == rhs.aint))
+ return false;
+ if (!(aString == rhs.aString))
+ return false;
+ if (!(lint == rhs.lint))
+ return false;
+ if (!(lString == rhs.lString))
+ return false;
+ if (!(lintString == rhs.lintString))
+ return false;
+ if (!(mStringString == rhs.mStringString))
+ return false;
+ return true;
+ }
+ bool operator != (const Complex &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Complex & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(Complex &a, Complex &b);
+
+
+
+#endif
Added: hive/trunk/serde/src/gen/thrift/gen-cpp/megastruct_constants.cpp
URL: http://svn.apache.org/viewvc/hive/trunk/serde/src/gen/thrift/gen-cpp/megastruct_constants.cpp?rev=1471260&view=auto
==============================================================================
--- hive/trunk/serde/src/gen/thrift/gen-cpp/megastruct_constants.cpp (added)
+++ hive/trunk/serde/src/gen/thrift/gen-cpp/megastruct_constants.cpp Wed Apr 24 06:06:06 2013
@@ -0,0 +1,17 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+#include "megastruct_constants.h"
+
+
+
+const megastructConstants g_megastruct_constants;
+
+megastructConstants::megastructConstants() {
+}
+
+
+
Added: hive/trunk/serde/src/gen/thrift/gen-cpp/megastruct_constants.h
URL: http://svn.apache.org/viewvc/hive/trunk/serde/src/gen/thrift/gen-cpp/megastruct_constants.h?rev=1471260&view=auto
==============================================================================
--- hive/trunk/serde/src/gen/thrift/gen-cpp/megastruct_constants.h (added)
+++ hive/trunk/serde/src/gen/thrift/gen-cpp/megastruct_constants.h Wed Apr 24 06:06:06 2013
@@ -0,0 +1,24 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+#ifndef megastruct_CONSTANTS_H
+#define megastruct_CONSTANTS_H
+
+#include "megastruct_types.h"
+
+
+
+class megastructConstants {
+ public:
+ megastructConstants();
+
+};
+
+extern const megastructConstants g_megastruct_constants;
+
+
+
+#endif
Added: hive/trunk/serde/src/gen/thrift/gen-cpp/megastruct_types.cpp
URL: http://svn.apache.org/viewvc/hive/trunk/serde/src/gen/thrift/gen-cpp/megastruct_types.cpp?rev=1471260&view=auto
==============================================================================
--- hive/trunk/serde/src/gen/thrift/gen-cpp/megastruct_types.cpp (added)
+++ hive/trunk/serde/src/gen/thrift/gen-cpp/megastruct_types.cpp Wed Apr 24 06:06:06 2013
@@ -0,0 +1,752 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+#include "megastruct_types.h"
+
+#include <algorithm>
+
+
+
+int _kMyEnumValues[] = {
+ MyEnum::LLAMA,
+ MyEnum::ALPACA
+};
+const char* _kMyEnumNames[] = {
+ "LLAMA",
+ "ALPACA"
+};
+const std::map<int, const char*> _MyEnum_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(2, _kMyEnumValues, _kMyEnumNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
+
+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};
+
+uint32_t MiniStruct::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;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->my_string);
+ this->__isset.my_string = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ int32_t ecast0;
+ xfer += iprot->readI32(ecast0);
+ this->my_enum = (MyEnum::type)ecast0;
+ this->__isset.my_enum = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t MiniStruct::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("MiniStruct");
+
+ if (this->__isset.my_string) {
+ xfer += oprot->writeFieldBegin("my_string", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->my_string);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.my_enum) {
+ xfer += oprot->writeFieldBegin("my_enum", ::apache::thrift::protocol::T_I32, 2);
+ xfer += oprot->writeI32((int32_t)this->my_enum);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(MiniStruct &a, MiniStruct &b) {
+ using ::std::swap;
+ swap(a.my_string, b.my_string);
+ swap(a.my_enum, b.my_enum);
+ swap(a.__isset, b.__isset);
+}
+
+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};
+
+uint32_t MegaStruct::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;
+
+
+ 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_BOOL) {
+ xfer += iprot->readBool(this->my_bool);
+ this->__isset.my_bool = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_BYTE) {
+ xfer += iprot->readByte(this->my_byte);
+ this->__isset.my_byte = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_I16) {
+ xfer += iprot->readI16(this->my_16bit_int);
+ this->__isset.my_16bit_int = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ xfer += iprot->readI32(this->my_32bit_int);
+ this->__isset.my_32bit_int = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 5:
+ if (ftype == ::apache::thrift::protocol::T_I64) {
+ xfer += iprot->readI64(this->my_64bit_int);
+ this->__isset.my_64bit_int = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 6:
+ if (ftype == ::apache::thrift::protocol::T_DOUBLE) {
+ xfer += iprot->readDouble(this->my_double);
+ this->__isset.my_double = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 7:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->my_string);
+ this->__isset.my_string = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 8:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readBinary(this->my_binary);
+ this->__isset.my_binary = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 9:
+ 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)
+ {
+ std::string _key6;
+ xfer += iprot->readString(_key6);
+ std::string& _val7 = this->my_string_string_map[_key6];
+ xfer += iprot->readString(_val7);
+ }
+ xfer += iprot->readMapEnd();
+ }
+ this->__isset.my_string_string_map = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 10:
+ 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)
+ {
+ 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;
+ }
+ xfer += iprot->readMapEnd();
+ }
+ this->__isset.my_string_enum_map = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 11:
+ 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)
+ {
+ 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);
+ }
+ xfer += iprot->readMapEnd();
+ }
+ this->__isset.my_enum_string_map = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 12:
+ 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)
+ {
+ 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);
+ }
+ xfer += iprot->readMapEnd();
+ }
+ this->__isset.my_enum_struct_map = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 13:
+ 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)
+ {
+ 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];
+ {
+ _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)
+ {
+ xfer += iprot->readString(_val38[_i44]);
+ }
+ xfer += iprot->readListEnd();
+ }
+ }
+ xfer += iprot->readMapEnd();
+ }
+ this->__isset.my_enum_stringlist_map = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 14:
+ 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)
+ {
+ MyEnum::type _key50;
+ int32_t ecast52;
+ xfer += iprot->readI32(ecast52);
+ _key50 = (MyEnum::type)ecast52;
+ std::vector<MiniStruct> & _val51 = this->my_enum_structlist_map[_key50];
+ {
+ _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)
+ {
+ xfer += _val51[_i57].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ }
+ xfer += iprot->readMapEnd();
+ }
+ this->__isset.my_enum_structlist_map = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 15:
+ 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)
+ {
+ xfer += iprot->readString(this->my_stringlist[_i62]);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.my_stringlist = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 16:
+ 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)
+ {
+ xfer += this->my_structlist[_i67].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.my_structlist = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 17:
+ 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)
+ {
+ int32_t ecast73;
+ xfer += iprot->readI32(ecast73);
+ this->my_enumlist[_i72] = (MyEnum::type)ecast73;
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.my_enumlist = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 18:
+ 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)
+ {
+ std::string _elem79;
+ xfer += iprot->readString(_elem79);
+ this->my_stringset.insert(_elem79);
+ }
+ xfer += iprot->readSetEnd();
+ }
+ this->__isset.my_stringset = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 19:
+ 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)
+ {
+ MyEnum::type _elem85;
+ int32_t ecast86;
+ xfer += iprot->readI32(ecast86);
+ _elem85 = (MyEnum::type)ecast86;
+ this->my_enumset.insert(_elem85);
+ }
+ xfer += iprot->readSetEnd();
+ }
+ this->__isset.my_enumset = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 20:
+ 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)
+ {
+ MiniStruct _elem92;
+ xfer += _elem92.read(iprot);
+ this->my_structset.insert(_elem92);
+ }
+ xfer += iprot->readSetEnd();
+ }
+ this->__isset.my_structset = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t MegaStruct::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("MegaStruct");
+
+ if (this->__isset.my_bool) {
+ xfer += oprot->writeFieldBegin("my_bool", ::apache::thrift::protocol::T_BOOL, 1);
+ xfer += oprot->writeBool(this->my_bool);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.my_byte) {
+ xfer += oprot->writeFieldBegin("my_byte", ::apache::thrift::protocol::T_BYTE, 2);
+ xfer += oprot->writeByte(this->my_byte);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.my_16bit_int) {
+ xfer += oprot->writeFieldBegin("my_16bit_int", ::apache::thrift::protocol::T_I16, 3);
+ xfer += oprot->writeI16(this->my_16bit_int);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.my_32bit_int) {
+ xfer += oprot->writeFieldBegin("my_32bit_int", ::apache::thrift::protocol::T_I32, 4);
+ xfer += oprot->writeI32(this->my_32bit_int);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.my_64bit_int) {
+ xfer += oprot->writeFieldBegin("my_64bit_int", ::apache::thrift::protocol::T_I64, 5);
+ xfer += oprot->writeI64(this->my_64bit_int);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.my_double) {
+ xfer += oprot->writeFieldBegin("my_double", ::apache::thrift::protocol::T_DOUBLE, 6);
+ xfer += oprot->writeDouble(this->my_double);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.my_string) {
+ xfer += oprot->writeFieldBegin("my_string", ::apache::thrift::protocol::T_STRING, 7);
+ xfer += oprot->writeString(this->my_string);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.my_binary) {
+ xfer += oprot->writeFieldBegin("my_binary", ::apache::thrift::protocol::T_STRING, 8);
+ xfer += oprot->writeBinary(this->my_binary);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.my_string_string_map) {
+ 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)
+ {
+ xfer += oprot->writeString(_iter93->first);
+ xfer += oprot->writeString(_iter93->second);
+ }
+ xfer += oprot->writeMapEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.my_string_enum_map) {
+ 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)
+ {
+ xfer += oprot->writeString(_iter94->first);
+ xfer += oprot->writeI32((int32_t)_iter94->second);
+ }
+ xfer += oprot->writeMapEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.my_enum_string_map) {
+ 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)
+ {
+ xfer += oprot->writeI32((int32_t)_iter95->first);
+ xfer += oprot->writeString(_iter95->second);
+ }
+ xfer += oprot->writeMapEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.my_enum_struct_map) {
+ 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)
+ {
+ xfer += oprot->writeI32((int32_t)_iter96->first);
+ xfer += _iter96->second.write(oprot);
+ }
+ xfer += oprot->writeMapEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.my_enum_stringlist_map) {
+ 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)
+ {
+ xfer += oprot->writeI32((int32_t)_iter97->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->writeString((*_iter98));
+ }
+ xfer += oprot->writeListEnd();
+ }
+ }
+ xfer += oprot->writeMapEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.my_enum_structlist_map) {
+ 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)
+ {
+ xfer += oprot->writeI32((int32_t)_iter99->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 += (*_iter100).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ }
+ xfer += oprot->writeMapEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.my_stringlist) {
+ 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)
+ {
+ xfer += oprot->writeString((*_iter101));
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.my_structlist) {
+ 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)
+ {
+ xfer += (*_iter102).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.my_enumlist) {
+ 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)
+ {
+ xfer += oprot->writeI32((int32_t)(*_iter103));
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.my_stringset) {
+ 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)
+ {
+ xfer += oprot->writeString((*_iter104));
+ }
+ xfer += oprot->writeSetEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.my_enumset) {
+ 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)
+ {
+ xfer += oprot->writeI32((int32_t)(*_iter105));
+ }
+ xfer += oprot->writeSetEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.my_structset) {
+ 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)
+ {
+ xfer += (*_iter106).write(oprot);
+ }
+ xfer += oprot->writeSetEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(MegaStruct &a, MegaStruct &b) {
+ using ::std::swap;
+ swap(a.my_bool, b.my_bool);
+ swap(a.my_byte, b.my_byte);
+ swap(a.my_16bit_int, b.my_16bit_int);
+ swap(a.my_32bit_int, b.my_32bit_int);
+ swap(a.my_64bit_int, b.my_64bit_int);
+ swap(a.my_double, b.my_double);
+ swap(a.my_string, b.my_string);
+ swap(a.my_binary, b.my_binary);
+ swap(a.my_string_string_map, b.my_string_string_map);
+ swap(a.my_string_enum_map, b.my_string_enum_map);
+ swap(a.my_enum_string_map, b.my_enum_string_map);
+ swap(a.my_enum_struct_map, b.my_enum_struct_map);
+ swap(a.my_enum_stringlist_map, b.my_enum_stringlist_map);
+ swap(a.my_enum_structlist_map, b.my_enum_structlist_map);
+ swap(a.my_stringlist, b.my_stringlist);
+ swap(a.my_structlist, b.my_structlist);
+ swap(a.my_enumlist, b.my_enumlist);
+ swap(a.my_stringset, b.my_stringset);
+ swap(a.my_enumset, b.my_enumset);
+ swap(a.my_structset, b.my_structset);
+ swap(a.__isset, b.__isset);
+}
+
+
Added: hive/trunk/serde/src/gen/thrift/gen-cpp/megastruct_types.h
URL: http://svn.apache.org/viewvc/hive/trunk/serde/src/gen/thrift/gen-cpp/megastruct_types.h?rev=1471260&view=auto
==============================================================================
--- hive/trunk/serde/src/gen/thrift/gen-cpp/megastruct_types.h (added)
+++ hive/trunk/serde/src/gen/thrift/gen-cpp/megastruct_types.h Wed Apr 24 06:06:06 2013
@@ -0,0 +1,342 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+#ifndef megastruct_TYPES_H
+#define megastruct_TYPES_H
+
+#include <thrift/Thrift.h>
+#include <thrift/TApplicationException.h>
+#include <thrift/protocol/TProtocol.h>
+#include <thrift/transport/TTransport.h>
+
+
+
+
+
+struct MyEnum {
+ enum type {
+ LLAMA = 1,
+ ALPACA = 2
+ };
+};
+
+extern const std::map<int, const char*> _MyEnum_VALUES_TO_NAMES;
+
+typedef struct _MiniStruct__isset {
+ _MiniStruct__isset() : my_string(false), my_enum(false) {}
+ bool my_string;
+ bool my_enum;
+} _MiniStruct__isset;
+
+class MiniStruct {
+ public:
+
+ 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() : my_string(), my_enum((MyEnum::type)0) {
+ }
+
+ 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_enum(const MyEnum::type val) {
+ my_enum = val;
+ __isset.my_enum = true;
+ }
+
+ bool operator == (const MiniStruct & rhs) const
+ {
+ if (__isset.my_string != rhs.__isset.my_string)
+ return false;
+ else if (__isset.my_string && !(my_string == rhs.my_string))
+ return false;
+ if (__isset.my_enum != rhs.__isset.my_enum)
+ return false;
+ else if (__isset.my_enum && !(my_enum == rhs.my_enum))
+ return false;
+ return true;
+ }
+ bool operator != (const MiniStruct &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const MiniStruct & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+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;
+} _MegaStruct__isset;
+
+class MegaStruct {
+ public:
+
+ 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() : 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() {}
+
+ bool my_bool;
+ int8_t my_byte;
+ int16_t my_16bit_int;
+ int32_t my_32bit_int;
+ int64_t my_64bit_int;
+ double my_double;
+ std::string my_string;
+ std::string my_binary;
+ std::map<std::string, std::string> my_string_string_map;
+ std::map<std::string, MyEnum::type> my_string_enum_map;
+ std::map<MyEnum::type, std::string> my_enum_string_map;
+ std::map<MyEnum::type, MiniStruct> my_enum_struct_map;
+ std::map<MyEnum::type, std::vector<std::string> > my_enum_stringlist_map;
+ std::map<MyEnum::type, std::vector<MiniStruct> > my_enum_structlist_map;
+ std::vector<std::string> my_stringlist;
+ std::vector<MiniStruct> my_structlist;
+ std::vector<MyEnum::type> my_enumlist;
+ std::set<std::string> my_stringset;
+ std::set<MyEnum::type> my_enumset;
+ std::set<MiniStruct> my_structset;
+
+ _MegaStruct__isset __isset;
+
+ void __set_my_bool(const bool val) {
+ my_bool = val;
+ __isset.my_bool = true;
+ }
+
+ void __set_my_byte(const int8_t val) {
+ my_byte = val;
+ __isset.my_byte = true;
+ }
+
+ void __set_my_16bit_int(const int16_t val) {
+ my_16bit_int = val;
+ __isset.my_16bit_int = true;
+ }
+
+ void __set_my_32bit_int(const int32_t val) {
+ my_32bit_int = val;
+ __isset.my_32bit_int = true;
+ }
+
+ void __set_my_64bit_int(const int64_t val) {
+ my_64bit_int = val;
+ __isset.my_64bit_int = true;
+ }
+
+ void __set_my_double(const double val) {
+ my_double = val;
+ __isset.my_double = true;
+ }
+
+ void __set_my_string(const std::string& val) {
+ my_string = val;
+ __isset.my_string = true;
+ }
+
+ void __set_my_binary(const std::string& val) {
+ my_binary = val;
+ __isset.my_binary = true;
+ }
+
+ 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_enum_map(const std::map<std::string, MyEnum::type> & val) {
+ my_string_enum_map = val;
+ __isset.my_string_enum_map = true;
+ }
+
+ 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_struct_map(const std::map<MyEnum::type, MiniStruct> & val) {
+ my_enum_struct_map = val;
+ __isset.my_enum_struct_map = true;
+ }
+
+ 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_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_stringlist(const std::vector<std::string> & val) {
+ my_stringlist = val;
+ __isset.my_stringlist = true;
+ }
+
+ void __set_my_structlist(const std::vector<MiniStruct> & val) {
+ my_structlist = val;
+ __isset.my_structlist = true;
+ }
+
+ void __set_my_enumlist(const std::vector<MyEnum::type> & val) {
+ my_enumlist = val;
+ __isset.my_enumlist = true;
+ }
+
+ void __set_my_stringset(const std::set<std::string> & val) {
+ my_stringset = val;
+ __isset.my_stringset = true;
+ }
+
+ void __set_my_enumset(const std::set<MyEnum::type> & val) {
+ my_enumset = val;
+ __isset.my_enumset = true;
+ }
+
+ void __set_my_structset(const std::set<MiniStruct> & val) {
+ my_structset = val;
+ __isset.my_structset = true;
+ }
+
+ bool operator == (const MegaStruct & rhs) const
+ {
+ if (__isset.my_bool != rhs.__isset.my_bool)
+ return false;
+ else if (__isset.my_bool && !(my_bool == rhs.my_bool))
+ return false;
+ if (__isset.my_byte != rhs.__isset.my_byte)
+ return false;
+ else if (__isset.my_byte && !(my_byte == rhs.my_byte))
+ return false;
+ if (__isset.my_16bit_int != rhs.__isset.my_16bit_int)
+ return false;
+ else if (__isset.my_16bit_int && !(my_16bit_int == rhs.my_16bit_int))
+ return false;
+ if (__isset.my_32bit_int != rhs.__isset.my_32bit_int)
+ return false;
+ else if (__isset.my_32bit_int && !(my_32bit_int == rhs.my_32bit_int))
+ return false;
+ if (__isset.my_64bit_int != rhs.__isset.my_64bit_int)
+ return false;
+ else if (__isset.my_64bit_int && !(my_64bit_int == rhs.my_64bit_int))
+ return false;
+ if (__isset.my_double != rhs.__isset.my_double)
+ return false;
+ else if (__isset.my_double && !(my_double == rhs.my_double))
+ return false;
+ if (__isset.my_string != rhs.__isset.my_string)
+ return false;
+ else if (__isset.my_string && !(my_string == rhs.my_string))
+ return false;
+ if (__isset.my_binary != rhs.__isset.my_binary)
+ return false;
+ else if (__isset.my_binary && !(my_binary == rhs.my_binary))
+ return false;
+ if (__isset.my_string_string_map != rhs.__isset.my_string_string_map)
+ return false;
+ else if (__isset.my_string_string_map && !(my_string_string_map == rhs.my_string_string_map))
+ return false;
+ if (__isset.my_string_enum_map != rhs.__isset.my_string_enum_map)
+ return false;
+ else if (__isset.my_string_enum_map && !(my_string_enum_map == rhs.my_string_enum_map))
+ return false;
+ if (__isset.my_enum_string_map != rhs.__isset.my_enum_string_map)
+ return false;
+ else if (__isset.my_enum_string_map && !(my_enum_string_map == rhs.my_enum_string_map))
+ return false;
+ if (__isset.my_enum_struct_map != rhs.__isset.my_enum_struct_map)
+ return false;
+ else if (__isset.my_enum_struct_map && !(my_enum_struct_map == rhs.my_enum_struct_map))
+ return false;
+ if (__isset.my_enum_stringlist_map != rhs.__isset.my_enum_stringlist_map)
+ return false;
+ else if (__isset.my_enum_stringlist_map && !(my_enum_stringlist_map == rhs.my_enum_stringlist_map))
+ return false;
+ if (__isset.my_enum_structlist_map != rhs.__isset.my_enum_structlist_map)
+ return false;
+ else if (__isset.my_enum_structlist_map && !(my_enum_structlist_map == rhs.my_enum_structlist_map))
+ return false;
+ if (__isset.my_stringlist != rhs.__isset.my_stringlist)
+ return false;
+ else if (__isset.my_stringlist && !(my_stringlist == rhs.my_stringlist))
+ return false;
+ if (__isset.my_structlist != rhs.__isset.my_structlist)
+ return false;
+ else if (__isset.my_structlist && !(my_structlist == rhs.my_structlist))
+ return false;
+ if (__isset.my_enumlist != rhs.__isset.my_enumlist)
+ return false;
+ else if (__isset.my_enumlist && !(my_enumlist == rhs.my_enumlist))
+ return false;
+ if (__isset.my_stringset != rhs.__isset.my_stringset)
+ return false;
+ else if (__isset.my_stringset && !(my_stringset == rhs.my_stringset))
+ return false;
+ if (__isset.my_enumset != rhs.__isset.my_enumset)
+ return false;
+ else if (__isset.my_enumset && !(my_enumset == rhs.my_enumset))
+ return false;
+ if (__isset.my_structset != rhs.__isset.my_structset)
+ return false;
+ else if (__isset.my_structset && !(my_structset == rhs.my_structset))
+ return false;
+ return true;
+ }
+ bool operator != (const MegaStruct &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const MegaStruct & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(MegaStruct &a, MegaStruct &b);
+
+
+
+#endif
Added: hive/trunk/serde/src/gen/thrift/gen-cpp/testthrift_constants.cpp
URL: http://svn.apache.org/viewvc/hive/trunk/serde/src/gen/thrift/gen-cpp/testthrift_constants.cpp?rev=1471260&view=auto
==============================================================================
--- hive/trunk/serde/src/gen/thrift/gen-cpp/testthrift_constants.cpp (added)
+++ hive/trunk/serde/src/gen/thrift/gen-cpp/testthrift_constants.cpp Wed Apr 24 06:06:06 2013
@@ -0,0 +1,17 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+#include "testthrift_constants.h"
+
+
+
+const testthriftConstants g_testthrift_constants;
+
+testthriftConstants::testthriftConstants() {
+}
+
+
+
Added: hive/trunk/serde/src/gen/thrift/gen-cpp/testthrift_constants.h
URL: http://svn.apache.org/viewvc/hive/trunk/serde/src/gen/thrift/gen-cpp/testthrift_constants.h?rev=1471260&view=auto
==============================================================================
--- hive/trunk/serde/src/gen/thrift/gen-cpp/testthrift_constants.h (added)
+++ hive/trunk/serde/src/gen/thrift/gen-cpp/testthrift_constants.h Wed Apr 24 06:06:06 2013
@@ -0,0 +1,24 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+#ifndef testthrift_CONSTANTS_H
+#define testthrift_CONSTANTS_H
+
+#include "testthrift_types.h"
+
+
+
+class testthriftConstants {
+ public:
+ testthriftConstants();
+
+};
+
+extern const testthriftConstants g_testthrift_constants;
+
+
+
+#endif
Added: hive/trunk/serde/src/gen/thrift/gen-cpp/testthrift_types.cpp
URL: http://svn.apache.org/viewvc/hive/trunk/serde/src/gen/thrift/gen-cpp/testthrift_types.cpp?rev=1471260&view=auto
==============================================================================
--- hive/trunk/serde/src/gen/thrift/gen-cpp/testthrift_types.cpp (added)
+++ hive/trunk/serde/src/gen/thrift/gen-cpp/testthrift_types.cpp Wed Apr 24 06:06:06 2013
@@ -0,0 +1,183 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+#include "testthrift_types.h"
+
+#include <algorithm>
+
+
+
+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};
+
+uint32_t InnerStruct::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;
+
+
+ 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_I32) {
+ xfer += iprot->readI32(this->field0);
+ this->__isset.field0 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t InnerStruct::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("InnerStruct");
+
+ xfer += oprot->writeFieldBegin("field0", ::apache::thrift::protocol::T_I32, 1);
+ xfer += oprot->writeI32(this->field0);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(InnerStruct &a, InnerStruct &b) {
+ using ::std::swap;
+ swap(a.field0, b.field0);
+ swap(a.__isset, b.__isset);
+}
+
+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};
+
+uint32_t ThriftTestObj::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;
+
+
+ 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_I32) {
+ xfer += iprot->readI32(this->field1);
+ this->__isset.field1 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->field2);
+ this->__isset.field2 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ 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)
+ {
+ xfer += this->field3[_i4].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.field3 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t ThriftTestObj::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ThriftTestObj");
+
+ xfer += oprot->writeFieldBegin("field1", ::apache::thrift::protocol::T_I32, 1);
+ xfer += oprot->writeI32(this->field1);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("field2", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->field2);
+ xfer += oprot->writeFieldEnd();
+
+ 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)
+ {
+ xfer += (*_iter5).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(ThriftTestObj &a, ThriftTestObj &b) {
+ using ::std::swap;
+ swap(a.field1, b.field1);
+ swap(a.field2, b.field2);
+ swap(a.field3, b.field3);
+ swap(a.__isset, b.__isset);
+}
+
+
Added: hive/trunk/serde/src/gen/thrift/gen-cpp/testthrift_types.h
URL: http://svn.apache.org/viewvc/hive/trunk/serde/src/gen/thrift/gen-cpp/testthrift_types.h?rev=1471260&view=auto
==============================================================================
--- hive/trunk/serde/src/gen/thrift/gen-cpp/testthrift_types.h (added)
+++ hive/trunk/serde/src/gen/thrift/gen-cpp/testthrift_types.h Wed Apr 24 06:06:06 2013
@@ -0,0 +1,123 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+#ifndef testthrift_TYPES_H
+#define testthrift_TYPES_H
+
+#include <thrift/Thrift.h>
+#include <thrift/TApplicationException.h>
+#include <thrift/protocol/TProtocol.h>
+#include <thrift/transport/TTransport.h>
+
+
+
+
+
+typedef struct _InnerStruct__isset {
+ _InnerStruct__isset() : field0(false) {}
+ bool field0;
+} _InnerStruct__isset;
+
+class InnerStruct {
+ public:
+
+ 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() : field0(0) {
+ }
+
+ virtual ~InnerStruct() throw() {}
+
+ int32_t field0;
+
+ _InnerStruct__isset __isset;
+
+ void __set_field0(const int32_t val) {
+ field0 = val;
+ }
+
+ bool operator == (const InnerStruct & rhs) const
+ {
+ if (!(field0 == rhs.field0))
+ return false;
+ return true;
+ }
+ bool operator != (const InnerStruct &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const InnerStruct & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(InnerStruct &a, InnerStruct &b);
+
+typedef struct _ThriftTestObj__isset {
+ _ThriftTestObj__isset() : field1(false), field2(false), field3(false) {}
+ bool field1;
+ bool field2;
+ bool field3;
+} _ThriftTestObj__isset;
+
+class ThriftTestObj {
+ public:
+
+ 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() : field1(0), field2() {
+ }
+
+ 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_field2(const std::string& val) {
+ field2 = val;
+ }
+
+ void __set_field3(const std::vector<InnerStruct> & val) {
+ field3 = val;
+ }
+
+ bool operator == (const ThriftTestObj & rhs) const
+ {
+ if (!(field1 == rhs.field1))
+ return false;
+ if (!(field2 == rhs.field2))
+ return false;
+ if (!(field3 == rhs.field3))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftTestObj &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftTestObj & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(ThriftTestObj &a, ThriftTestObj &b);
+
+
+
+#endif
Modified: hive/trunk/serde/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/serde/test/InnerStruct.java
URL: http://svn.apache.org/viewvc/hive/trunk/serde/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/serde/test/InnerStruct.java?rev=1471260&r1=1471259&r2=1471260&view=diff
==============================================================================
--- hive/trunk/serde/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/serde/test/InnerStruct.java (original)
+++ hive/trunk/serde/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/serde/test/InnerStruct.java Wed Apr 24 06:06:06 2013
@@ -6,6 +6,7 @@
*/
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;
@@ -226,7 +227,14 @@ public class InnerStruct implements org.
@Override
public int hashCode() {
- return 0;
+ HashCodeBuilder builder = new HashCodeBuilder();
+
+ boolean present_field0 = true;
+ builder.append(present_field0);
+ if (present_field0)
+ builder.append(field0);
+
+ return builder.toHashCode();
}
public int compareTo(InnerStruct other) {
Modified: hive/trunk/serde/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/serde/test/ThriftTestObj.java
URL: http://svn.apache.org/viewvc/hive/trunk/serde/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/serde/test/ThriftTestObj.java?rev=1471260&r1=1471259&r2=1471260&view=diff
==============================================================================
--- hive/trunk/serde/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/serde/test/ThriftTestObj.java (original)
+++ hive/trunk/serde/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/serde/test/ThriftTestObj.java Wed Apr 24 06:06:06 2013
@@ -6,6 +6,7 @@
*/
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;
@@ -362,7 +363,24 @@ public class ThriftTestObj implements or
@Override
public int hashCode() {
- return 0;
+ HashCodeBuilder builder = new HashCodeBuilder();
+
+ boolean present_field1 = true;
+ builder.append(present_field1);
+ if (present_field1)
+ builder.append(field1);
+
+ boolean present_field2 = true && (isSetField2());
+ builder.append(present_field2);
+ if (present_field2)
+ builder.append(field2);
+
+ boolean present_field3 = true && (isSetField3());
+ builder.append(present_field3);
+ if (present_field3)
+ builder.append(field3);
+
+ return builder.toHashCode();
}
public int compareTo(ThriftTestObj other) {
Modified: hive/trunk/serde/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/serde2/thrift/test/Complex.java
URL: http://svn.apache.org/viewvc/hive/trunk/serde/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/serde2/thrift/test/Complex.java?rev=1471260&r1=1471259&r2=1471260&view=diff
==============================================================================
--- hive/trunk/serde/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/serde2/thrift/test/Complex.java (original)
+++ hive/trunk/serde/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/serde2/thrift/test/Complex.java Wed Apr 24 06:06:06 2013
@@ -6,6 +6,7 @@
*/
package org.apache.hadoop.hive.serde2.thrift.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;
@@ -601,7 +602,39 @@ public class Complex implements org.apac
@Override
public int hashCode() {
- return 0;
+ HashCodeBuilder builder = new HashCodeBuilder();
+
+ boolean present_aint = true;
+ builder.append(present_aint);
+ if (present_aint)
+ builder.append(aint);
+
+ boolean present_aString = true && (isSetAString());
+ builder.append(present_aString);
+ if (present_aString)
+ builder.append(aString);
+
+ boolean present_lint = true && (isSetLint());
+ builder.append(present_lint);
+ if (present_lint)
+ builder.append(lint);
+
+ boolean present_lString = true && (isSetLString());
+ builder.append(present_lString);
+ if (present_lString)
+ builder.append(lString);
+
+ boolean present_lintString = true && (isSetLintString());
+ builder.append(present_lintString);
+ if (present_lintString)
+ builder.append(lintString);
+
+ boolean present_mStringString = true && (isSetMStringString());
+ builder.append(present_mStringString);
+ if (present_mStringString)
+ builder.append(mStringString);
+
+ return builder.toHashCode();
}
public int compareTo(Complex other) {
@@ -859,7 +892,7 @@ public class Complex implements org.apac
for (int _i10 = 0; _i10 < _map9.size; ++_i10)
{
String _key11; // required
- String _val12; // optional
+ String _val12; // required
_key11 = iprot.readString();
_val12 = iprot.readString();
struct.mStringString.put(_key11, _val12);
@@ -1082,7 +1115,7 @@ public class Complex implements org.apac
for (int _i31 = 0; _i31 < _map30.size; ++_i31)
{
String _key32; // required
- String _val33; // optional
+ String _val33; // required
_key32 = iprot.readString();
_val33 = iprot.readString();
struct.mStringString.put(_key32, _val33);
Modified: hive/trunk/serde/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/serde2/thrift/test/IntString.java
URL: http://svn.apache.org/viewvc/hive/trunk/serde/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/serde2/thrift/test/IntString.java?rev=1471260&r1=1471259&r2=1471260&view=diff
==============================================================================
--- hive/trunk/serde/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/serde2/thrift/test/IntString.java (original)
+++ hive/trunk/serde/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/serde2/thrift/test/IntString.java Wed Apr 24 06:06:06 2013
@@ -6,6 +6,7 @@
*/
package org.apache.hadoop.hive.serde2.thrift.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;
@@ -342,7 +343,24 @@ public class IntString implements org.ap
@Override
public int hashCode() {
- return 0;
+ HashCodeBuilder builder = new HashCodeBuilder();
+
+ boolean present_myint = true;
+ builder.append(present_myint);
+ if (present_myint)
+ builder.append(myint);
+
+ boolean present_myString = true && (isSetMyString());
+ builder.append(present_myString);
+ if (present_myString)
+ builder.append(myString);
+
+ boolean present_underscore_int = true;
+ builder.append(present_underscore_int);
+ if (present_underscore_int)
+ builder.append(underscore_int);
+
+ return builder.toHashCode();
}
public int compareTo(IntString other) {
Modified: hive/trunk/serde/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/serde2/thrift/test/MegaStruct.java
URL: http://svn.apache.org/viewvc/hive/trunk/serde/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/serde2/thrift/test/MegaStruct.java?rev=1471260&r1=1471259&r2=1471260&view=diff
==============================================================================
--- hive/trunk/serde/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/serde2/thrift/test/MegaStruct.java (original)
+++ hive/trunk/serde/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/serde2/thrift/test/MegaStruct.java Wed Apr 24 06:06:06 2013
@@ -6,6 +6,7 @@
*/
package org.apache.hadoop.hive.serde2.thrift.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;
@@ -1566,7 +1567,109 @@ public class MegaStruct implements org.a
@Override
public int hashCode() {
- return 0;
+ HashCodeBuilder builder = new HashCodeBuilder();
+
+ boolean present_my_bool = true && (isSetMy_bool());
+ builder.append(present_my_bool);
+ if (present_my_bool)
+ builder.append(my_bool);
+
+ boolean present_my_byte = true && (isSetMy_byte());
+ builder.append(present_my_byte);
+ if (present_my_byte)
+ builder.append(my_byte);
+
+ boolean present_my_16bit_int = true && (isSetMy_16bit_int());
+ builder.append(present_my_16bit_int);
+ if (present_my_16bit_int)
+ builder.append(my_16bit_int);
+
+ boolean present_my_32bit_int = true && (isSetMy_32bit_int());
+ builder.append(present_my_32bit_int);
+ if (present_my_32bit_int)
+ builder.append(my_32bit_int);
+
+ boolean present_my_64bit_int = true && (isSetMy_64bit_int());
+ builder.append(present_my_64bit_int);
+ if (present_my_64bit_int)
+ builder.append(my_64bit_int);
+
+ boolean present_my_double = true && (isSetMy_double());
+ builder.append(present_my_double);
+ if (present_my_double)
+ builder.append(my_double);
+
+ boolean present_my_string = true && (isSetMy_string());
+ builder.append(present_my_string);
+ if (present_my_string)
+ builder.append(my_string);
+
+ boolean present_my_binary = true && (isSetMy_binary());
+ builder.append(present_my_binary);
+ if (present_my_binary)
+ builder.append(my_binary);
+
+ boolean present_my_string_string_map = true && (isSetMy_string_string_map());
+ builder.append(present_my_string_string_map);
+ if (present_my_string_string_map)
+ builder.append(my_string_string_map);
+
+ boolean present_my_string_enum_map = true && (isSetMy_string_enum_map());
+ builder.append(present_my_string_enum_map);
+ if (present_my_string_enum_map)
+ builder.append(my_string_enum_map);
+
+ boolean present_my_enum_string_map = true && (isSetMy_enum_string_map());
+ builder.append(present_my_enum_string_map);
+ if (present_my_enum_string_map)
+ builder.append(my_enum_string_map);
+
+ boolean present_my_enum_struct_map = true && (isSetMy_enum_struct_map());
+ builder.append(present_my_enum_struct_map);
+ if (present_my_enum_struct_map)
+ builder.append(my_enum_struct_map);
+
+ boolean present_my_enum_stringlist_map = true && (isSetMy_enum_stringlist_map());
+ builder.append(present_my_enum_stringlist_map);
+ if (present_my_enum_stringlist_map)
+ builder.append(my_enum_stringlist_map);
+
+ boolean present_my_enum_structlist_map = true && (isSetMy_enum_structlist_map());
+ builder.append(present_my_enum_structlist_map);
+ if (present_my_enum_structlist_map)
+ builder.append(my_enum_structlist_map);
+
+ boolean present_my_stringlist = true && (isSetMy_stringlist());
+ builder.append(present_my_stringlist);
+ if (present_my_stringlist)
+ builder.append(my_stringlist);
+
+ boolean present_my_structlist = true && (isSetMy_structlist());
+ builder.append(present_my_structlist);
+ if (present_my_structlist)
+ builder.append(my_structlist);
+
+ boolean present_my_enumlist = true && (isSetMy_enumlist());
+ builder.append(present_my_enumlist);
+ if (present_my_enumlist)
+ builder.append(my_enumlist);
+
+ boolean present_my_stringset = true && (isSetMy_stringset());
+ builder.append(present_my_stringset);
+ if (present_my_stringset)
+ builder.append(my_stringset);
+
+ boolean present_my_enumset = true && (isSetMy_enumset());
+ builder.append(present_my_enumset);
+ if (present_my_enumset)
+ builder.append(my_enumset);
+
+ boolean present_my_structset = true && (isSetMy_structset());
+ builder.append(present_my_structset);
+ if (present_my_structset)
+ builder.append(my_structset);
+
+ return builder.toHashCode();
}
public int compareTo(MegaStruct other) {
@@ -2089,7 +2192,7 @@ public class MegaStruct implements org.a
for (int _i1 = 0; _i1 < _map0.size; ++_i1)
{
String _key2; // required
- String _val3; // optional
+ String _val3; // required
_key2 = iprot.readString();
_val3 = iprot.readString();
struct.my_string_string_map.put(_key2, _val3);
@@ -2109,7 +2212,7 @@ public class MegaStruct implements org.a
for (int _i5 = 0; _i5 < _map4.size; ++_i5)
{
String _key6; // required
- MyEnum _val7; // optional
+ MyEnum _val7; // required
_key6 = iprot.readString();
_val7 = MyEnum.findByValue(iprot.readI32());
struct.my_string_enum_map.put(_key6, _val7);
@@ -2129,7 +2232,7 @@ public class MegaStruct implements org.a
for (int _i9 = 0; _i9 < _map8.size; ++_i9)
{
MyEnum _key10; // required
- String _val11; // optional
+ String _val11; // required
_key10 = MyEnum.findByValue(iprot.readI32());
_val11 = iprot.readString();
struct.my_enum_string_map.put(_key10, _val11);
@@ -2149,7 +2252,7 @@ public class MegaStruct implements org.a
for (int _i13 = 0; _i13 < _map12.size; ++_i13)
{
MyEnum _key14; // required
- MiniStruct _val15; // optional
+ MiniStruct _val15; // required
_key14 = MyEnum.findByValue(iprot.readI32());
_val15 = new MiniStruct();
_val15.read(iprot);
@@ -2170,7 +2273,7 @@ public class MegaStruct implements org.a
for (int _i17 = 0; _i17 < _map16.size; ++_i17)
{
MyEnum _key18; // required
- List<String> _val19; // optional
+ List<String> _val19; // required
_key18 = MyEnum.findByValue(iprot.readI32());
{
org.apache.thrift.protocol.TList _list20 = iprot.readListBegin();
@@ -2200,7 +2303,7 @@ public class MegaStruct implements org.a
for (int _i24 = 0; _i24 < _map23.size; ++_i24)
{
MyEnum _key25; // required
- List<MiniStruct> _val26; // optional
+ List<MiniStruct> _val26; // required
_key25 = MyEnum.findByValue(iprot.readI32());
{
org.apache.thrift.protocol.TList _list27 = iprot.readListBegin();
@@ -2852,7 +2955,7 @@ public class MegaStruct implements org.a
for (int _i77 = 0; _i77 < _map76.size; ++_i77)
{
String _key78; // required
- String _val79; // optional
+ String _val79; // required
_key78 = iprot.readString();
_val79 = iprot.readString();
struct.my_string_string_map.put(_key78, _val79);
@@ -2867,7 +2970,7 @@ public class MegaStruct implements org.a
for (int _i81 = 0; _i81 < _map80.size; ++_i81)
{
String _key82; // required
- MyEnum _val83; // optional
+ MyEnum _val83; // required
_key82 = iprot.readString();
_val83 = MyEnum.findByValue(iprot.readI32());
struct.my_string_enum_map.put(_key82, _val83);
@@ -2882,7 +2985,7 @@ public class MegaStruct implements org.a
for (int _i85 = 0; _i85 < _map84.size; ++_i85)
{
MyEnum _key86; // required
- String _val87; // optional
+ String _val87; // required
_key86 = MyEnum.findByValue(iprot.readI32());
_val87 = iprot.readString();
struct.my_enum_string_map.put(_key86, _val87);
@@ -2897,7 +3000,7 @@ public class MegaStruct implements org.a
for (int _i89 = 0; _i89 < _map88.size; ++_i89)
{
MyEnum _key90; // required
- MiniStruct _val91; // optional
+ MiniStruct _val91; // required
_key90 = MyEnum.findByValue(iprot.readI32());
_val91 = new MiniStruct();
_val91.read(iprot);
@@ -2913,7 +3016,7 @@ public class MegaStruct implements org.a
for (int _i93 = 0; _i93 < _map92.size; ++_i93)
{
MyEnum _key94; // required
- List<String> _val95; // optional
+ List<String> _val95; // required
_key94 = MyEnum.findByValue(iprot.readI32());
{
org.apache.thrift.protocol.TList _list96 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32());
@@ -2937,7 +3040,7 @@ public class MegaStruct implements org.a
for (int _i100 = 0; _i100 < _map99.size; ++_i100)
{
MyEnum _key101; // required
- List<MiniStruct> _val102; // optional
+ List<MiniStruct> _val102; // required
_key101 = MyEnum.findByValue(iprot.readI32());
{
org.apache.thrift.protocol.TList _list103 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());