You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@thrift.apache.org by je...@apache.org on 2013/09/08 00:42:46 UTC
git commit: THRIFT-2159 Serializer/Deserializer for Go
Updated Branches:
refs/heads/master c949514e4 -> 7a0948399
THRIFT-2159 Serializer/Deserializer for Go
Patch: Justin Judd
Project: http://git-wip-us.apache.org/repos/asf/thrift/repo
Commit: http://git-wip-us.apache.org/repos/asf/thrift/commit/7a094839
Tree: http://git-wip-us.apache.org/repos/asf/thrift/tree/7a094839
Diff: http://git-wip-us.apache.org/repos/asf/thrift/diff/7a094839
Branch: refs/heads/master
Commit: 7a09483993be2b42b60224829534d5c976e5f9e2
Parents: c949514
Author: Jens Geyer <je...@apache.org>
Authored: Sun Sep 8 00:36:22 2013 +0200
Committer: Jens Geyer <je...@apache.org>
Committed: Sun Sep 8 00:36:22 2013 +0200
----------------------------------------------------------------------
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(+)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/thrift/blob/7a094839/lib/go/thrift/deserializer.go
----------------------------------------------------------------------
diff --git a/lib/go/thrift/deserializer.go b/lib/go/thrift/deserializer.go
new file mode 100644
index 0000000..e7effb1
--- /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
+}
http://git-wip-us.apache.org/repos/asf/thrift/blob/7a094839/lib/go/thrift/serializer.go
----------------------------------------------------------------------
diff --git a/lib/go/thrift/serializer.go b/lib/go/thrift/serializer.go
new file mode 100644
index 0000000..bb6a2c8
--- /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
+}
http://git-wip-us.apache.org/repos/asf/thrift/blob/7a094839/lib/go/thrift/serializer_test.go
----------------------------------------------------------------------
diff --git a/lib/go/thrift/serializer_test.go b/lib/go/thrift/serializer_test.go
new file mode 100644
index 0000000..840f6f7
--- /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)
+ }
+
+ }
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/thrift/blob/7a094839/lib/go/thrift/serializer_types.go
----------------------------------------------------------------------
diff --git a/lib/go/thrift/serializer_types.go b/lib/go/thrift/serializer_types.go
new file mode 100644
index 0000000..2ce353b
--- /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<string, string> stringMap,
+ 10: list<string> stringList,
+ 11: set<string> 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 "<UNSET>"
+}
+
+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 "<nil>"
+ }
+ return fmt.Sprintf("TestStruct(%+v)", *p)
+}