From 7a09483993be2b42b60224829534d5c976e5f9e2 Mon Sep 17 00:00:00 2001 From: Jens Geyer Date: Sun, 8 Sep 2013 00:36:22 +0200 Subject: [PATCH] THRIFT-2159 Serializer/Deserializer for Go Patch: Justin Judd --- lib/go/thrift/deserializer.go | 39 ++ lib/go/thrift/serializer.go | 74 ++++ lib/go/thrift/serializer_test.go | 150 ++++++++ lib/go/thrift/serializer_types.go | 578 ++++++++++++++++++++++++++++++ 4 files changed, 841 insertions(+) create mode 100644 lib/go/thrift/deserializer.go create mode 100644 lib/go/thrift/serializer.go create mode 100644 lib/go/thrift/serializer_test.go create mode 100644 lib/go/thrift/serializer_types.go diff --git a/lib/go/thrift/deserializer.go b/lib/go/thrift/deserializer.go new file mode 100644 index 00000000..e7effb17 --- /dev/null +++ b/lib/go/thrift/deserializer.go @@ -0,0 +1,39 @@ +package thrift + +type TDeserializer struct { + Transport TTransport + Protocol TProtocol +} + +func NewTDeserializer() *TDeserializer { + var transport TTransport + transport = NewTMemoryBufferLen(1024) + + protocol := NewTBinaryProtocolFactoryDefault().GetProtocol(transport) + + return &TDeserializer{ + transport, + protocol} +} + +func (t *TDeserializer) ReadString(msg TStruct, s string) (err error) { + err = nil + if _, err = t.Transport.Write([]byte(s)); err != nil { + return + } + if err = msg.Read(t.Protocol); err != nil { + return + } + return +} + +func (t *TDeserializer) Read(msg TStruct, b []byte) (err error) { + err = nil + if _, err = t.Transport.Write(b); err != nil { + return + } + if err = msg.Read(t.Protocol); err != nil { + return + } + return +} diff --git a/lib/go/thrift/serializer.go b/lib/go/thrift/serializer.go new file mode 100644 index 00000000..bb6a2c8c --- /dev/null +++ b/lib/go/thrift/serializer.go @@ -0,0 +1,74 @@ +package thrift + +type TSerializer struct { + Transport TTransport + Protocol TProtocol +} + +type TStruct interface { + Write(p TProtocol) error + Read(p TProtocol) error +} + +func NewTSerializer() *TSerializer { + var transport TTransport + transport = NewTMemoryBufferLen(1024) + + protocol := NewTBinaryProtocolFactoryDefault().GetProtocol(transport) + + return &TSerializer{ + transport, + protocol} +} + +func (t *TSerializer) WriteString(msg TStruct) (s string, err error) { + s = "" + err = nil + + if err = msg.Write(t.Protocol); err != nil { + return + } + + if err = t.Protocol.Flush(); err != nil { + return + } + if err = t.Transport.Flush(); err != nil { + return + } + + var buf []byte + var place int + buf = make([]byte, 1024) + if place, err = t.Transport.Read(buf); err != nil { + return + } + + s = string(buf[:place]) + return +} + +func (t *TSerializer) Write(msg TStruct) (b []byte, err error) { + err = nil + + if err = msg.Write(t.Protocol); err != nil { + return + } + + if err = t.Protocol.Flush(); err != nil { + return + } + + if err = t.Transport.Flush(); err != nil { + return + } + + var buf []byte + var place int + buf = make([]byte, 1024) + if place, err = t.Transport.Read(buf); err != nil { + return + } + + b = buf[:place] + return +} diff --git a/lib/go/thrift/serializer_test.go b/lib/go/thrift/serializer_test.go new file mode 100644 index 00000000..840f6f7e --- /dev/null +++ b/lib/go/thrift/serializer_test.go @@ -0,0 +1,150 @@ +package thrift + +import ( + "errors" + "fmt" + "testing" +) + +type ProtocolFactory interface { + GetProtocol(t TTransport) TProtocol +} + +func compareStructs(m, m1 TestStruct) (bool, error) { + switch { + case m.On != m1.On: + return false, errors.New("Boolean not equal") + case m.B != m1.B: + return false, errors.New("Byte not equal") + case m.Int16 != m1.Int16: + return false, errors.New("Int16 not equal") + case m.Int32 != m1.Int32: + return false, errors.New("Int32 not equal") + case m.Int64 != m1.Int64: + return false, errors.New("Int64 not equal") + case m.D != m1.D: + return false, errors.New("Double not equal") + case m.St != m1.St: + return false, errors.New("String not equal") + + case len(m.Bin) != len(m1.Bin): + return false, errors.New("Binary size not equal") + case len(m.Bin) == len(m1.Bin): + for i := range m.Bin { + if m.Bin[i] != m1.Bin[i] { + return false, errors.New("Binary not equal") + } + } + case len(m.StringMap) != len(m1.StringMap): + return false, errors.New("StringMap size not equal") + case len(m.StringList) != len(m1.StringList): + return false, errors.New("StringList size not equal") + case len(m.StringSet) != len(m1.StringSet): + return false, errors.New("StringSet size not equal") + + case m.E != m1.E: + return false, errors.New("TestEnum not equal") + + default: + return true, nil + + } + return true, nil +} + +func ProtocolTest1(test *testing.T, pf ProtocolFactory) (bool, error) { + t := NewTSerializer() + t.Protocol = pf.GetProtocol(t.Transport) + var m = TestStruct{} + m.On = true + m.B = int8(0) + m.Int16 = 1 + m.Int32 = 2 + m.Int64 = 3 + m.D = 4.1 + m.St = "Test" + m.Bin = make([]byte, 10) + m.StringMap = make(map[string]string, 5) + m.StringList = make([]string, 5) + m.StringSet = make(map[string]bool, 5) + m.E = 2 + + s, err := t.WriteString(&m) + if err != nil { + return false, errors.New(fmt.Sprintf("Unable to Serialize struct\n\t %s", err)) + } + + t1 := NewTDeserializer() + t1.Protocol = pf.GetProtocol(t1.Transport) + var m1 = TestStruct{} + if err = t1.ReadString(&m1, s); err != nil { + return false, errors.New(fmt.Sprintf("Unable to Deserialize struct\n\t %s", err)) + + } + + return compareStructs(m, m1) + +} + +func ProtocolTest2(test *testing.T, pf ProtocolFactory) (bool, error) { + t := NewTSerializer() + t.Protocol = pf.GetProtocol(t.Transport) + var m = TestStruct{} + m.On = false + m.B = int8(0) + m.Int16 = 1 + m.Int32 = 2 + m.Int64 = 3 + m.D = 4.1 + m.St = "Test" + m.Bin = make([]byte, 10) + m.StringMap = make(map[string]string, 5) + m.StringList = make([]string, 5) + m.StringSet = make(map[string]bool, 5) + m.E = 2 + + s, err := t.WriteString(&m) + if err != nil { + return false, errors.New(fmt.Sprintf("Unable to Serialize struct\n\t %s", err)) + + } + + t1 := NewTDeserializer() + t1.Protocol = pf.GetProtocol(t1.Transport) + var m1 = TestStruct{} + if err = t1.ReadString(&m1, s); err != nil { + return false, errors.New(fmt.Sprintf("Unable to Deserialize struct\n\t %s", err)) + + } + + return compareStructs(m, m1) + +} + +func TestSerializer(t *testing.T) { + + var protocol_factories map[string]ProtocolFactory + protocol_factories = make(map[string]ProtocolFactory) + protocol_factories["Binary"] = NewTBinaryProtocolFactoryDefault() + protocol_factories["Compact"] = NewTCompactProtocolFactory() + protocol_factories["SimpleJSON"] = NewTSimpleJSONProtocolFactory() + protocol_factories["JSON"] = NewTJSONProtocolFactory() + + var tests map[string]func(*testing.T, ProtocolFactory) (bool, error) + tests = make(map[string]func(*testing.T, ProtocolFactory) (bool, error)) + tests["Test 1"] = ProtocolTest1 + tests["Test 2"] = ProtocolTest2 + //tests["Test 3"] = ProtocolTest3 // Example of how to add additional tests + + for name, pf := range protocol_factories { + + for test, f := range tests { + + if s, err := f(t, pf); !s || err != nil { + t.Errorf("%s Failed for %s protocol\n\t %s", test, name, err) + } + + } + } + +} diff --git a/lib/go/thrift/serializer_types.go b/lib/go/thrift/serializer_types.go new file mode 100644 index 00000000..2ce353b1 --- /dev/null +++ b/lib/go/thrift/serializer_types.go @@ -0,0 +1,578 @@ +package thrift + +// Autogenerated by Thrift Compiler (1.0.0-dev) +// DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + +/* THE FOLLOWING THRIFT FILE WAS USED TO CREATE THIS + +enum TestEnum { + FIRST = 1, + SECOND = 2, + THIRD = 3, + FOURTH = 4, +} + +struct TestStruct { + 1: bool on, + 2: byte b, + 3: i16 int16, + 4: i32 int32, + 5: i64 int64, + 6: double d, + 7: string st, + 8: binary bin, + 9: map stringMap, + 10: list stringList, + 11: set stringSet, + 12: TestEnum e, +} +*/ + +import ( + "fmt" + "math" +) + +// (needed to ensure safety because of naive import list constrution.) +var _ = math.MinInt32 +var _ = ZERO +var _ = fmt.Printf + +var GoUnusedProtection__ int + +type TestEnum int64 + +const ( + TestEnum_FIRST TestEnum = 1 + TestEnum_SECOND TestEnum = 2 + TestEnum_THIRD TestEnum = 3 + TestEnum_FOURTH TestEnum = 4 +) + +func (p TestEnum) String() string { + switch p { + case TestEnum_FIRST: + return "TestEnum_FIRST" + case TestEnum_SECOND: + return "TestEnum_SECOND" + case TestEnum_THIRD: + return "TestEnum_THIRD" + case TestEnum_FOURTH: + return "TestEnum_FOURTH" + } + return "" +} + +func TestEnumFromString(s string) (TestEnum, error) { + switch s { + case "TestEnum_FIRST": + return TestEnum_FIRST, nil + case "TestEnum_SECOND": + return TestEnum_SECOND, nil + case "TestEnum_THIRD": + return TestEnum_THIRD, nil + case "TestEnum_FOURTH": + return TestEnum_FOURTH, nil + } + return TestEnum(math.MinInt32 - 1), fmt.Errorf("not a valid TestEnum string") +} + +type TestStruct struct { + On bool `thrift:"on,1"` + B int8 `thrift:"b,2"` + Int16 int16 `thrift:"int16,3"` + Int32 int32 `thrift:"int32,4"` + Int64 int64 `thrift:"int64,5"` + D float64 `thrift:"d,6"` + St string `thrift:"st,7"` + Bin []byte `thrift:"bin,8"` + StringMap map[string]string `thrift:"stringMap,9"` + StringList []string `thrift:"stringList,10"` + StringSet map[string]bool `thrift:"stringSet,11"` + E TestEnum `thrift:"e,12"` +} + +func NewTestStruct() *TestStruct { + return &TestStruct{ + E: math.MinInt32 - 1, // unset sentinal value + } +} + +func (p *TestStruct) IsSetE() bool { + return int64(p.E) != math.MinInt32-1 +} + +func (p *TestStruct) Read(iprot TProtocol) error { + if _, err := iprot.ReadStructBegin(); err != nil { + return fmt.Errorf("%T read error %s", p, err) + } + for { + _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin() + if err != nil { + return fmt.Errorf("%T field %d read error: %s", p, fieldId, err) + } + if fieldTypeId == STOP { + break + } + switch fieldId { + case 1: + if err := p.readField1(iprot); err != nil { + return err + } + case 2: + if err := p.readField2(iprot); err != nil { + return err + } + case 3: + if err := p.readField3(iprot); err != nil { + return err + } + case 4: + if err := p.readField4(iprot); err != nil { + return err + } + case 5: + if err := p.readField5(iprot); err != nil { + return err + } + case 6: + if err := p.readField6(iprot); err != nil { + return err + } + case 7: + if err := p.readField7(iprot); err != nil { + return err + } + case 8: + if err := p.readField8(iprot); err != nil { + return err + } + case 9: + if err := p.readField9(iprot); err != nil { + return err + } + case 10: + if err := p.readField10(iprot); err != nil { + return err + } + case 11: + if err := p.readField11(iprot); err != nil { + return err + } + case 12: + if err := p.readField12(iprot); err != nil { + return err + } + default: + if err := iprot.Skip(fieldTypeId); err != nil { + return err + } + } + if err := iprot.ReadFieldEnd(); err != nil { + return err + } + } + if err := iprot.ReadStructEnd(); err != nil { + return fmt.Errorf("%T read struct end error: %s", p, err) + } + return nil +} + +func (p *TestStruct) readField1(iprot TProtocol) error { + if v, err := iprot.ReadBool(); err != nil { + return fmt.Errorf("error reading field 1: %s") + } else { + p.On = v + } + return nil +} + +func (p *TestStruct) readField2(iprot TProtocol) error { + if v, err := iprot.ReadByte(); err != nil { + return fmt.Errorf("error reading field 2: %s") + } else { + p.B = int8(v) + } + return nil +} + +func (p *TestStruct) readField3(iprot TProtocol) error { + if v, err := iprot.ReadI16(); err != nil { + return fmt.Errorf("error reading field 3: %s") + } else { + p.Int16 = v + } + return nil +} + +func (p *TestStruct) readField4(iprot TProtocol) error { + if v, err := iprot.ReadI32(); err != nil { + return fmt.Errorf("error reading field 4: %s") + } else { + p.Int32 = v + } + return nil +} + +func (p *TestStruct) readField5(iprot TProtocol) error { + if v, err := iprot.ReadI64(); err != nil { + return fmt.Errorf("error reading field 5: %s") + } else { + p.Int64 = v + } + return nil +} + +func (p *TestStruct) readField6(iprot TProtocol) error { + if v, err := iprot.ReadDouble(); err != nil { + return fmt.Errorf("error reading field 6: %s") + } else { + p.D = v + } + return nil +} + +func (p *TestStruct) readField7(iprot TProtocol) error { + if v, err := iprot.ReadString(); err != nil { + return fmt.Errorf("error reading field 7: %s") + } else { + p.St = v + } + return nil +} + +func (p *TestStruct) readField8(iprot TProtocol) error { + if v, err := iprot.ReadBinary(); err != nil { + return fmt.Errorf("error reading field 8: %s") + } else { + p.Bin = v + } + return nil +} + +func (p *TestStruct) readField9(iprot TProtocol) error { + _, _, size, err := iprot.ReadMapBegin() + if err != nil { + return fmt.Errorf("error reading map begin: %s") + } + p.StringMap = make(map[string]string, size) + for i := 0; i < size; i++ { + var _key0 string + if v, err := iprot.ReadString(); err != nil { + return fmt.Errorf("error reading field 0: %s") + } else { + _key0 = v + } + var _val1 string + if v, err := iprot.ReadString(); err != nil { + return fmt.Errorf("error reading field 0: %s") + } else { + _val1 = v + } + p.StringMap[_key0] = _val1 + } + if err := iprot.ReadMapEnd(); err != nil { + return fmt.Errorf("error reading map end: %s") + } + return nil +} + +func (p *TestStruct) readField10(iprot TProtocol) error { + _, size, err := iprot.ReadListBegin() + if err != nil { + return fmt.Errorf("error reading list being: %s") + } + p.StringList = make([]string, 0, size) + for i := 0; i < size; i++ { + var _elem2 string + if v, err := iprot.ReadString(); err != nil { + return fmt.Errorf("error reading field 0: %s") + } else { + _elem2 = v + } + p.StringList = append(p.StringList, _elem2) + } + if err := iprot.ReadListEnd(); err != nil { + return fmt.Errorf("error reading list end: %s") + } + return nil +} + +func (p *TestStruct) readField11(iprot TProtocol) error { + _, size, err := iprot.ReadSetBegin() + if err != nil { + return fmt.Errorf("error reading set being: %s") + } + p.StringSet = make(map[string]bool, size) + for i := 0; i < size; i++ { + var _elem3 string + if v, err := iprot.ReadString(); err != nil { + return fmt.Errorf("error reading field 0: %s") + } else { + _elem3 = v + } + p.StringSet[_elem3] = true + } + if err := iprot.ReadSetEnd(); err != nil { + return fmt.Errorf("error reading set end: %s") + } + return nil +} + +func (p *TestStruct) readField12(iprot TProtocol) error { + if v, err := iprot.ReadI32(); err != nil { + return fmt.Errorf("error reading field 12: %s") + } else { + p.E = TestEnum(v) + } + return nil +} + +func (p *TestStruct) Write(oprot TProtocol) error { + if err := oprot.WriteStructBegin("TestStruct"); err != nil { + return fmt.Errorf("%T write struct begin error: %s", p, err) + } + if err := p.writeField1(oprot); err != nil { + return err + } + if err := p.writeField2(oprot); err != nil { + return err + } + if err := p.writeField3(oprot); err != nil { + return err + } + if err := p.writeField4(oprot); err != nil { + return err + } + if err := p.writeField5(oprot); err != nil { + return err + } + if err := p.writeField6(oprot); err != nil { + return err + } + if err := p.writeField7(oprot); err != nil { + return err + } + if err := p.writeField8(oprot); err != nil { + return err + } + if err := p.writeField9(oprot); err != nil { + return err + } + if err := p.writeField10(oprot); err != nil { + return err + } + if err := p.writeField11(oprot); err != nil { + return err + } + if err := p.writeField12(oprot); err != nil { + return err + } + if err := oprot.WriteFieldStop(); err != nil { + return fmt.Errorf("%T write field stop error: %s", err) + } + if err := oprot.WriteStructEnd(); err != nil { + return fmt.Errorf("%T write struct stop error: %s", err) + } + return nil +} + +func (p *TestStruct) writeField1(oprot TProtocol) (err error) { + if err := oprot.WriteFieldBegin("on", BOOL, 1); err != nil { + return fmt.Errorf("%T write field begin error 1:on: %s", p, err) + } + if err := oprot.WriteBool(bool(p.On)); err != nil { + return fmt.Errorf("%T.on (1) field write error: %s", p) + } + if err := oprot.WriteFieldEnd(); err != nil { + return fmt.Errorf("%T write field end error 1:on: %s", p, err) + } + return err +} + +func (p *TestStruct) writeField2(oprot TProtocol) (err error) { + if err := oprot.WriteFieldBegin("b", BYTE, 2); err != nil { + return fmt.Errorf("%T write field begin error 2:b: %s", p, err) + } + if err := oprot.WriteByte(byte(p.B)); err != nil { + return fmt.Errorf("%T.b (2) field write error: %s", p) + } + if err := oprot.WriteFieldEnd(); err != nil { + return fmt.Errorf("%T write field end error 2:b: %s", p, err) + } + return err +} + +func (p *TestStruct) writeField3(oprot TProtocol) (err error) { + if err := oprot.WriteFieldBegin("int16", I16, 3); err != nil { + return fmt.Errorf("%T write field begin error 3:int16: %s", p, err) + } + if err := oprot.WriteI16(int16(p.Int16)); err != nil { + return fmt.Errorf("%T.int16 (3) field write error: %s", p) + } + if err := oprot.WriteFieldEnd(); err != nil { + return fmt.Errorf("%T write field end error 3:int16: %s", p, err) + } + return err +} + +func (p *TestStruct) writeField4(oprot TProtocol) (err error) { + if err := oprot.WriteFieldBegin("int32", I32, 4); err != nil { + return fmt.Errorf("%T write field begin error 4:int32: %s", p, err) + } + if err := oprot.WriteI32(int32(p.Int32)); err != nil { + return fmt.Errorf("%T.int32 (4) field write error: %s", p) + } + if err := oprot.WriteFieldEnd(); err != nil { + return fmt.Errorf("%T write field end error 4:int32: %s", p, err) + } + return err +} + +func (p *TestStruct) writeField5(oprot TProtocol) (err error) { + if err := oprot.WriteFieldBegin("int64", I64, 5); err != nil { + return fmt.Errorf("%T write field begin error 5:int64: %s", p, err) + } + if err := oprot.WriteI64(int64(p.Int64)); err != nil { + return fmt.Errorf("%T.int64 (5) field write error: %s", p) + } + if err := oprot.WriteFieldEnd(); err != nil { + return fmt.Errorf("%T write field end error 5:int64: %s", p, err) + } + return err +} + +func (p *TestStruct) writeField6(oprot TProtocol) (err error) { + if err := oprot.WriteFieldBegin("d", DOUBLE, 6); err != nil { + return fmt.Errorf("%T write field begin error 6:d: %s", p, err) + } + if err := oprot.WriteDouble(float64(p.D)); err != nil { + return fmt.Errorf("%T.d (6) field write error: %s", p) + } + if err := oprot.WriteFieldEnd(); err != nil { + return fmt.Errorf("%T write field end error 6:d: %s", p, err) + } + return err +} + +func (p *TestStruct) writeField7(oprot TProtocol) (err error) { + if err := oprot.WriteFieldBegin("st", STRING, 7); err != nil { + return fmt.Errorf("%T write field begin error 7:st: %s", p, err) + } + if err := oprot.WriteString(string(p.St)); err != nil { + return fmt.Errorf("%T.st (7) field write error: %s", p) + } + if err := oprot.WriteFieldEnd(); err != nil { + return fmt.Errorf("%T write field end error 7:st: %s", p, err) + } + return err +} + +func (p *TestStruct) writeField8(oprot TProtocol) (err error) { + if p.Bin != nil { + if err := oprot.WriteFieldBegin("bin", BINARY, 8); err != nil { + return fmt.Errorf("%T write field begin error 8:bin: %s", p, err) + } + if err := oprot.WriteBinary(p.Bin); err != nil { + return fmt.Errorf("%T.bin (8) field write error: %s", p) + } + if err := oprot.WriteFieldEnd(); err != nil { + return fmt.Errorf("%T write field end error 8:bin: %s", p, err) + } + } + return err +} + +func (p *TestStruct) writeField9(oprot TProtocol) (err error) { + if p.StringMap != nil { + if err := oprot.WriteFieldBegin("stringMap", MAP, 9); err != nil { + return fmt.Errorf("%T write field begin error 9:stringMap: %s", p, err) + } + if err := oprot.WriteMapBegin(STRING, STRING, len(p.StringMap)); err != nil { + return fmt.Errorf("error writing map begin: %s") + } + for k, v := range p.StringMap { + if err := oprot.WriteString(string(k)); err != nil { + return fmt.Errorf("%T. (0) field write error: %s", p) + } + if err := oprot.WriteString(string(v)); err != nil { + return fmt.Errorf("%T. (0) field write error: %s", p) + } + } + if err := oprot.WriteMapEnd(); err != nil { + return fmt.Errorf("error writing map end: %s") + } + if err := oprot.WriteFieldEnd(); err != nil { + return fmt.Errorf("%T write field end error 9:stringMap: %s", p, err) + } + } + return err +} + +func (p *TestStruct) writeField10(oprot TProtocol) (err error) { + if p.StringList != nil { + if err := oprot.WriteFieldBegin("stringList", LIST, 10); err != nil { + return fmt.Errorf("%T write field begin error 10:stringList: %s", p, err) + } + if err := oprot.WriteListBegin(STRING, len(p.StringList)); err != nil { + return fmt.Errorf("error writing list begin: %s") + } + for _, v := range p.StringList { + if err := oprot.WriteString(string(v)); err != nil { + return fmt.Errorf("%T. (0) field write error: %s", p) + } + } + if err := oprot.WriteListEnd(); err != nil { + return fmt.Errorf("error writing list end: %s") + } + if err := oprot.WriteFieldEnd(); err != nil { + return fmt.Errorf("%T write field end error 10:stringList: %s", p, err) + } + } + return err +} + +func (p *TestStruct) writeField11(oprot TProtocol) (err error) { + if p.StringSet != nil { + if err := oprot.WriteFieldBegin("stringSet", SET, 11); err != nil { + return fmt.Errorf("%T write field begin error 11:stringSet: %s", p, err) + } + if err := oprot.WriteSetBegin(STRING, len(p.StringSet)); err != nil { + return fmt.Errorf("error writing set begin: %s") + } + for v, _ := range p.StringSet { + if err := oprot.WriteString(string(v)); err != nil { + return fmt.Errorf("%T. (0) field write error: %s", p) + } + } + if err := oprot.WriteSetEnd(); err != nil { + return fmt.Errorf("error writing set end: %s") + } + if err := oprot.WriteFieldEnd(); err != nil { + return fmt.Errorf("%T write field end error 11:stringSet: %s", p, err) + } + } + return err +} + +func (p *TestStruct) writeField12(oprot TProtocol) (err error) { + if p.IsSetE() { + if err := oprot.WriteFieldBegin("e", I32, 12); err != nil { + return fmt.Errorf("%T write field begin error 12:e: %s", p, err) + } + if err := oprot.WriteI32(int32(p.E)); err != nil { + return fmt.Errorf("%T.e (12) field write error: %s", p) + } + if err := oprot.WriteFieldEnd(); err != nil { + return fmt.Errorf("%T write field end error 12:e: %s", p, err) + } + } + return err +} + +func (p *TestStruct) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("TestStruct(%+v)", *p) +} -- 2.17.1