From 1ce2e1f5d226560135b1cd3aa3fc262577c934c4 Mon Sep 17 00:00:00 2001 From: Kehan Yin <838278270@qq.com> Date: Mon, 17 Jun 2024 12:02:20 +0800 Subject: [PATCH] fix(j2p): support sint/fixed/sfixed types convertion and generic call (#57) * test: add test data for pb * fix: fix convert error with sint,fix32,fix64 * test: test proto generic example * feat(proto): support streaming mode for proto (#56) feat: support streaming mode for proto * fix: fix unsafe convert * style: delete unused code * test: delete service code in proto * test: update test data * fix: encodeMapKey * test: test sint/fix types map --------- Co-authored-by: Marina Sakai <118230951+Marina-Sakai@users.noreply.github.com> --- conv/j2p/conv_test.go | 253 +- conv/j2p/decode.go | 96 +- conv/p2j/conv_test.go | 238 +- conv/p2j/impl.go | 9 +- proto/binary/binary.go | 65 +- proto/generic/example_test.go | 53 +- proto/generic/path_test.go | 8 +- proto/generic/value_test.go | 168 +- testdata/data/basic_example.json | 1 + testdata/data/basic_example_pb.bin | Bin 0 -> 1246 bytes testdata/data/example2_pb.bin | 34 +- testdata/data/example2req.json | 2 +- testdata/data/example3_pb.bin | 22 +- testdata/idl/basic_example.proto | 61 + testdata/idl/example2.proto | 4 +- testdata/idl/example3.proto | 164 + testdata/kitex_gen/pb/base/base.pb.go | 144 +- .../pb/base/basic_example.pb.fast.go | 2420 ++++++++++++ .../kitex_gen/pb/base/basic_example.pb.go | 827 ++++ .../baselineservice/baselineservice.go | 868 ----- .../pb/baseline/baselineservice/client.go | 73 - .../pb/baseline/baselineservice/invoker.go | 24 - .../pb/baseline/baselineservice/server.go | 20 - .../pb/example/testservice/client.go | 85 - .../pb/example/testservice/invoker.go | 24 - .../pb/example/testservice/server.go | 20 - .../pb/example/testservice/testservice.go | 1196 ------ .../kitex_gen/pb/example2/example2.pb.fast.go | 34 +- testdata/kitex_gen/pb/example2/example2.pb.go | 692 ++-- .../pb/example2/testservice2/client.go | 97 - .../pb/example2/testservice2/invoker.go | 24 - .../pb/example2/testservice2/server.go | 20 - .../pb/example2/testservice2/testservice2.go | 1524 -------- .../kitex_gen/pb/example3/example3.pb.fast.go | 3359 +++++++++++++++++ testdata/kitex_gen/pb/example3/example3.pb.go | 1925 ++++++++++ 35 files changed, 9962 insertions(+), 4592 deletions(-) create mode 100644 testdata/data/basic_example.json create mode 100644 testdata/data/basic_example_pb.bin create mode 100644 testdata/idl/basic_example.proto create mode 100644 testdata/idl/example3.proto create mode 100644 testdata/kitex_gen/pb/base/basic_example.pb.fast.go create mode 100644 testdata/kitex_gen/pb/base/basic_example.pb.go delete mode 100644 testdata/kitex_gen/pb/baseline/baselineservice/baselineservice.go delete mode 100644 testdata/kitex_gen/pb/baseline/baselineservice/client.go delete mode 100644 testdata/kitex_gen/pb/baseline/baselineservice/invoker.go delete mode 100644 testdata/kitex_gen/pb/baseline/baselineservice/server.go delete mode 100644 testdata/kitex_gen/pb/example/testservice/client.go delete mode 100644 testdata/kitex_gen/pb/example/testservice/invoker.go delete mode 100644 testdata/kitex_gen/pb/example/testservice/server.go delete mode 100644 testdata/kitex_gen/pb/example/testservice/testservice.go delete mode 100644 testdata/kitex_gen/pb/example2/testservice2/client.go delete mode 100644 testdata/kitex_gen/pb/example2/testservice2/invoker.go delete mode 100644 testdata/kitex_gen/pb/example2/testservice2/server.go delete mode 100644 testdata/kitex_gen/pb/example2/testservice2/testservice2.go create mode 100644 testdata/kitex_gen/pb/example3/example3.pb.fast.go create mode 100644 testdata/kitex_gen/pb/example3/example3.pb.go diff --git a/conv/j2p/conv_test.go b/conv/j2p/conv_test.go index 52f6b667..bf38e826 100644 --- a/conv/j2p/conv_test.go +++ b/conv/j2p/conv_test.go @@ -43,11 +43,21 @@ func TestMain(m *testing.M) { } const ( - exampleIDLPath = "testdata/idl/example2.proto" - exampleJSON = "testdata/data/example2req.json" - exampleProtoPath = "testdata/data/example2_pb.bin" + exampleIDLPath = "testdata/idl/example2.proto" + exampleJSON = "testdata/data/example2req.json" + exampleProtoPath = "testdata/data/example2_pb.bin" // not used + basicExampleJSON = "testdata/data/basic_example.json" + basicExampleIDLPath = "testdata/idl/basic_example.proto" ) +func TestBuildExampleJSONData(t *testing.T) { + buildExampleJSONData() +} + +func TestBuildBasicExampleJSONData(t *testing.T) { + buildBasicExampleJSONData() +} + func TestConvJSON2Protobf(t *testing.T) { // buildExampleJSONData() desc := getExampleDesc() @@ -85,6 +95,71 @@ func TestConvJSON2Protobf(t *testing.T) { require.Equal(t, exp, act) } +func TestConvJSON2Protobf_BasicExample(t *testing.T) { + // buildExampleJSONData() + desc := getBasicExampleDesc() + data := getBasicExampleData() + // pdata, _ := ioutil.ReadFile(util_test.MustGitPath(exampleProtoPath)) + // fmt.Println(pdata) + cv := NewBinaryConv(conv.Options{}) + ctx := context.Background() + // get protobuf-encode bytes + out, err := cv.Do(ctx, desc, data) + require.Nil(t, err) + exp := &base.BasicExample{} + // unmarshal target struct + err = json.Unmarshal(data, exp) + require.Nil(t, err) + act := &base.BasicExample{} + l := 0 + // fmt.Print(out) + dataLen := len(out) + // fastRead to get target struct + for l < dataLen { + id, wtyp, tagLen := goprotowire.ConsumeTag(out) + fmt.Println("id", id) + fmt.Println("w", wtyp) + if tagLen < 0 { + t.Fatal("test failed") + } + l += tagLen + out = out[tagLen:] + offset, err := act.FastRead(out, int8(wtyp), int32(id)) + require.Nil(t, err) + out = out[offset:] + l += offset + } + require.Nil(t, err) + // compare exp and act struct + fmt.Println(exp) + fmt.Println("----------------") + fmt.Println(act) + require.Equal(t, exp, act) +} + +func getBasicExampleDesc() *proto.TypeDescriptor { + opts := proto.Options{} + includeDirs := util_test.MustGitPath("testdata/idl/") // includeDirs is used to find the include files. + svc, err := opts.NewDescriptorFromPath(context.Background(), util_test.MustGitPath(basicExampleIDLPath), includeDirs) + if err != nil { + panic(err) + } + res := (*svc).LookupMethodByName("ExampleMethod").Input() + + if res == nil { + panic("can't find Target MessageDescriptor") + } + return res +} + +func getBasicExampleData() []byte { + out, err := ioutil.ReadFile(util_test.MustGitPath(basicExampleJSON)) + if err != nil { + panic(err) + } + return out +} + func getExampleDesc() *proto.TypeDescriptor { opts := proto.Options{} includeDirs := util_test.MustGitPath("testdata/idl/") // includeDirs is used to find the include files. @@ -116,11 +191,13 @@ func getExample2Req() *example2.ExampleReq { req.InnerBase2.Bool = true req.InnerBase2.Uint32 = uint32(123) req.InnerBase2.Uint64 = uint64(123) + req.InnerBase2.Int32 = int32(123) + req.InnerBase2.SInt64 = int64(123) req.InnerBase2.Double = float64(22.3) req.InnerBase2.String_ = "hello_inner" req.InnerBase2.ListInt32 = []int32{12, 13, 14, 15, 16, 17} req.InnerBase2.MapStringString = map[string]string{"m1": "aaa", "m2": "bbb"} - req.InnerBase2.SetInt32 = []int32{200, 201, 202, 203, 204, 205} + req.InnerBase2.ListSInt64 = []int64{200, 201, 202, 203, 204, 205} req.InnerBase2.Foo = example2.FOO_FOO_A req.InnerBase2.MapInt32String = map[int32]string{1: "aaa", 2: "bbb", 3: "ccc", 4: "ddd"} req.InnerBase2.Binary = []byte{0x1, 0x2, 0x3, 0x4} @@ -203,6 +280,140 @@ func getExample2Req() *example2.ExampleReq { return req } +func getBasicExampleReq() *base.BasicExample { + req := new(base.BasicExample) + req = &base.BasicExample{ + Int32: 123, + Int64: 123, + Uint32: uint32(math.MaxInt32), + Uint64: uint64(math.MaxInt64), + Sint32: 123, + Sint64: 123, + Sfixed32: 123, + Sfixed64: 123, + Fixed32: 123, + Fixed64: 123, + Float: 123.123, + Double: 123.123, + Bool: true, + Str: "hello world!", + Bytes: []byte{0x1, 0x2, 0x3, 0x4}, + ListInt32: []int32{100, 200, 300, 400, 500}, + ListInt64: []int64{100, 200, 300, 400, 500}, + ListUint32: []uint32{100, 200, 300, 400, 500}, + ListUint64: []uint64{100, 200, 300, 400, 500}, + ListSint32: []int32{100, 200, 300, 400, 500}, + ListSint64: []int64{100, 200, 300, 400, 500}, + ListSfixed32: []int32{100, 200, 300, 400, 500}, + ListSfixed64: []int64{100, 200, 300, 400, 500}, + ListFixed32: []uint32{100, 200, 300, 400, 500}, + ListFixed64: []uint64{100, 200, 300, 400, 500}, + ListFloat: []float32{1.1, 2.2, 3.3, 4.4, 5.5}, + ListDouble: []float64{1.1, 2.2, 3.3, 4.4, 5.5}, + ListBool: []bool{true, false, true, false, true}, + ListString: []string{"a1", "b2", "c3", "d4", "e5"}, + ListBytes: [][]byte{{0x1, 0x2, 0x3, 0x4}, {0x5, 0x6, 0x7, 0x8}}, + MapInt64SINT32: map[int64]int32{ + 0: 0, + math.MaxInt64: math.MaxInt32, + math.MinInt64: math.MinInt32, + }, + MapInt64Sfixed32: map[int64]int32{ + 0: 0, + math.MaxInt64: math.MaxInt32, + math.MinInt64: math.MinInt32, + }, + MapInt64Fixed32: map[int64]uint32{ + math.MaxInt64: uint32(math.MaxInt32), + math.MinInt64: 0, + }, + MapInt64Uint32: map[int64]uint32{ + 0: 0, + math.MaxInt64: uint32(math.MaxInt32), + math.MinInt64: 0, + }, + MapInt64Double: map[int64]float64{ + 0: 0, + math.MaxInt64: math.MaxFloat64, + math.MinInt64: math.SmallestNonzeroFloat64, + }, + MapInt64Bool: map[int64]bool{ + 0: false, + math.MaxInt64: true, + math.MinInt64: false, + }, + MapInt64String: map[int64]string{ + 0: "0", + math.MaxInt64: "max", + math.MinInt64: "min", + }, + MapInt64Bytes: map[int64][]byte{ + 0: {0x0}, + math.MaxInt64: {0x1, 0x2, 0x3, 0x4}, + math.MinInt64: {0x5, 0x6, 0x7, 0x8}, + }, + MapInt64Float: map[int64]float32{ + 0: 0, + math.MaxInt64: math.MaxFloat32, + math.MinInt64: math.SmallestNonzeroFloat32, + }, + MapInt64Int32: map[int64]int32{ + 0: 0, + math.MaxInt64: math.MaxInt32, + math.MinInt64: math.MinInt32, + }, + MapstringSINT64: map[string]int64{ + "0": 0, + "max": math.MaxInt64, + "min": math.MinInt64, + }, + MapstringSfixed64: map[string]int64{ + "0": 0, + "max": math.MaxInt64, + "min": math.MinInt64, + }, + MapstringFixed64: map[string]uint64{ + "max": uint64(math.MaxInt64), + "min": 0, + }, + MapstringUint64: map[string]uint64{ + "max": uint64(math.MaxInt64), + "min": 0, + }, + MapstringDouble: map[string]float64{ + "0": 0, + "max": math.MaxFloat64, + "min": math.SmallestNonzeroFloat64, + }, + MapstringBool: map[string]bool{ + "0": false, + "max": true, + }, + MapstringString: map[string]string{ + "0": "0", + "max": "max", + "min": "min", + }, + MapstringBytes: map[string][]byte{ + "0": {0x0}, + "max": {0x1, 0x2, 0x3, 0x4}, + "min": {0x5, 0x6, 0x7, 0x8}, + }, + MapstringFloat: map[string]float32{ + "0": 0, + "max": math.MaxFloat32, + "min": math.SmallestNonzeroFloat32, + }, + MapstringInt64: map[string]int64{ + "0": 0, + "max": math.MaxInt64, + "min": math.MinInt64, + }, + } + + return req +} + func buildExampleJSONData() error { req := getExample2Req() data, err := json.Marshal(req) @@ -237,6 +448,40 @@ func buildExampleJSONData() error { return nil } +func buildBasicExampleJSONData() error { + req := getBasicExampleReq() + data, err := json.Marshal(req) + if err != nil { + panic(fmt.Sprintf("buildExampleJSONData failed, err: %v", err.Error())) + } + checkExist := func(path string) bool { + _, err := os.Stat(path) + if err != nil { + if os.IsExist(err) { + return true + } + return false + } + return true + } + var file *os.File + absoluteExampleJSONPath := util_test.MustGitPath(basicExampleJSON) + if checkExist(absoluteExampleJSONPath) == true { + if err = os.Remove(absoluteExampleJSONPath); err != nil { + panic("delete protoJSONFile failed") + } + } + file, err = os.Create(absoluteExampleJSONPath) + if err != nil { + panic("create protoJSONFile failed") + } + defer file.Close() + if _, err := file.WriteString(string(data)); err != nil { + panic("write protoJSONData failed") + } + return nil +} + func getExampleInt2Float() *proto.TypeDescriptor { includeDirs := util_test.MustGitPath("testdata/idl/") // includeDirs is used to find the include files. svc, err := proto.NewDescritorFromPath(context.Background(), util_test.MustGitPath(exampleIDLPath), includeDirs) diff --git a/conv/j2p/decode.go b/conv/j2p/decode.go index 1fa375ee..ffe7e442 100644 --- a/conv/j2p/decode.go +++ b/conv/j2p/decode.go @@ -5,7 +5,6 @@ import ( "fmt" "strconv" "sync" - "unsafe" "github.com/bytedance/sonic/ast" "github.com/cloudwego/dynamicgo/conv" @@ -185,18 +184,30 @@ func (self *visitorUserNode) OnBool(v bool) error { self.inskip = false return nil } + var err error - if self.globalFieldDesc == nil { - return newError(meta.ErrConvert, "self.globalFieldDescriptor is nil, type Onbool", nil) + top := self.stk[self.sp] + fieldDesc := self.globalFieldDesc + // case PackedList(List bool), get fieldDescriptor from Stack + if self.globalFieldDesc == nil && top.typ == arrStkType { + fieldDesc = top.state.fieldDesc } - // TODO - if err = self.p.AppendTagByKind(self.globalFieldDesc.Number(), self.globalFieldDesc.Kind()); err != nil { - return err + + // packed list no need to write tag + if !fieldDesc.Type().IsList() { + if err = self.p.AppendTagByKind(fieldDesc.Number(), fieldDesc.Kind()); err != nil { + return err + } } + if err = self.p.WriteBool(v); err != nil { return err } - return self.onValueEnd() + // globalFieldDesc must belong to MessageDescriptor + if self.globalFieldDesc != nil { + err = self.onValueEnd() + } + return err } // Parse stringType/bytesType @@ -260,19 +271,33 @@ func (self *visitorUserNode) OnInt64(v int64, n json.Number) error { } switch fieldDesc.Kind() { - case proto.Int32Kind, proto.Sint32Kind, proto.Sfixed32Kind, proto.Fixed32Kind: - convertData := *(*int32)(unsafe.Pointer(&v)) - + case proto.Int32Kind: + convertData := int32(v) if err = self.p.WriteInt32(convertData); err != nil { return err } + case proto.Sint32Kind: + convertData := int32(v) + if err = self.p.WriteSint32(convertData); err != nil { + return err + } + case proto.Sfixed32Kind: + convertData := int32(v) + if err = self.p.WriteSfixed32(convertData); err != nil { + return err + } + case proto.Fixed32Kind: + convertData := uint32(v) + if err = self.p.WriteFixed32(convertData); err != nil { + return err + } case proto.Uint32Kind: - convertData := *(*uint32)(unsafe.Pointer(&v)) + convertData := uint32(v) if err = self.p.WriteUint32(convertData); err != nil { return err } case proto.Uint64Kind: - convertData := *(*uint64)(unsafe.Pointer(&v)) + convertData := uint64(v) if err = self.p.WriteUint64(convertData); err != nil { return err } @@ -280,12 +305,28 @@ func (self *visitorUserNode) OnInt64(v int64, n json.Number) error { if err = self.p.WriteInt64(v); err != nil { return err } + case proto.Sint64Kind: + if err = self.p.WriteSint64(v); err != nil { + return err + } + case proto.Sfixed64Kind: + if err = self.p.WriteSfixed64(v); err != nil { + return err + } + case proto.Fixed64Kind: + convertData := uint64(v) + if err = self.p.WriteFixed64(convertData); err != nil { + return err + } + // cast int2float, int2double case proto.FloatKind: - if err = self.p.WriteFloat(float32(v)); err != nil { + convertData := float32(v) + if err = self.p.WriteFloat(convertData); err != nil { return err } case proto.DoubleKind: - if err = self.p.WriteDouble(float64(v)); err != nil { + convertData := float64(v) + if err = self.p.WriteDouble(convertData); err != nil { return err } @@ -311,36 +352,33 @@ func (self *visitorUserNode) OnFloat64(v float64, n json.Number) error { if self.globalFieldDesc == nil && top.typ == arrStkType { fieldDesc = top.state.fieldDesc } - switch fieldDesc.Kind() { - case proto.FloatKind: - convertData := *(*float32)(unsafe.Pointer(&v)) + + // packed list no need to write tag + if !fieldDesc.Type().IsList() { if err = self.p.AppendTagByKind(fieldDesc.Number(), fieldDesc.Kind()); err != nil { return err } + } + + switch fieldDesc.Kind() { + case proto.FloatKind: + convertData := float32(v) if err = self.p.WriteFloat(convertData); err != nil { return err } case proto.DoubleKind: - convertData := *(*float64)(unsafe.Pointer(&v)) - if err = self.p.AppendTagByKind(fieldDesc.Number(), fieldDesc.Kind()); err != nil { - return err - } + convertData := v if err = self.p.WriteDouble(convertData); err != nil { return err } + // cast double2int32, double2int64 case proto.Int32Kind: convertData := int32(v) - if err = self.p.AppendTagByKind(fieldDesc.Number(), fieldDesc.Kind()); err != nil { - return err - } if err = self.p.WriteInt32(convertData); err != nil { return err } case proto.Int64Kind: convertData := int64(v) - if err = self.p.AppendTagByKind(fieldDesc.Number(), fieldDesc.Kind()); err != nil { - return err - } if err = self.p.WriteInt64(convertData); err != nil { return err } @@ -395,7 +433,7 @@ func (self *visitorUserNode) OnObjectBegin(capacity int) error { // MapKey maybe int32/sint32/uint32/uint64 etc.... func (self *visitorUserNode) encodeMapKey(key string, t proto.Type) error { switch t { - case proto.INT32, proto.SINT32, proto.SFIX32, proto.FIX32: + case proto.INT32: t, _ := strconv.ParseInt(key, 10, 32) if err := self.p.WriteInt32(int32(t)); err != nil { return err @@ -476,7 +514,7 @@ func (self *visitorUserNode) OnObjectKey(key string) error { // case MapKey, write PairTag、PairLen、MapKeyTag、MapKeyLen、MapKeyData, push MapDesc into stack // encode PairTag、PairLen - fd := top.state.fieldDesc; + fd := top.state.fieldDesc if err := self.p.AppendTag(fd.Number(), proto.BytesType); err != nil { return newError(meta.ErrWrite, fmt.Sprintf("field '%s' encode pair tag faield", fd.Name()), err) } diff --git a/conv/p2j/conv_test.go b/conv/p2j/conv_test.go index 3cd41160..438662b8 100644 --- a/conv/p2j/conv_test.go +++ b/conv/p2j/conv_test.go @@ -44,9 +44,12 @@ func TestMain(m *testing.M) { } const ( - exampleIDLPath = "testdata/idl/example2.proto" - exampleProtoPath = "testdata/data/example3_pb.bin" - exampleJSONPath = "testdata/data/example3req.json" + exampleIDLPath = "testdata/idl/example2.proto" + exampleProtoPath = "testdata/data/example3_pb.bin" + exampleJSONPath = "testdata/data/example3req.json" + basicExampleIDLPath = "testdata/idl/basic_example.proto" + basicExampleJSONPath = "testdata/data/basic_example.json" + basicExampleProtoPath = "testdata/data/basic_example_pb.bin" ) func TestBuildData(t *testing.T) { @@ -55,7 +58,13 @@ func TestBuildData(t *testing.T) { } } -func TestConvProto3JSON(t *testing.T) { +func TestBuildBasicExampleData(t *testing.T) { + if err := saveBasicExampleReqProtoBufData(); err != nil { + panic("build basicExampleProtoData failed") + } +} + +func TestConvProto2JSON(t *testing.T) { includeDirs := util_test.MustGitPath("testdata/idl/") // includeDirs is used to find the include files. messageDesc := proto.FnRequest(proto.GetFnDescFromFile(exampleIDLPath, "ExampleMethod", proto.Options{}, includeDirs)) //js := getExample2JSON() @@ -90,6 +99,44 @@ func TestConvProto3JSON(t *testing.T) { assert.Equal(t, exp, act) } +func TestConvProto2JSON_BasicExample(t *testing.T) { + includeDirs := util_test.MustGitPath("testdata/idl/") // includeDirs is used to find the include files. + messageDesc := proto.FnRequest(proto.GetFnDescFromFile(basicExampleIDLPath, "ExampleMethod", proto.Options{}, includeDirs)) + + cv := NewBinaryConv(conv.Options{}) + in := readBasicExampleReqProtoBufData() + out, err := cv.Do(context.Background(), messageDesc, in) + if err != nil { + t.Fatal(err) + } + exp := base.BasicExample{} + // use kitex_util to check proto data validity + l := 0 + dataLen := len(in) + for l < dataLen { + id, wtyp, tagLen := goprotowire.ConsumeTag(in) + if tagLen < 0 { + t.Fatal("proto data error format") + } + l += tagLen + in = in[tagLen:] + offset, err := exp.FastRead(in, int8(wtyp), int32(id)) + require.Nil(t, err) + in = in[offset:] + l += offset + } + if len(in) != 0 { + t.Fatal("proto data error format") + } + // check json data validity, convert it into act struct + var act base.BasicExample + require.Nil(t, json.Unmarshal([]byte(out), &act)) + fmt.Println(exp) + fmt.Println("-------------") + fmt.Println(act) + assert.Equal(t, exp, act) +} + // construct ExampleReq Object func constructExampleReqObject() *example2.ExampleReq { req := example2.ExampleReq{} @@ -99,11 +146,13 @@ func constructExampleReqObject() *example2.ExampleReq { req.InnerBase2.Bool = true req.InnerBase2.Uint32 = uint32(123) req.InnerBase2.Uint64 = uint64(123) + req.InnerBase2.Int32 = int32(123) + req.InnerBase2.SInt64 = int64(123) req.InnerBase2.Double = float64(22.3) req.InnerBase2.String_ = "hello_inner" req.InnerBase2.ListInt32 = []int32{12, 13, 14, 15, 16, 17} req.InnerBase2.MapStringString = map[string]string{"m1": "aaa", "m2": "bbb", "m3": "ccc", "m4": "ddd"} - req.InnerBase2.SetInt32 = []int32{200, 201, 202, 203, 204, 205} + req.InnerBase2.ListSInt64 = []int64{200, 201, 202, 203, 204, 205} req.InnerBase2.Foo = example2.FOO_FOO_A req.InnerBase2.MapInt32String = map[int32]string{1: "aaa", 2: "bbb", 3: "ccc", 4: "ddd"} req.InnerBase2.Binary = []byte{0x1, 0x2, 0x3, 0x4} @@ -186,10 +235,144 @@ func constructExampleReqObject() *example2.ExampleReq { return &req } +func constructBasicExampleReqObject() *base.BasicExample { + req := new(base.BasicExample) + req = &base.BasicExample{ + Int32: 123, + Int64: 123, + Uint32: uint32(math.MaxInt32), + Uint64: uint64(math.MaxInt64), + Sint32: 123, + Sint64: 123, + Sfixed32: 123, + Sfixed64: 123, + Fixed32: 123, + Fixed64: 123, + Float: 123.123, + Double: 123.123, + Bool: true, + Str: "hello world!", + Bytes: []byte{0x1, 0x2, 0x3, 0x4}, + ListInt32: []int32{100, 200, 300, 400, 500}, + ListInt64: []int64{100, 200, 300, 400, 500}, + ListUint32: []uint32{100, 200, 300, 400, 500}, + ListUint64: []uint64{100, 200, 300, 400, 500}, + ListSint32: []int32{100, 200, 300, 400, 500}, + ListSint64: []int64{100, 200, 300, 400, 500}, + ListSfixed32: []int32{100, 200, 300, 400, 500}, + ListSfixed64: []int64{100, 200, 300, 400, 500}, + ListFixed32: []uint32{100, 200, 300, 400, 500}, + ListFixed64: []uint64{100, 200, 300, 400, 500}, + ListFloat: []float32{1.1, 2.2, 3.3, 4.4, 5.5}, + ListDouble: []float64{1.1, 2.2, 3.3, 4.4, 5.5}, + ListBool: []bool{true, false, true, false, true}, + ListString: []string{"a1", "b2", "c3", "d4", "e5"}, + ListBytes: [][]byte{{0x1, 0x2, 0x3, 0x4}, {0x5, 0x6, 0x7, 0x8}}, + MapInt64SINT32: map[int64]int32{ + 0: 0, + math.MaxInt64: math.MaxInt32, + math.MinInt64: math.MinInt32, + }, + MapInt64Sfixed32: map[int64]int32{ + 0: 0, + math.MaxInt64: math.MaxInt32, + math.MinInt64: math.MinInt32, + }, + MapInt64Fixed32: map[int64]uint32{ + math.MaxInt64: uint32(math.MaxInt32), + math.MinInt64: 0, + }, + MapInt64Uint32: map[int64]uint32{ + 0: 0, + math.MaxInt64: uint32(math.MaxInt32), + math.MinInt64: 0, + }, + MapInt64Double: map[int64]float64{ + 0: 0, + math.MaxInt64: math.MaxFloat64, + math.MinInt64: math.SmallestNonzeroFloat64, + }, + MapInt64Bool: map[int64]bool{ + 0: false, + math.MaxInt64: true, + math.MinInt64: false, + }, + MapInt64String: map[int64]string{ + 0: "0", + math.MaxInt64: "max", + math.MinInt64: "min", + }, + MapInt64Bytes: map[int64][]byte{ + 0: {0x0}, + math.MaxInt64: {0x1, 0x2, 0x3, 0x4}, + math.MinInt64: {0x5, 0x6, 0x7, 0x8}, + }, + MapInt64Float: map[int64]float32{ + 0: 0, + math.MaxInt64: math.MaxFloat32, + math.MinInt64: math.SmallestNonzeroFloat32, + }, + MapInt64Int32: map[int64]int32{ + 0: 0, + math.MaxInt64: math.MaxInt32, + math.MinInt64: math.MinInt32, + }, + MapstringSINT64: map[string]int64{ + "0": 0, + "max": math.MaxInt64, + "min": math.MinInt64, + }, + MapstringSfixed64: map[string]int64{ + "0": 0, + "max": math.MaxInt64, + "min": math.MinInt64, + }, + MapstringFixed64: map[string]uint64{ + "max": uint64(math.MaxInt64), + "min": 0, + }, + MapstringUint64: map[string]uint64{ + "max": uint64(math.MaxInt64), + "min": 0, + }, + MapstringDouble: map[string]float64{ + "0": 0, + "max": math.MaxFloat64, + "min": math.SmallestNonzeroFloat64, + }, + MapstringBool: map[string]bool{ + "0": false, + "max": true, + }, + MapstringString: map[string]string{ + "0": "0", + "max": "max", + "min": "min", + }, + MapstringBytes: map[string][]byte{ + "0": {0x0}, + "max": {0x1, 0x2, 0x3, 0x4}, + "min": {0x5, 0x6, 0x7, 0x8}, + }, + MapstringFloat: map[string]float32{ + "0": 0, + "max": math.MaxFloat32, + "min": math.SmallestNonzeroFloat32, + }, + MapstringInt64: map[string]int64{ + "0": 0, + "max": math.MaxInt64, + "min": math.MinInt64, + }, + } + + return req +} + // marshal ExampleReq Object to ProtoBinary, and write binaryData into exampleProtoPath func saveExampleReqProtoBufData() error { req := constructExampleReqObject() - data, err := goproto.Marshal(req.ProtoReflect().Interface()) + data, err := goproto.Marshal(req) if err != nil { panic("goproto marshal data failed") } @@ -221,6 +404,41 @@ func saveExampleReqProtoBufData() error { return nil } +// construct BasicExampleReq Object +func saveBasicExampleReqProtoBufData() error { + req := constructBasicExampleReqObject() + data, err := goproto.Marshal(req.ProtoReflect().Interface()) + if err != nil { + panic("goproto marshal data failed") + } + checkExist := func(path string) bool { + _, err := os.Stat(path) + if err != nil { + if os.IsExist(err) { + return true + } + return false + } + return true + } + var file *os.File + absoluteExampleProtoPath := util_test.MustGitPath(basicExampleProtoPath) + if checkExist(absoluteExampleProtoPath) == true { + if err := os.Remove(absoluteExampleProtoPath); err != nil { + panic("delete protoBinaryFile failed") + } + } + file, err = os.Create(absoluteExampleProtoPath) + if err != nil { + panic("create protoBinaryFile failed") + } + defer file.Close() + if _, err := file.Write(data); err != nil { + panic("write protoBinary data failed") + } + return nil +} + // read ProtoBuf's data in binary format from exampleProtoPath func readExampleReqProtoBufData() []byte { out, err := ioutil.ReadFile(util_test.MustGitPath(exampleProtoPath)) @@ -230,6 +448,14 @@ func readExampleReqProtoBufData() []byte { return out } +func readBasicExampleReqProtoBufData() []byte { + out, err := ioutil.ReadFile(util_test.MustGitPath(basicExampleProtoPath)) + if err != nil { + panic(err) + } + return out +} + // marshal ExampleReq Object to JsonBinary, and write binaryData into exampleJSONPath func saveExampleReqJSONData() error { req := constructExampleReqObject() diff --git a/conv/p2j/impl.go b/conv/p2j/impl.go index a5904859..0f4e97e2 100644 --- a/conv/p2j/impl.go +++ b/conv/p2j/impl.go @@ -161,7 +161,7 @@ func (self *BinaryConv) unmarshalSingular(ctx context.Context, resp http.Respons *out = json.EncodeInt64(*out, int64(v)) } case proto.SINT64: - v, e := p.ReadInt64() + v, e := p.ReadSint64() if e != nil { return wrapError(meta.ErrRead, "unmarshal Sint64kind error", e) } @@ -172,6 +172,12 @@ func (self *BinaryConv) unmarshalSingular(ctx context.Context, resp http.Respons return wrapError(meta.ErrRead, "unmarshal Uint64kind error", e) } *out = json.EncodeInt64(*out, int64(v)) + case proto.FIX64: + v, e := p.ReadFixed64() + if e != nil { + return wrapError(meta.ErrRead, "unmarshal Fixed64kind error", e) + } + *out = json.EncodeInt64(*out, int64(v)) case proto.SFIX64: v, e := p.ReadSfixed64() if e != nil { @@ -278,6 +284,7 @@ func (self *BinaryConv) unmarshalList(ctx context.Context, resp http.ResponseSet self.unmarshalSingular(ctx, resp, p, out, fd.Elem()) for p.Read < len(p.Buf) { elementFieldNumber, _, tagLen, err := p.ConsumeTagWithoutMove() + if err != nil { return wrapError(meta.ErrRead, "consume list child Tag error", err) } diff --git a/proto/binary/binary.go b/proto/binary/binary.go index 0fd2a4e5..39ee951b 100644 --- a/proto/binary/binary.go +++ b/proto/binary/binary.go @@ -1,7 +1,6 @@ package binary import ( - "encoding/binary" "errors" "io" "math" @@ -240,23 +239,15 @@ func (p *BinaryProtocol) WriteUint32(value uint32) error { } // Writefixed32 -func (p *BinaryProtocol) WriteFixed32(value int32) error { - v, err := p.malloc(4) - if err != nil { - return err - } - binary.LittleEndian.PutUint32(v, uint32(value)) - return err +func (p *BinaryProtocol) WriteFixed32(value uint32) error { + p.Buf = protowire.BinaryEncoder{}.EncodeFixed32(p.Buf, value) + return nil } // WriteSfixed32 func (p *BinaryProtocol) WriteSfixed32(value int32) error { - v, err := p.malloc(4) - if err != nil { - return err - } - binary.LittleEndian.PutUint32(v, uint32(value)) - return err + p.Buf = protowire.BinaryEncoder{}.EncodeSfixed32(p.Buf, value) + return nil } // WriteInt64 @@ -279,42 +270,26 @@ func (p *BinaryProtocol) WriteUint64(value uint64) error { // Writefixed64 func (p *BinaryProtocol) WriteFixed64(value uint64) error { - v, err := p.malloc(8) - if err != nil { - return err - } - binary.LittleEndian.PutUint64(v, value) - return err + p.Buf = protowire.BinaryEncoder{}.EncodeFixed64(p.Buf, value) + return nil } // WriteSfixed64 func (p *BinaryProtocol) WriteSfixed64(value int64) error { - v, err := p.malloc(8) - if err != nil { - return err - } - binary.LittleEndian.PutUint64(v, uint64(value)) - return err + p.Buf = protowire.BinaryEncoder{}.EncodeSfixed64(p.Buf, value) + return nil } // WriteFloat func (p *BinaryProtocol) WriteFloat(value float32) error { - v, err := p.malloc(4) - if err != nil { - return err - } - binary.LittleEndian.PutUint32(v, math.Float32bits(float32(value))) - return err + p.Buf = protowire.BinaryEncoder{}.EncodeFloat32(p.Buf, value) + return nil } // WriteDouble func (p *BinaryProtocol) WriteDouble(value float64) error { - v, err := p.malloc(8) - if err != nil { - return err - } - binary.LittleEndian.PutUint64(v, math.Float64bits(value)) - return err + p.Buf = protowire.BinaryEncoder{}.EncodeDouble(p.Buf, value) + return nil } // WriteString @@ -422,7 +397,7 @@ func (p *BinaryProtocol) WriteMap(desc *proto.TypeDescriptor, val interface{}, c p.AppendTag(1, MapKey.WireType()) // notice: may have problem, when k is sfixed64/fixed64 or sfixed32/fixed32 there is no need to use varint // we had better add more code to judge the type of k if write fast - // p.WriteInt64(int64(k)) + // p.WriteInt64(int64(k)) p.WriteBaseTypeWithDesc(MapKey, k, NeedMessageLen, cast, disallowUnknown, useFieldName) // the gerneral way p.AppendTag(2, MapValue.WireType()) p.WriteBaseTypeWithDesc(MapValue, v, NeedMessageLen, cast, disallowUnknown, useFieldName) @@ -466,7 +441,7 @@ func (p *BinaryProtocol) WriteMessageFields(desc *proto.MessageDescriptor, val i return meta.NewError(meta.ErrWrite, "append field tag failed", nil) } } - + if err := p.WriteAnyWithDesc(f.Type(), v, NeedMessageLen, cast, disallowUnknown, useFieldName); err != nil { return err } @@ -635,7 +610,7 @@ func (p *BinaryProtocol) WriteBaseTypeWithDesc(desc *proto.TypeDescriptor, val i v = int32(vv) } } - p.WriteFixed32(v) + p.WriteFixed32(uint32(v)) case proto.FLOAT: v, ok := val.(float32) if !ok { @@ -678,7 +653,7 @@ func (p *BinaryProtocol) WriteBaseTypeWithDesc(desc *proto.TypeDescriptor, val i } } } - p.WriteSfixed64(v) + p.WriteFixed64(uint64(v)) case proto.DOUBLE: v, ok := val.(float64) if !ok { @@ -720,7 +695,7 @@ func (p *BinaryProtocol) WriteBaseTypeWithDesc(desc *proto.TypeDescriptor, val i if NeedMessageLen { p.Buf, pos = AppendSpeculativeLength(p.Buf) } - + if useFieldName { val, ok = val.(map[string]interface{}) } else { @@ -895,7 +870,7 @@ func (p *BinaryProtocol) ReadFixed32() (int32, error) { // ReadSFixed32 func (p *BinaryProtocol) ReadSfixed32() (int32, error) { - value, n := protowire.BinaryDecoder{}.DecodeFixed32((p.Buf)[p.Read:]) + value, n := protowire.BinaryDecoder{}.DecodeSfixed32((p.Buf)[p.Read:]) if n < 0 { return int32(value), errDecodeField } @@ -1128,7 +1103,7 @@ func (p *BinaryProtocol) ReadMap(desc *proto.TypeDescriptor, copyString bool, di // - LIST/SET will be converted to []interface{} // - MAP will be converted to map[string]interface{} or map[int]interface{} or map[interface{}]interface{} // - MESSAGE will be converted to map[proto.FieldNumber]interface{} or map[string]interface{} -func (p *BinaryProtocol) ReadAnyWithDesc(desc *proto.TypeDescriptor, hasMessageLen bool ,copyString bool, disallowUnknown bool, useFieldName bool) (interface{}, error) { +func (p *BinaryProtocol) ReadAnyWithDesc(desc *proto.TypeDescriptor, hasMessageLen bool, copyString bool, disallowUnknown bool, useFieldName bool) (interface{}, error) { switch { case desc.IsList(): return p.ReadList(desc, copyString, disallowUnknown, useFieldName) diff --git a/proto/generic/example_test.go b/proto/generic/example_test.go index 3edad992..aaf304cd 100644 --- a/proto/generic/example_test.go +++ b/proto/generic/example_test.go @@ -18,8 +18,8 @@ var opts = &Options{ } func ExampleValue_GetByPath(t *testing.T) { - desc := getExample2Desc() - data := getExample2Data() + desc := getExample3Desc() + data := getExample3Data() v := NewRootValue(desc, data) ps := []Path{NewPathFieldName("InnerBase2"), NewPathFieldName("Base"), NewPathFieldName("Extra"), NewPathStrKey("1b")} @@ -32,8 +32,8 @@ func ExampleValue_GetByPath(t *testing.T) { } func ExampleValue_GetMany() { - desc := getExample2Desc() - data := getExample2Data() + desc := getExample3Desc() + data := getExample3Data() v := NewRootValue(desc, data) ps := []PathNode{ @@ -49,8 +49,8 @@ func ExampleValue_GetMany() { } func ExampleValue_SetByPath() { - desc := getExample2Desc() - data := getExample2Data() + desc := getExample3Desc() + data := getExample3Data() v := NewRootValue(desc, data) p := binary.NewBinaryProtol([]byte{}) @@ -76,11 +76,10 @@ func ExampleValue_SetByPath() { } func ExampleValue_SetMany(t *testing.T) { - desc := getExample2Desc() - data := getExample2Data() + desc := getExample3Desc() + data := getExample3Data() root := NewRootValue(desc, data) - exp1 := int32(-1024) n1 := NewNodeInt32(exp1) address := []int{} @@ -96,14 +95,13 @@ func ExampleValue_SetMany(t *testing.T) { v1 := root.GetByPath(NewPathFieldName("A")) act1, err := v1.Int() fmt.Println(act1) // -1024 - expmin := int32(math.MinInt32) expmax := int32(math.MaxInt32) nmin := NewNodeInt32(expmin) nmax := NewNodeInt32(expmax) PathExampleListInt32 = []Path{NewPathFieldName("InnerBase2"), NewPathFieldId(proto.FieldNumber(8))} - + vv, listInt2root := root.GetByPathWithAddress(PathExampleListInt32...) l2, err := vv.Len() fmt.Println(l2) // 6 @@ -111,7 +109,6 @@ func ExampleValue_SetMany(t *testing.T) { panic(err) } - path2root := []Path{NewPathFieldName("InnerBase2"), NewPathFieldId(proto.FieldNumber(8)), NewPathIndex(1024)} address2root := append(listInt2root, 0) @@ -125,7 +122,7 @@ func ExampleValue_SetMany(t *testing.T) { Node: nmax, }, }, opts, &root, address2root, path2root...) - + if err != nil { panic(err) } @@ -150,13 +147,13 @@ func ExampleValue_SetMany(t *testing.T) { if err != nil { panic(err) } - + fmt.Println(ll2) // 8 } func ExampleValue_MarshalTo(t *testing.T) { - desc := getExample2Desc() - data := getExample2Data() + desc := getExample3Desc() + data := getExample3Data() v := NewRootValue(desc, data) partial := getExamplePartialDesc() @@ -173,15 +170,14 @@ func ExampleValue_MarshalTo(t *testing.T) { fmt.Printf("%#v", partMsg) } - -func ExamplePathNode_Load(* testing.T) { - desc := getExample2Desc() - data := getExample2Data() +func ExamplePathNode_Load(*testing.T) { + desc := getExample3Desc() + data := getExample3Data() root := PathNode{ Node: NewNode(proto.MESSAGE, data), } - + // load first level children err := root.Load(false, opts, desc) if err != nil { @@ -196,7 +192,6 @@ func ExamplePathNode_Load(* testing.T) { } fmt.Printf("%#v", root) - // reuse PathNode memory reuse := pathNodePool.Get().(*PathNode) reuse.Node = NewNode(proto.MESSAGE, data) @@ -210,8 +205,8 @@ func ExamplePathNode_Load(* testing.T) { } func ExampleValue_MarshalAll() { - desc := getExample2Desc() - data := getExample2Data() + desc := getExample3Desc() + data := getExample3Data() v := NewRootValue(desc, data) p := PathNode{ Node: v.Node, @@ -234,8 +229,8 @@ func ExampleValue_MarshalAll() { } func ExamplePathNode_MarshalMany(t *testing.T) { - desc := getExample2Desc() - data := getExample2Data() + desc := getExample3Desc() + data := getExample3Data() v := NewRootValue(desc, data) @@ -249,7 +244,7 @@ func ExamplePathNode_MarshalMany(t *testing.T) { if err != nil { panic(err) } - + n := PathNode{ Path: NewPathFieldId(1), // just used path type for message flag, id is not used Node: v.Node, @@ -263,5 +258,5 @@ func ExamplePathNode_MarshalMany(t *testing.T) { panic(err) } fmt.Printf("%#v", msg) - -} \ No newline at end of file + +} diff --git a/proto/generic/path_test.go b/proto/generic/path_test.go index fce2c512..41c51b80 100644 --- a/proto/generic/path_test.go +++ b/proto/generic/path_test.go @@ -7,8 +7,8 @@ import ( ) func TestTreeMarshal(t *testing.T) { - desc := getExample2Desc() - data := getExample2Data() + desc := getExample3Desc() + data := getExample3Data() partdesc := getExamplePartialDesc() t.Run("marshalNormal", func(t *testing.T) { v := NewRootValue(desc, data) @@ -30,6 +30,6 @@ func TestTreeMarshal(t *testing.T) { buf, err := tree.Marshal(opts) require.Nil(t, err) require.Equal(t, len(buf), len(data)) - + }) -} \ No newline at end of file +} diff --git a/proto/generic/value_test.go b/proto/generic/value_test.go index d9b28bba..39ac877a 100644 --- a/proto/generic/value_test.go +++ b/proto/generic/value_test.go @@ -14,19 +14,19 @@ import ( "github.com/cloudwego/dynamicgo/proto" "github.com/cloudwego/dynamicgo/proto/binary" "github.com/cloudwego/dynamicgo/testdata/kitex_gen/pb/base" - "github.com/cloudwego/dynamicgo/testdata/kitex_gen/pb/example2" + "github.com/cloudwego/dynamicgo/testdata/kitex_gen/pb/example3" "github.com/stretchr/testify/require" goprotowire "google.golang.org/protobuf/encoding/protowire" goproto "google.golang.org/protobuf/proto" ) const ( - exampleIDLPath = "../../testdata/idl/example2.proto" - exampleProtoPath = "../../testdata/data/example2_pb.bin" + exampleIDLPath = "../../testdata/idl/example3.proto" + exampleProtoPath = "../../testdata/data/example3_pb.bin" ) // parse protofile to get MessageDescriptor -func getExample2Desc() *proto.TypeDescriptor { +func getExample3Desc() *proto.TypeDescriptor { includeDirs := util_test.MustGitPath("testdata/idl/") // includeDirs is used to find the include files. svc, err := proto.NewDescritorFromPath(context.Background(), exampleIDLPath, includeDirs) if err != nil { @@ -54,7 +54,7 @@ func getExamplePartialDesc() *proto.TypeDescriptor { return res } -func getExample2Data() []byte { +func getExample3Data() []byte { out, err := ioutil.ReadFile(exampleProtoPath) if err != nil { panic(err) @@ -62,11 +62,11 @@ func getExample2Data() []byte { return out } -func getExample2Req() *example2.ExampleReq { - req := example2.ExampleReq{} +func getExample3Req() *example3.ExampleReq { + req := example3.ExampleReq{} req.Msg = "hello" req.Subfix = math.MaxFloat64 - req.InnerBase2 = &example2.InnerBase2{} + req.InnerBase2 = &example3.InnerBase2{} req.InnerBase2.Bool = true req.InnerBase2.Uint32 = uint32(123) req.InnerBase2.Uint64 = uint64(123) @@ -75,7 +75,7 @@ func getExample2Req() *example2.ExampleReq { req.InnerBase2.ListInt32 = []int32{12, 13, 14, 15, 16, 17} req.InnerBase2.MapStringString = map[string]string{"m1": "aaa", "m2": "bbb", "m3": "ccc", "m4": "ddd"} req.InnerBase2.SetInt32 = []int32{200, 201, 202, 203, 204, 205} - req.InnerBase2.Foo = example2.FOO_FOO_A + req.InnerBase2.Foo = example3.FOO_FOO_A req.InnerBase2.MapInt32String = map[int32]string{1: "aaa", 2: "bbb", 3: "ccc", 4: "ddd"} req.InnerBase2.Binary = []byte{0x1, 0x2, 0x3, 0x4} req.InnerBase2.MapUint32String = map[uint32]string{uint32(1): "u32aa", uint32(2): "u32bb", uint32(3): "u32cc", uint32(4): "u32dd"} @@ -154,12 +154,23 @@ func getExample2Req() *example2.ExampleReq { req.InnerBase2.Base.TrafficEnv.Open = false req.InnerBase2.Base.TrafficEnv.Env = "env" req.InnerBase2.Base.Extra = map[string]string{"1b": "aaa", "2b": "bbb", "3b": "ccc", "4b": "ddd"} + + req.InnerBase2.Sfixed32 = int32(100) + req.InnerBase2.Fixed64 = uint64(200) + req.InnerBase2.Sint32 = int32(300) + req.InnerBase2.Sint64 = int64(400) + req.InnerBase2.ListSInt64 = []int64{100, 200, 300} + req.InnerBase2.ListSInt32 = []int32{121, 400, 514} + req.InnerBase2.ListSfixed32 = []int32{201, 31, 22} + req.InnerBase2.ListFixed64 = []uint64{841, 23, 11000} + req.InnerBase2.MapInt64Sfixed64 = map[int64]int64{2: 2, 3: 3, 100: -100} + req.InnerBase2.MapStringFixed32 = map[string]uint32{"1": 1, "2": 222222} return &req } -// build binaryData for example2.proto +// build binaryData for example3.proto func generateBinaryData() error { - req := getExample2Req() + req := getExample3Req() data, err := goproto.Marshal(req.ProtoReflect().Interface()) if err != nil { panic("goproto marshal data failed") @@ -197,8 +208,8 @@ func TestCreateValue(t *testing.T) { func TestCount(t *testing.T) { t.Run("Normal", func(t *testing.T) { - desc := getExample2Desc() - data := getExample2Data() + desc := getExample3Desc() + data := getExample3Data() fmt.Printf("data len: %d\n", len(data)) v := NewRootValue(desc, data) children := make([]PathNode, 0, 4) @@ -214,7 +225,7 @@ func TestCount(t *testing.T) { // stored unknown node t.Run("Partial", func(t *testing.T) { desc := getExamplePartialDesc() - data := getExample2Data() + data := getExample3Data() fmt.Printf("data len: %d\n", len(data)) v := NewRootValue(desc, data) children := make([]PathNode, 0, 4) @@ -236,11 +247,11 @@ func countHelper(count *int, ps []PathNode) { } func TestMarshalTo(t *testing.T) { - desc := getExample2Desc() - data := getExample2Data() + desc := getExample3Desc() + data := getExample3Data() partial := getExamplePartialDesc() - exp := example2.ExampleReq{} + exp := example3.ExampleReq{} v := NewRootValue(desc, data) dataLen := len(data) l := 0 @@ -265,7 +276,7 @@ func TestMarshalTo(t *testing.T) { opts := &Options{} buf, err := v.MarshalTo(partial, opts) require.Nil(t, err) - ep := example2.ExampleReqPartial{} + ep := example3.ExampleReqPartial{} bufLen := len(buf) l := 0 @@ -295,7 +306,7 @@ func TestMarshalTo(t *testing.T) { }) t.Run("unknown", func(t *testing.T) { - data := getExample2Data() + data := getExample3Data() v := NewRootValue(desc, data) exist, err := v.SetByPath(NewNodeString("Insert"), NewPathFieldId(1024)) require.False(t, exist) @@ -306,7 +317,7 @@ func TestMarshalTo(t *testing.T) { opts := &Options{DisallowUnknown: false} buf, err := v.MarshalTo(partial, opts) require.NoError(t, err) - ep := example2.ExampleReqPartial{} + ep := example3.ExampleReqPartial{} bufLen := len(buf) l := 0 @@ -353,9 +364,9 @@ func handlePartialMapStringString2(p map[int]interface{}) { } func TestGet(t *testing.T) { - desc := getExample2Desc() - data := getExample2Data() - exp := example2.ExampleReq{} + desc := getExample3Desc() + data := getExample3Data() + exp := example3.ExampleReq{} v := NewRootValue(desc, data) dataLen := len(data) l := 0 @@ -376,7 +387,7 @@ func TestGet(t *testing.T) { t.Fatal("test failed") } - req := getExample2Req() + req := getExample3Req() t.Run("GetByStr()", func(t *testing.T) { v := v.GetByPath(PathExampleMapStringString...) require.Nil(t, v.Check()) @@ -569,11 +580,102 @@ func TestGet(t *testing.T) { deepEqual(exp11, act11) }) + t.Run("TestGetfixedNumber", func(t *testing.T) { + // fixed64 + exp := req.InnerBase2.Fixed64 + ve := v.GetByPath(NewPathFieldName("InnerBase2"), NewPathFieldName("Fixed64")) + if ve.Error() != "" { + t.Fatal(ve.Error()) + } + act, err := ve.Uint() + fmt.Println(exp) + fmt.Println(act) + require.NoError(t, err) + require.Equal(t, uint(exp), act) + + // repeated sint64 + exp1 := req.InnerBase2.ListSInt64[1] + v1 := v.GetByPath(NewPathFieldName("InnerBase2"), NewPathFieldId(26), NewPathIndex(1)) + if v1.Error() != "" { + t.Fatal(v1.Error()) + } + act1, err := v1.Int() + fmt.Println(exp1) + fmt.Println(act1) + require.NoError(t, err) + require.Equal(t, int(exp1), act1) + + // repeated sint32 + exp2 := req.InnerBase2.ListSInt32[2] + v2 := v.GetByPath(NewPathFieldName("InnerBase2"), NewPathFieldId(27), NewPathIndex(2)) + if v2.Error() != "" { + t.Fatal(v2.Error()) + } + act2, err := v2.Int() + fmt.Println(exp2) + fmt.Println(act2) + require.NoError(t, err) + require.Equal(t, int(exp2), act2) + + // repeated sfixed32 + exp3 := req.InnerBase2.ListSfixed32[0] + v3 := v.GetByPath(NewPathFieldName("InnerBase2"), NewPathFieldId(28), NewPathIndex(0)) + if v3.Error() != "" { + t.Fatal(v3.Error()) + } + act3, err := v3.Int() + fmt.Println(exp3) + fmt.Println(act3) + require.NoError(t, err) + require.Equal(t, int(exp3), act3) + + // repeated fixed64 + exp4 := req.InnerBase2.ListFixed64[2] + v4 := v.GetByPath(NewPathFieldName("InnerBase2"), NewPathFieldName("ListFixed64"), NewPathIndex(2)) + if v4.Error() != "" { + t.Fatal(v4.Error()) + } + act4, err := v4.Uint() + fmt.Println(exp4) + fmt.Println(act4) + require.NoError(t, err) + require.Equal(t, uint(exp4), act4) + + // MapInt64Sfixed64 + exp5 := req.InnerBase2.MapInt64Sfixed64[100] + v5 := v.GetByPath(NewPathFieldName("InnerBase2"), NewPathFieldName("MapInt64Sfixed64"), NewPathIntKey(100)) + act5, err := v5.int() + fmt.Println(exp5) + fmt.Println(act5) + require.NoError(t, err) + require.Equal(t, int(exp5), act5) + + // MapStringFixed32 + exp6 := req.InnerBase2.MapStringFixed32["2"] + v6 := v.GetByPath(NewPathFieldName("InnerBase2"), NewPathFieldName("MapStringFixed32"), NewPathStrKey("2")) + act6, err := v6.Uint() + fmt.Println(exp6) + fmt.Println(act6) + require.NoError(t, err) + require.Equal(t, uint(exp6), act6) + + // Sfixed32 + exp7 := req.InnerBase2.Sfixed32 + v7 := v.GetByPath(NewPathFieldName("InnerBase2"), NewPathFieldName("Sfixed32")) + if v7.Error() != "" { + t.Fatal(v7.Error()) + } + act7, err := v7.Int() + fmt.Println(exp7) + fmt.Println(act7) + require.NoError(t, err) + require.Equal(t, int(exp7), act7) + }) } func TestSetByPath(t *testing.T) { - desc := getExample2Desc() - data := getExample2Data() + desc := getExample3Desc() + data := getExample3Data() v := NewRootValue(desc, data) v2 := NewNode(proto.MESSAGE, data) d2 := desc.Message().ByName("InnerBase2").Message().ByName("Base").Message().ByName("Extra").MapValue() @@ -706,10 +808,10 @@ func TestSetByPath(t *testing.T) { } func TestUnsetByPath(t *testing.T) { - desc := getExample2Desc() - data := getExample2Data() + desc := getExample3Desc() + data := getExample3Data() r := NewRootValue(desc, data) - req := getExample2Req() + req := getExample3Req() v := r.Fork() err := v.UnsetByPath() require.Nil(t, err) @@ -906,8 +1008,8 @@ func TestUnsetByPath(t *testing.T) { } func TestSetMany(t *testing.T) { - desc := getExample2Desc() - data := getExample2Data() + desc := getExample3Desc() + data := getExample3Data() opts := &Options{ UseNativeSkip: true, } @@ -1011,7 +1113,7 @@ func TestSetMany(t *testing.T) { }, opts, &vRoot, address, pathes...) require.Nil(t, err) - exp := example2.ExampleReq{} + exp := example3.ExampleReq{} // fast read dataLen := vRoot.l data := vRoot.raw() @@ -1097,7 +1199,7 @@ func TestSetMany(t *testing.T) { }, opts, &vRoot, address2root, path2root...) require.Nil(t, err) - expx := example2.InnerBase2{} + expx := example3.InnerBase2{} // fast read data = inner.raw() byteLen, offset := goprotowire.ConsumeVarint(data) diff --git a/testdata/data/basic_example.json b/testdata/data/basic_example.json new file mode 100644 index 00000000..6e60f872 --- /dev/null +++ b/testdata/data/basic_example.json @@ -0,0 +1 @@ +{"Int32":123,"Int64":123,"Uint32":2147483647,"Uint64":9223372036854775807,"Sint32":123,"Sint64":123,"Sfixed32":123,"Sfixed64":123,"Fixed32":123,"Fixed64":123,"Float":123.123,"Double":123.123,"Bool":true,"Str":"hello world!","Bytes":"AQIDBA==","ListInt32":[100,200,300,400,500],"ListInt64":[100,200,300,400,500],"ListUint32":[100,200,300,400,500],"ListUint64":[100,200,300,400,500],"ListSint32":[100,200,300,400,500],"ListSint64":[100,200,300,400,500],"ListSfixed32":[100,200,300,400,500],"ListSfixed64":[100,200,300,400,500],"ListFixed32":[100,200,300,400,500],"ListFixed64":[100,200,300,400,500],"ListFloat":[1.1,2.2,3.3,4.4,5.5],"ListDouble":[1.1,2.2,3.3,4.4,5.5],"ListBool":[true,false,true,false,true],"ListString":["a1","b2","c3","d4","e5"],"ListBytes":["AQIDBA==","BQYHCA=="],"MapInt64SINT32":{"-9223372036854775808":-2147483648,"0":0,"9223372036854775807":2147483647},"MapInt64Sfixed32":{"-9223372036854775808":-2147483648,"0":0,"9223372036854775807":2147483647},"MapInt64Fixed32":{"-9223372036854775808":0,"9223372036854775807":2147483647},"MapInt64Uint32":{"-9223372036854775808":0,"0":0,"9223372036854775807":2147483647},"MapInt64Double":{"-9223372036854775808":5e-324,"0":0,"9223372036854775807":1.7976931348623157e+308},"MapInt64Bool":{"-9223372036854775808":false,"0":false,"9223372036854775807":true},"MapInt64String":{"-9223372036854775808":"min","0":"0","9223372036854775807":"max"},"MapInt64Bytes":{"-9223372036854775808":"BQYHCA==","0":"AA==","9223372036854775807":"AQIDBA=="},"MapInt64Float":{"-9223372036854775808":1e-45,"0":0,"9223372036854775807":3.4028235e+38},"MapInt64Int32":{"-9223372036854775808":-2147483648,"0":0,"9223372036854775807":2147483647},"MapstringSINT64":{"0":0,"max":9223372036854775807,"min":-9223372036854775808},"MapstringSfixed64":{"0":0,"max":9223372036854775807,"min":-9223372036854775808},"MapstringFixed64":{"max":9223372036854775807,"min":0},"MapstringUint64":{"max":9223372036854775807,"min":0},"MapstringDouble":{"0":0,"max":1.7976931348623157e+308,"min":5e-324},"MapstringBool":{"0":false,"max":true},"MapstringString":{"0":"0","max":"max","min":"min"},"MapstringBytes":{"0":"AA==","max":"AQIDBA==","min":"BQYHCA=="},"MapstringFloat":{"0":0,"max":3.4028235e+38,"min":1e-45},"MapstringInt64":{"0":0,"max":9223372036854775807,"min":-9223372036854775808}} \ No newline at end of file diff --git a/testdata/data/basic_example_pb.bin b/testdata/data/basic_example_pb.bin new file mode 100644 index 0000000000000000000000000000000000000000..9a8903b61cbf82cbb080feadcb2f20c504311a44 GIT binary patch literal 1246 zcma)5F^m#X5dAYB*p)+B5H2<*XGdXy;#Ed(wYM;KCYqp}ITGZOYrIIYWJ_W}wmT|A zNh}N{C5?pKHB{yr6DmVLK^JnJGf3w&%r*`XtU~REwc)1zm zXYi;dgm}V+@r)PG7rR&CCE%dG2%I>-nbIfxDq4+R2>9#!W;}wu~`9LH!3=!g&Vd=F*~D$Hev?~8|>mA=VUu6E6a(@N7Wnv$iJ zz+GKa^e(0Anbk=;&+DyJ&vMg!-EiL|(W>-u)3~9-6Z*}!hapDekaxroojCWb#;A0m zBX*Ums)BZnFhS9mYL4)RN}3CK;b}*?x`?Qsu19FcGD3_osfiT>8E=f1<`t7wy2)y> zGfz9H*kWSS`E91E1ld=%2hQJUv4NqExj*wg3#{bp`KDh+Ehn< f#SN(|sVV49xvKOJq!u%f>vsy|T+79OqYi%oJE*9x literal 0 HcmV?d00001 diff --git a/testdata/data/example2_pb.bin b/testdata/data/example2_pb.bin index 0dcfd37a..4cfd1c9f 100644 --- a/testdata/data/example2_pb.bin +++ b/testdata/data/example2_pb.bin @@ -1,14 +1,9 @@ -hello{{1L6@: hello_innerB J +hello{{ {(1L6@: hello_innerB J +m4dddJ m1aaaJ m2bbbJ -m3cccJ -m4dddR baaabbbbbcccbdddjr u32bbr u32ccr u32ddr u32aaz u64aaz u64bbz u64ccz u64dd 64aaa 64bbb 64ccc 64dddTP -logIdcalleraddr"client*env2 -1aaaa2 -2abbb2 -3accc2 -4addd_[ +m3cccR bbbbbcccbdddbaaajr u32ccr u32ddr u32aar u32bbz u64aaz u64bbz u64ccz u64dd 64aaa 64bbb 64ccc 64ddd_[ logId2caller2addr2"client2*env22 1aaaa22 @@ -17,27 +12,32 @@ 3accc22 -4addd2P +4addd2TP logIdcalleraddr"client*env2 1aaaa2 2abbb2 3accc2 -4addd[ +4adddP +logIdcalleraddr"client*env2 +3accc2 +4addd2 +1aaaa2 +2abbb[ logId2caller2addr2"client2*env22 +4addd22 + 1aaaa22 2abbb22 -3accc22 - -4addd2U +3accc2U 1P logIdcalleraddr"client*env2 +4addd2 1aaaa2 2abbb2 -3accc2 -4addd` +3accc` 2[ logId2caller2addr2"client2*env22 @@ -49,7 +49,7 @@ 4addd211122233344516P logIdcalleraddr"client*env2 -4bddd2 1baaa2 2bbbb2 -3bccc \ No newline at end of file +3bccc2 +4bddd \ No newline at end of file diff --git a/testdata/data/example2req.json b/testdata/data/example2req.json index a2e23aa0..a1285605 100644 --- a/testdata/data/example2req.json +++ b/testdata/data/example2req.json @@ -1 +1 @@ -{"Msg":"hello","A":25,"InnerBase2":{"Bool":true,"Uint32":123,"Uint64":123,"Double":22.3,"String":"hello_inner","ListInt32":[12,13,14,15,16,17],"MapStringString":{"m1":"aaa","m2":"bbb"},"SetInt32":[200,201,202,203,204,205],"MapInt32String":{"1":"aaa","2":"bbb","3":"ccc","4":"ddd"},"Binary":"AQIDBA==","MapUint32String":{"1":"u32aa","2":"u32bb","3":"u32cc","4":"u32dd"},"MapUint64String":{"1":"u64aa","2":"u64bb","3":"u64cc","4":"u64dd"},"MapInt64String":{"1":"64aaa","2":"64bbb","3":"64ccc","4":"64ddd"},"MapInt64Base":{"1":{"LogID":"logId","Caller":"caller","Addr":"addr","Client":"client","TrafficEnv":{"Env":"env"},"Extra":{"1a":"aaa","2a":"bbb","3a":"ccc","4a":"ddd"}},"2":{"LogID":"logId2","Caller":"caller2","Addr":"addr2","Client":"client2","TrafficEnv":{"Open":true,"Env":"env2"},"Extra":{"1a":"aaa2","2a":"bbb2","3a":"ccc2","4a":"ddd2"}}},"MapStringBase":{"1":{"LogID":"logId","Caller":"caller","Addr":"addr","Client":"client","TrafficEnv":{"Env":"env"},"Extra":{"1a":"aaa","2a":"bbb","3a":"ccc","4a":"ddd"}},"2":{"LogID":"logId2","Caller":"caller2","Addr":"addr2","Client":"client2","TrafficEnv":{"Open":true,"Env":"env2"},"Extra":{"1a":"aaa2","2a":"bbb2","3a":"ccc2","4a":"ddd2"}}},"ListBase":[{"LogID":"logId","Caller":"caller","Addr":"addr","Client":"client","TrafficEnv":{"Env":"env"},"Extra":{"1a":"aaa","2a":"bbb","3a":"ccc","4a":"ddd"}},{"LogID":"logId2","Caller":"caller2","Addr":"addr2","Client":"client2","TrafficEnv":{"Open":true,"Env":"env2"},"Extra":{"1a":"aaa2","2a":"bbb2","3a":"ccc2","4a":"ddd2"}}],"ListString":["111","222","333","44","51","6"],"Base":{"LogID":"logId","Caller":"caller","Addr":"addr","Client":"client","TrafficEnv":{"Env":"env"},"Extra":{"1b":"aaa","2b":"bbb","3b":"ccc","4b":"ddd"}}}} \ No newline at end of file +{"Msg":"hello","A":25,"InnerBase2":{"Bool":true,"Uint32":123,"Uint64":123,"Int32":123,"SInt64":123,"Double":22.3,"String":"hello_inner","ListInt32":[12,13,14,15,16,17],"MapStringString":{"m1":"aaa","m2":"bbb"},"ListSInt64":[200,201,202,203,204,205],"MapInt32String":{"1":"aaa","2":"bbb","3":"ccc","4":"ddd"},"Binary":"AQIDBA==","MapUint32String":{"1":"u32aa","2":"u32bb","3":"u32cc","4":"u32dd"},"MapUint64String":{"1":"u64aa","2":"u64bb","3":"u64cc","4":"u64dd"},"MapInt64String":{"1":"64aaa","2":"64bbb","3":"64ccc","4":"64ddd"},"MapInt64Base":{"1":{"LogID":"logId","Caller":"caller","Addr":"addr","Client":"client","TrafficEnv":{"Env":"env"},"Extra":{"1a":"aaa","2a":"bbb","3a":"ccc","4a":"ddd"}},"2":{"LogID":"logId2","Caller":"caller2","Addr":"addr2","Client":"client2","TrafficEnv":{"Open":true,"Env":"env2"},"Extra":{"1a":"aaa2","2a":"bbb2","3a":"ccc2","4a":"ddd2"}}},"MapStringBase":{"1":{"LogID":"logId","Caller":"caller","Addr":"addr","Client":"client","TrafficEnv":{"Env":"env"},"Extra":{"1a":"aaa","2a":"bbb","3a":"ccc","4a":"ddd"}},"2":{"LogID":"logId2","Caller":"caller2","Addr":"addr2","Client":"client2","TrafficEnv":{"Open":true,"Env":"env2"},"Extra":{"1a":"aaa2","2a":"bbb2","3a":"ccc2","4a":"ddd2"}}},"ListBase":[{"LogID":"logId","Caller":"caller","Addr":"addr","Client":"client","TrafficEnv":{"Env":"env"},"Extra":{"1a":"aaa","2a":"bbb","3a":"ccc","4a":"ddd"}},{"LogID":"logId2","Caller":"caller2","Addr":"addr2","Client":"client2","TrafficEnv":{"Open":true,"Env":"env2"},"Extra":{"1a":"aaa2","2a":"bbb2","3a":"ccc2","4a":"ddd2"}}],"ListString":["111","222","333","44","51","6"],"Base":{"LogID":"logId","Caller":"caller","Addr":"addr","Client":"client","TrafficEnv":{"Env":"env"},"Extra":{"1b":"aaa","2b":"bbb","3b":"ccc","4b":"ddd"}}}} \ No newline at end of file diff --git a/testdata/data/example3_pb.bin b/testdata/data/example3_pb.bin index 05392b51..c293f2f5 100644 --- a/testdata/data/example3_pb.bin +++ b/testdata/data/example3_pb.bin @@ -1,9 +1,9 @@ -hello{{1L6@: hello_innerB J +hello{{ {(1L6@: hello_innerB J m1aaaJ m2bbbJ m3cccJ -m4dddR bcccbdddbaaabbbbjr u32bbr u32ccr u32ddr u32aaz u64aaz u64bbz u64ccz u64dd 64ccc 64ddd 64aaa 64bbbTP +m4dddR baaabbbbbcccbdddjr u32aar u32bbr u32ccr u32ddz u64aaz u64bbz u64ccz u64dd 64aaa 64bbb 64ccc 64dddTP logIdcalleraddr"client*env2 1aaaa2 2abbb2 @@ -11,13 +11,13 @@ 4addd_[ logId2caller2addr2"client2*env22 -3accc22 +1aaaa22 -4addd22 +2abbb22 -1aaaa22 +3accc22 -2abbb2P +4addd2P logIdcalleraddr"client*env2 1aaaa2 2abbb2 @@ -34,10 +34,10 @@ 4addd2U 1P logIdcalleraddr"client*env2 +4addd2 1aaaa2 2abbb2 -3accc2 -4addd` +3accc` 2[ logId2caller2addr2"client2*env22 @@ -49,7 +49,7 @@ 4addd211122233344516P logIdcalleraddr"client*env2 -3bccc2 -4bddd2 1baaa2 -2bbbb \ No newline at end of file +2bbbb2 +3bccc2 +4bddd \ No newline at end of file diff --git a/testdata/idl/basic_example.proto b/testdata/idl/basic_example.proto new file mode 100644 index 00000000..9366ae56 --- /dev/null +++ b/testdata/idl/basic_example.proto @@ -0,0 +1,61 @@ +syntax = "proto3"; +package pb3; +option go_package = "pb/base"; + +message BasicExample { + int32 Int32 = 1; + int64 Int64 = 2; + uint32 Uint32 = 3; + uint64 Uint64 = 4; + sint32 Sint32 = 5; + sint64 Sint64 = 6; + sfixed32 Sfixed32 = 7; + sfixed64 Sfixed64 = 8; + fixed32 Fixed32 = 9; + fixed64 Fixed64 = 10; + float Float = 11; + double Double = 12; + bool Bool = 13; + string Str = 14; + bytes Bytes = 15; + repeated int32 ListInt32 = 16; + repeated int64 ListInt64 = 17; + repeated uint32 ListUint32 = 18; + repeated uint64 ListUint64 = 19; + repeated sint32 ListSint32 = 20; + repeated sint64 ListSint64 = 21; + repeated sfixed32 ListSfixed32 = 22; + repeated sfixed64 ListSfixed64 = 23; + repeated fixed32 ListFixed32 = 24; + repeated fixed64 ListFixed64 = 25; + repeated float ListFloat = 26; + repeated double ListDouble = 27; + repeated bool ListBool = 28; + repeated string ListString = 29; + repeated bytes ListBytes = 30; + map MapInt64SINT32 = 31; + map MapInt64Sfixed32 = 32; + map MapInt64Fixed32 = 33; + map MapInt64Uint32 = 34; + map MapInt64Double = 35; + map MapInt64Bool = 36; + map MapInt64String = 37; + map MapInt64Bytes = 38; + map MapInt64Float = 39; + map MapInt64Int32 = 40; + map MapstringSINT64 = 41; + map MapstringSfixed64 = 42; + map MapstringFixed64 = 43; + map MapstringUint64 = 44; + map MapstringDouble = 45; + map MapstringBool = 46; + map MapstringString = 47; + map MapstringBytes = 48; + map MapstringFloat = 49; + map MapstringInt64 = 50; +} + +// Test that RPC services work. +service BasicService { + rpc ExampleMethod(BasicExample) returns (BasicExample); +} \ No newline at end of file diff --git a/testdata/idl/example2.proto b/testdata/idl/example2.proto index a4fa54b8..8a0c11b0 100644 --- a/testdata/idl/example2.proto +++ b/testdata/idl/example2.proto @@ -20,12 +20,12 @@ message InnerBase2 { uint32 Uint32 = 2; uint64 Uint64 = 3; int32 Int32 = 4; - int64 Int64 = 5; + sint64 SInt64 = 5; double Double = 6; string String = 7; repeated int32 ListInt32 = 8; map MapStringString = 9; - repeated int32 SetInt32 = 10; + repeated sint64 ListSInt64 = 10; FOO Foo = 11; map MapInt32String = 12; bytes Binary = 13; diff --git a/testdata/idl/example3.proto b/testdata/idl/example3.proto new file mode 100644 index 00000000..2800e9a1 --- /dev/null +++ b/testdata/idl/example3.proto @@ -0,0 +1,164 @@ +// Copyright 2018 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Test Protobuf definitions with proto3 syntax. +syntax = "proto3"; + +package pb3; + +import "base.proto"; + +option go_package = "pb/example3"; + +enum FOO { + FOO_A = 0; +} + +message InnerBase2 { + bool Bool = 1; + uint32 Uint32 = 2; + uint64 Uint64 = 3; + int32 Int32 = 4; + int64 Int64 = 5; + double Double = 6; + string String = 7; + repeated int32 ListInt32 = 8; + map MapStringString = 9; + repeated int32 SetInt32 = 10; + FOO Foo = 11; + map MapInt32String = 12; + bytes Binary = 13; + map MapUint32String = 14; + map MapUint64String = 15; + map MapInt64String = 16; + map MapInt64Base = 17; + map MapStringBase = 20; + + repeated Base ListBase = 19; + repeated InnerBase2 ListInnerBase = 18; + repeated string ListString = 21; + sfixed32 Sfixed32 = 22; + fixed64 Fixed64 = 23; + sint32 Sint32 = 24; + sint64 Sint64 = 25; + repeated sint64 ListSInt64 = 26; + repeated sint32 ListSInt32 = 27; + repeated sfixed32 ListSfixed32 = 28; + repeated fixed64 ListFixed64 = 29; + map MapInt64Sfixed64 = 30; + map MapStringFixed32 = 31; + + + + Base Base = 255; +} + + +message InnerBasePartial { + bool Bool = 1; + repeated int32 ListInt32 = 8; + map MapStringString = 9; + map MapStringBase = 20; + repeated InnerBasePartial ListInnerBase = 18; + repeated BasePartial ListBase = 19; + + map MapStringString2 = 127; +} + +message BasePartial { + TrafficEnv TrafficEnv = 5; +} + + +message ExampleReq { + string Msg = 1; + int32 A = 2; + InnerBase2 InnerBase2 = 3; + Base Base = 255; + double Subfix = 32767; +} + + +message ExampleSuper { + string Msg = 1; + int32 A = 2; + InnerBase2 InnerBase2 = 3; + string Ex1 = 4; + string Ex2 = 5; + string Ex3 = 6; + string Ex4 = 7; + SelfRef SelfRef = 9; + Base Base = 255; + double Subfix = 32767; +} + +message SelfRef { + SelfRef self = 1; +} + +message ExampleReqPartial { + string Msg = 1; + InnerBasePartial InnerBase2 = 3; + BasePartial Base = 255; +} + + +message ExampleResp { + string Msg = 1; + string required_field = 2; + BaseResp BaseResp = 255; +} + +message ExampleRespPartial { + string required_field = 2; + BaseResp BaseResp = 255; +} + +message Exception { + int32 code = 1; + string msg = 255; +} + +message A { + A self = 1; +} + +message PingResponse { + string message = 1; +} + +message OnewayRequest { + string msg = 1; +} + +message VoidRequest { + string msg = 1; +} + +message VoidResponse { + +} + +message ExampleInt2Float { + int32 Int32 = 1; + double Float64 = 2; + string String = 3; + int64 Int64 = 4; + double Subfix = 32767; +} + + + +// Test that RPC services work. +service TestService2 { + rpc ExampleMethod(ExampleReq) returns (ExampleResp); + rpc ExamplePartialMethod(ExampleReqPartial) returns (A); + rpc ExamplePartialMethod2(ExampleReqPartial) returns (ExampleRespPartial); + rpc ExampleSuperMethod(ExampleSuper) returns (A); + rpc Int2FloatMethod(ExampleInt2Float) returns (ExampleInt2Float); + rpc Foo(A) returns (A); + rpc Ping(A) returns (PingResponse); + rpc Oneway(OnewayRequest) returns (VoidResponse); + rpc Void(VoidRequest) returns (VoidResponse); +} \ No newline at end of file diff --git a/testdata/kitex_gen/pb/base/base.pb.go b/testdata/kitex_gen/pb/base/base.pb.go index dd73bcef..ccb91c0d 100644 --- a/testdata/kitex_gen/pb/base/base.pb.go +++ b/testdata/kitex_gen/pb/base/base.pb.go @@ -7,8 +7,8 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.28.1 -// protoc v4.23.0 -// source: base.proto +// protoc v5.26.1 +// source: idl/base.proto package base @@ -39,7 +39,7 @@ type TrafficEnv struct { func (x *TrafficEnv) Reset() { *x = TrafficEnv{} if protoimpl.UnsafeEnabled { - mi := &file_base_proto_msgTypes[0] + mi := &file_idl_base_proto_msgTypes[0] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -52,7 +52,7 @@ func (x *TrafficEnv) String() string { func (*TrafficEnv) ProtoMessage() {} func (x *TrafficEnv) ProtoReflect() protoreflect.Message { - mi := &file_base_proto_msgTypes[0] + mi := &file_idl_base_proto_msgTypes[0] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -65,7 +65,7 @@ func (x *TrafficEnv) ProtoReflect() protoreflect.Message { // Deprecated: Use TrafficEnv.ProtoReflect.Descriptor instead. func (*TrafficEnv) Descriptor() ([]byte, []int) { - return file_base_proto_rawDescGZIP(), []int{0} + return file_idl_base_proto_rawDescGZIP(), []int{0} } func (x *TrafficEnv) GetOpen() bool { @@ -98,7 +98,7 @@ type Base struct { func (x *Base) Reset() { *x = Base{} if protoimpl.UnsafeEnabled { - mi := &file_base_proto_msgTypes[1] + mi := &file_idl_base_proto_msgTypes[1] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -111,7 +111,7 @@ func (x *Base) String() string { func (*Base) ProtoMessage() {} func (x *Base) ProtoReflect() protoreflect.Message { - mi := &file_base_proto_msgTypes[1] + mi := &file_idl_base_proto_msgTypes[1] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -124,7 +124,7 @@ func (x *Base) ProtoReflect() protoreflect.Message { // Deprecated: Use Base.ProtoReflect.Descriptor instead. func (*Base) Descriptor() ([]byte, []int) { - return file_base_proto_rawDescGZIP(), []int{1} + return file_idl_base_proto_rawDescGZIP(), []int{1} } func (x *Base) GetLogID() string { @@ -182,7 +182,7 @@ type BaseResp struct { func (x *BaseResp) Reset() { *x = BaseResp{} if protoimpl.UnsafeEnabled { - mi := &file_base_proto_msgTypes[2] + mi := &file_idl_base_proto_msgTypes[2] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -195,7 +195,7 @@ func (x *BaseResp) String() string { func (*BaseResp) ProtoMessage() {} func (x *BaseResp) ProtoReflect() protoreflect.Message { - mi := &file_base_proto_msgTypes[2] + mi := &file_idl_base_proto_msgTypes[2] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -208,7 +208,7 @@ func (x *BaseResp) ProtoReflect() protoreflect.Message { // Deprecated: Use BaseResp.ProtoReflect.Descriptor instead. func (*BaseResp) Descriptor() ([]byte, []int) { - return file_base_proto_rawDescGZIP(), []int{2} + return file_idl_base_proto_rawDescGZIP(), []int{2} } func (x *BaseResp) GetStatusMessage() string { @@ -232,70 +232,70 @@ func (x *BaseResp) GetExtra() map[string]string { return nil } -var File_base_proto protoreflect.FileDescriptor - -var file_base_proto_rawDesc = []byte{ - 0x0a, 0x0a, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x03, 0x70, 0x62, - 0x33, 0x22, 0x32, 0x0a, 0x0a, 0x54, 0x72, 0x61, 0x66, 0x66, 0x69, 0x63, 0x45, 0x6e, 0x76, 0x12, - 0x12, 0x0a, 0x04, 0x4f, 0x70, 0x65, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x04, 0x4f, - 0x70, 0x65, 0x6e, 0x12, 0x10, 0x0a, 0x03, 0x45, 0x6e, 0x76, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x03, 0x45, 0x6e, 0x76, 0x22, 0x8b, 0x02, 0x0a, 0x04, 0x42, 0x61, 0x73, 0x65, 0x12, 0x14, - 0x0a, 0x05, 0x4c, 0x6f, 0x67, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x4c, - 0x6f, 0x67, 0x49, 0x44, 0x12, 0x16, 0x0a, 0x06, 0x43, 0x61, 0x6c, 0x6c, 0x65, 0x72, 0x18, 0x02, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x43, 0x61, 0x6c, 0x6c, 0x65, 0x72, 0x12, 0x12, 0x0a, 0x04, - 0x41, 0x64, 0x64, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x41, 0x64, 0x64, 0x72, - 0x12, 0x16, 0x0a, 0x06, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x06, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x12, 0x34, 0x0a, 0x0a, 0x54, 0x72, 0x61, 0x66, - 0x66, 0x69, 0x63, 0x45, 0x6e, 0x76, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x70, - 0x62, 0x33, 0x2e, 0x54, 0x72, 0x61, 0x66, 0x66, 0x69, 0x63, 0x45, 0x6e, 0x76, 0x48, 0x00, 0x52, - 0x0a, 0x54, 0x72, 0x61, 0x66, 0x66, 0x69, 0x63, 0x45, 0x6e, 0x76, 0x88, 0x01, 0x01, 0x12, 0x2a, - 0x0a, 0x05, 0x45, 0x78, 0x74, 0x72, 0x61, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, - 0x70, 0x62, 0x33, 0x2e, 0x42, 0x61, 0x73, 0x65, 0x2e, 0x45, 0x78, 0x74, 0x72, 0x61, 0x45, 0x6e, +var File_idl_base_proto protoreflect.FileDescriptor + +var file_idl_base_proto_rawDesc = []byte{ + 0x0a, 0x0e, 0x69, 0x64, 0x6c, 0x2f, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x12, 0x03, 0x70, 0x62, 0x33, 0x22, 0x32, 0x0a, 0x0a, 0x54, 0x72, 0x61, 0x66, 0x66, 0x69, 0x63, + 0x45, 0x6e, 0x76, 0x12, 0x12, 0x0a, 0x04, 0x4f, 0x70, 0x65, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x08, 0x52, 0x04, 0x4f, 0x70, 0x65, 0x6e, 0x12, 0x10, 0x0a, 0x03, 0x45, 0x6e, 0x76, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x45, 0x6e, 0x76, 0x22, 0x8b, 0x02, 0x0a, 0x04, 0x42, 0x61, + 0x73, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x4c, 0x6f, 0x67, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x05, 0x4c, 0x6f, 0x67, 0x49, 0x44, 0x12, 0x16, 0x0a, 0x06, 0x43, 0x61, 0x6c, 0x6c, + 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x43, 0x61, 0x6c, 0x6c, 0x65, 0x72, + 0x12, 0x12, 0x0a, 0x04, 0x41, 0x64, 0x64, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, + 0x41, 0x64, 0x64, 0x72, 0x12, 0x16, 0x0a, 0x06, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x18, 0x04, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x12, 0x34, 0x0a, 0x0a, + 0x54, 0x72, 0x61, 0x66, 0x66, 0x69, 0x63, 0x45, 0x6e, 0x76, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x0f, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x54, 0x72, 0x61, 0x66, 0x66, 0x69, 0x63, 0x45, 0x6e, + 0x76, 0x48, 0x00, 0x52, 0x0a, 0x54, 0x72, 0x61, 0x66, 0x66, 0x69, 0x63, 0x45, 0x6e, 0x76, 0x88, + 0x01, 0x01, 0x12, 0x2a, 0x0a, 0x05, 0x45, 0x78, 0x74, 0x72, 0x61, 0x18, 0x06, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x14, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x42, 0x61, 0x73, 0x65, 0x2e, 0x45, 0x78, 0x74, + 0x72, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x05, 0x45, 0x78, 0x74, 0x72, 0x61, 0x1a, 0x38, + 0x0a, 0x0a, 0x45, 0x78, 0x74, 0x72, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, + 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, + 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x42, 0x0d, 0x0a, 0x0b, 0x5f, 0x54, 0x72, 0x61, + 0x66, 0x66, 0x69, 0x63, 0x45, 0x6e, 0x76, 0x22, 0xba, 0x01, 0x0a, 0x08, 0x42, 0x61, 0x73, 0x65, + 0x52, 0x65, 0x73, 0x70, 0x12, 0x24, 0x0a, 0x0d, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x4d, 0x65, + 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x53, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x1e, 0x0a, 0x0a, 0x53, 0x74, + 0x61, 0x74, 0x75, 0x73, 0x43, 0x6f, 0x64, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, + 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x43, 0x6f, 0x64, 0x65, 0x12, 0x2e, 0x0a, 0x05, 0x45, 0x78, + 0x74, 0x72, 0x61, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x70, 0x62, 0x33, 0x2e, + 0x42, 0x61, 0x73, 0x65, 0x52, 0x65, 0x73, 0x70, 0x2e, 0x45, 0x78, 0x74, 0x72, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x05, 0x45, 0x78, 0x74, 0x72, 0x61, 0x1a, 0x38, 0x0a, 0x0a, 0x45, 0x78, 0x74, 0x72, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, - 0x3a, 0x02, 0x38, 0x01, 0x42, 0x0d, 0x0a, 0x0b, 0x5f, 0x54, 0x72, 0x61, 0x66, 0x66, 0x69, 0x63, - 0x45, 0x6e, 0x76, 0x22, 0xba, 0x01, 0x0a, 0x08, 0x42, 0x61, 0x73, 0x65, 0x52, 0x65, 0x73, 0x70, - 0x12, 0x24, 0x0a, 0x0d, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, - 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x4d, - 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x1e, 0x0a, 0x0a, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, - 0x43, 0x6f, 0x64, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x53, 0x74, 0x61, 0x74, - 0x75, 0x73, 0x43, 0x6f, 0x64, 0x65, 0x12, 0x2e, 0x0a, 0x05, 0x45, 0x78, 0x74, 0x72, 0x61, 0x18, - 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x42, 0x61, 0x73, 0x65, - 0x52, 0x65, 0x73, 0x70, 0x2e, 0x45, 0x78, 0x74, 0x72, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, - 0x05, 0x45, 0x78, 0x74, 0x72, 0x61, 0x1a, 0x38, 0x0a, 0x0a, 0x45, 0x78, 0x74, 0x72, 0x61, 0x45, - 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, - 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, - 0x42, 0x3b, 0x5a, 0x39, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x63, - 0x6c, 0x6f, 0x75, 0x64, 0x77, 0x65, 0x67, 0x6f, 0x2f, 0x64, 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63, - 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x6b, 0x69, 0x74, 0x65, - 0x78, 0x5f, 0x67, 0x65, 0x6e, 0x2f, 0x70, 0x62, 0x2f, 0x62, 0x61, 0x73, 0x65, 0x62, 0x06, 0x70, - 0x72, 0x6f, 0x74, 0x6f, 0x33, + 0x3a, 0x02, 0x38, 0x01, 0x42, 0x3b, 0x5a, 0x39, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, + 0x6f, 0x6d, 0x2f, 0x63, 0x6c, 0x6f, 0x75, 0x64, 0x77, 0x65, 0x67, 0x6f, 0x2f, 0x64, 0x79, 0x6e, + 0x61, 0x6d, 0x69, 0x63, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, + 0x6b, 0x69, 0x74, 0x65, 0x78, 0x5f, 0x67, 0x65, 0x6e, 0x2f, 0x70, 0x62, 0x2f, 0x62, 0x61, 0x73, + 0x65, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, } var ( - file_base_proto_rawDescOnce sync.Once - file_base_proto_rawDescData = file_base_proto_rawDesc + file_idl_base_proto_rawDescOnce sync.Once + file_idl_base_proto_rawDescData = file_idl_base_proto_rawDesc ) -func file_base_proto_rawDescGZIP() []byte { - file_base_proto_rawDescOnce.Do(func() { - file_base_proto_rawDescData = protoimpl.X.CompressGZIP(file_base_proto_rawDescData) +func file_idl_base_proto_rawDescGZIP() []byte { + file_idl_base_proto_rawDescOnce.Do(func() { + file_idl_base_proto_rawDescData = protoimpl.X.CompressGZIP(file_idl_base_proto_rawDescData) }) - return file_base_proto_rawDescData + return file_idl_base_proto_rawDescData } -var file_base_proto_msgTypes = make([]protoimpl.MessageInfo, 5) -var file_base_proto_goTypes = []interface{}{ +var file_idl_base_proto_msgTypes = make([]protoimpl.MessageInfo, 5) +var file_idl_base_proto_goTypes = []interface{}{ (*TrafficEnv)(nil), // 0: pb3.TrafficEnv (*Base)(nil), // 1: pb3.Base (*BaseResp)(nil), // 2: pb3.BaseResp nil, // 3: pb3.Base.ExtraEntry nil, // 4: pb3.BaseResp.ExtraEntry } -var file_base_proto_depIdxs = []int32{ +var file_idl_base_proto_depIdxs = []int32{ 0, // 0: pb3.Base.TrafficEnv:type_name -> pb3.TrafficEnv 3, // 1: pb3.Base.Extra:type_name -> pb3.Base.ExtraEntry 4, // 2: pb3.BaseResp.Extra:type_name -> pb3.BaseResp.ExtraEntry @@ -306,13 +306,13 @@ var file_base_proto_depIdxs = []int32{ 0, // [0:3] is the sub-list for field type_name } -func init() { file_base_proto_init() } -func file_base_proto_init() { - if File_base_proto != nil { +func init() { file_idl_base_proto_init() } +func file_idl_base_proto_init() { + if File_idl_base_proto != nil { return } if !protoimpl.UnsafeEnabled { - file_base_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + file_idl_base_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*TrafficEnv); i { case 0: return &v.state @@ -324,7 +324,7 @@ func file_base_proto_init() { return nil } } - file_base_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + file_idl_base_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*Base); i { case 0: return &v.state @@ -336,7 +336,7 @@ func file_base_proto_init() { return nil } } - file_base_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + file_idl_base_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*BaseResp); i { case 0: return &v.state @@ -349,25 +349,25 @@ func file_base_proto_init() { } } } - file_base_proto_msgTypes[1].OneofWrappers = []interface{}{} + file_idl_base_proto_msgTypes[1].OneofWrappers = []interface{}{} type x struct{} out := protoimpl.TypeBuilder{ File: protoimpl.DescBuilder{ GoPackagePath: reflect.TypeOf(x{}).PkgPath(), - RawDescriptor: file_base_proto_rawDesc, + RawDescriptor: file_idl_base_proto_rawDesc, NumEnums: 0, NumMessages: 5, NumExtensions: 0, NumServices: 0, }, - GoTypes: file_base_proto_goTypes, - DependencyIndexes: file_base_proto_depIdxs, - MessageInfos: file_base_proto_msgTypes, + GoTypes: file_idl_base_proto_goTypes, + DependencyIndexes: file_idl_base_proto_depIdxs, + MessageInfos: file_idl_base_proto_msgTypes, }.Build() - File_base_proto = out.File - file_base_proto_rawDesc = nil - file_base_proto_goTypes = nil - file_base_proto_depIdxs = nil + File_idl_base_proto = out.File + file_idl_base_proto_rawDesc = nil + file_idl_base_proto_goTypes = nil + file_idl_base_proto_depIdxs = nil } var _ context.Context diff --git a/testdata/kitex_gen/pb/base/basic_example.pb.fast.go b/testdata/kitex_gen/pb/base/basic_example.pb.fast.go new file mode 100644 index 00000000..7c9c3fc8 --- /dev/null +++ b/testdata/kitex_gen/pb/base/basic_example.pb.fast.go @@ -0,0 +1,2420 @@ +// Code generated by Fastpb v0.0.2. DO NOT EDIT. + +package base + +import ( + fmt "fmt" + fastpb "github.com/cloudwego/fastpb" +) + +var ( + _ = fmt.Errorf + _ = fastpb.Skip +) + +func (x *BasicExample) FastRead(buf []byte, _type int8, number int32) (offset int, err error) { + switch number { + case 1: + offset, err = x.fastReadField1(buf, _type) + if err != nil { + goto ReadFieldError + } + case 2: + offset, err = x.fastReadField2(buf, _type) + if err != nil { + goto ReadFieldError + } + case 3: + offset, err = x.fastReadField3(buf, _type) + if err != nil { + goto ReadFieldError + } + case 4: + offset, err = x.fastReadField4(buf, _type) + if err != nil { + goto ReadFieldError + } + case 5: + offset, err = x.fastReadField5(buf, _type) + if err != nil { + goto ReadFieldError + } + case 6: + offset, err = x.fastReadField6(buf, _type) + if err != nil { + goto ReadFieldError + } + case 7: + offset, err = x.fastReadField7(buf, _type) + if err != nil { + goto ReadFieldError + } + case 8: + offset, err = x.fastReadField8(buf, _type) + if err != nil { + goto ReadFieldError + } + case 9: + offset, err = x.fastReadField9(buf, _type) + if err != nil { + goto ReadFieldError + } + case 10: + offset, err = x.fastReadField10(buf, _type) + if err != nil { + goto ReadFieldError + } + case 11: + offset, err = x.fastReadField11(buf, _type) + if err != nil { + goto ReadFieldError + } + case 12: + offset, err = x.fastReadField12(buf, _type) + if err != nil { + goto ReadFieldError + } + case 13: + offset, err = x.fastReadField13(buf, _type) + if err != nil { + goto ReadFieldError + } + case 14: + offset, err = x.fastReadField14(buf, _type) + if err != nil { + goto ReadFieldError + } + case 15: + offset, err = x.fastReadField15(buf, _type) + if err != nil { + goto ReadFieldError + } + case 16: + offset, err = x.fastReadField16(buf, _type) + if err != nil { + goto ReadFieldError + } + case 17: + offset, err = x.fastReadField17(buf, _type) + if err != nil { + goto ReadFieldError + } + case 18: + offset, err = x.fastReadField18(buf, _type) + if err != nil { + goto ReadFieldError + } + case 19: + offset, err = x.fastReadField19(buf, _type) + if err != nil { + goto ReadFieldError + } + case 20: + offset, err = x.fastReadField20(buf, _type) + if err != nil { + goto ReadFieldError + } + case 21: + offset, err = x.fastReadField21(buf, _type) + if err != nil { + goto ReadFieldError + } + case 22: + offset, err = x.fastReadField22(buf, _type) + if err != nil { + goto ReadFieldError + } + case 23: + offset, err = x.fastReadField23(buf, _type) + if err != nil { + goto ReadFieldError + } + case 24: + offset, err = x.fastReadField24(buf, _type) + if err != nil { + goto ReadFieldError + } + case 25: + offset, err = x.fastReadField25(buf, _type) + if err != nil { + goto ReadFieldError + } + case 26: + offset, err = x.fastReadField26(buf, _type) + if err != nil { + goto ReadFieldError + } + case 27: + offset, err = x.fastReadField27(buf, _type) + if err != nil { + goto ReadFieldError + } + case 28: + offset, err = x.fastReadField28(buf, _type) + if err != nil { + goto ReadFieldError + } + case 29: + offset, err = x.fastReadField29(buf, _type) + if err != nil { + goto ReadFieldError + } + case 30: + offset, err = x.fastReadField30(buf, _type) + if err != nil { + goto ReadFieldError + } + case 31: + offset, err = x.fastReadField31(buf, _type) + if err != nil { + goto ReadFieldError + } + case 32: + offset, err = x.fastReadField32(buf, _type) + if err != nil { + goto ReadFieldError + } + case 33: + offset, err = x.fastReadField33(buf, _type) + if err != nil { + goto ReadFieldError + } + case 34: + offset, err = x.fastReadField34(buf, _type) + if err != nil { + goto ReadFieldError + } + case 35: + offset, err = x.fastReadField35(buf, _type) + if err != nil { + goto ReadFieldError + } + case 36: + offset, err = x.fastReadField36(buf, _type) + if err != nil { + goto ReadFieldError + } + case 37: + offset, err = x.fastReadField37(buf, _type) + if err != nil { + goto ReadFieldError + } + case 38: + offset, err = x.fastReadField38(buf, _type) + if err != nil { + goto ReadFieldError + } + case 39: + offset, err = x.fastReadField39(buf, _type) + if err != nil { + goto ReadFieldError + } + case 40: + offset, err = x.fastReadField40(buf, _type) + if err != nil { + goto ReadFieldError + } + case 41: + offset, err = x.fastReadField41(buf, _type) + if err != nil { + goto ReadFieldError + } + case 42: + offset, err = x.fastReadField42(buf, _type) + if err != nil { + goto ReadFieldError + } + case 43: + offset, err = x.fastReadField43(buf, _type) + if err != nil { + goto ReadFieldError + } + case 44: + offset, err = x.fastReadField44(buf, _type) + if err != nil { + goto ReadFieldError + } + case 45: + offset, err = x.fastReadField45(buf, _type) + if err != nil { + goto ReadFieldError + } + case 46: + offset, err = x.fastReadField46(buf, _type) + if err != nil { + goto ReadFieldError + } + case 47: + offset, err = x.fastReadField47(buf, _type) + if err != nil { + goto ReadFieldError + } + case 48: + offset, err = x.fastReadField48(buf, _type) + if err != nil { + goto ReadFieldError + } + case 49: + offset, err = x.fastReadField49(buf, _type) + if err != nil { + goto ReadFieldError + } + case 50: + offset, err = x.fastReadField50(buf, _type) + if err != nil { + goto ReadFieldError + } + default: + offset, err = fastpb.Skip(buf, _type, number) + if err != nil { + goto SkipFieldError + } + } + return offset, nil +SkipFieldError: + return offset, fmt.Errorf("%T cannot parse invalid wire-format data, error: %s", x, err) +ReadFieldError: + return offset, fmt.Errorf("%T read field %d '%s' error: %s", x, number, fieldIDToName_BasicExample[number], err) +} + +func (x *BasicExample) fastReadField1(buf []byte, _type int8) (offset int, err error) { + x.Int32, offset, err = fastpb.ReadInt32(buf, _type) + return offset, err +} + +func (x *BasicExample) fastReadField2(buf []byte, _type int8) (offset int, err error) { + x.Int64, offset, err = fastpb.ReadInt64(buf, _type) + return offset, err +} + +func (x *BasicExample) fastReadField3(buf []byte, _type int8) (offset int, err error) { + x.Uint32, offset, err = fastpb.ReadUint32(buf, _type) + return offset, err +} + +func (x *BasicExample) fastReadField4(buf []byte, _type int8) (offset int, err error) { + x.Uint64, offset, err = fastpb.ReadUint64(buf, _type) + return offset, err +} + +func (x *BasicExample) fastReadField5(buf []byte, _type int8) (offset int, err error) { + x.Sint32, offset, err = fastpb.ReadSint32(buf, _type) + return offset, err +} + +func (x *BasicExample) fastReadField6(buf []byte, _type int8) (offset int, err error) { + x.Sint64, offset, err = fastpb.ReadSint64(buf, _type) + return offset, err +} + +func (x *BasicExample) fastReadField7(buf []byte, _type int8) (offset int, err error) { + x.Sfixed32, offset, err = fastpb.ReadSfixed32(buf, _type) + return offset, err +} + +func (x *BasicExample) fastReadField8(buf []byte, _type int8) (offset int, err error) { + x.Sfixed64, offset, err = fastpb.ReadSfixed64(buf, _type) + return offset, err +} + +func (x *BasicExample) fastReadField9(buf []byte, _type int8) (offset int, err error) { + x.Fixed32, offset, err = fastpb.ReadFixed32(buf, _type) + return offset, err +} + +func (x *BasicExample) fastReadField10(buf []byte, _type int8) (offset int, err error) { + x.Fixed64, offset, err = fastpb.ReadFixed64(buf, _type) + return offset, err +} + +func (x *BasicExample) fastReadField11(buf []byte, _type int8) (offset int, err error) { + x.Float, offset, err = fastpb.ReadFloat(buf, _type) + return offset, err +} + +func (x *BasicExample) fastReadField12(buf []byte, _type int8) (offset int, err error) { + x.Double, offset, err = fastpb.ReadDouble(buf, _type) + return offset, err +} + +func (x *BasicExample) fastReadField13(buf []byte, _type int8) (offset int, err error) { + x.Bool, offset, err = fastpb.ReadBool(buf, _type) + return offset, err +} + +func (x *BasicExample) fastReadField14(buf []byte, _type int8) (offset int, err error) { + x.Str, offset, err = fastpb.ReadString(buf, _type) + return offset, err +} + +func (x *BasicExample) fastReadField15(buf []byte, _type int8) (offset int, err error) { + x.Bytes, offset, err = fastpb.ReadBytes(buf, _type) + return offset, err +} + +func (x *BasicExample) fastReadField16(buf []byte, _type int8) (offset int, err error) { + offset, err = fastpb.ReadList(buf, _type, + func(buf []byte, _type int8) (n int, err error) { + var v int32 + v, offset, err = fastpb.ReadInt32(buf, _type) + if err != nil { + return offset, err + } + x.ListInt32 = append(x.ListInt32, v) + return offset, err + }) + return offset, err +} + +func (x *BasicExample) fastReadField17(buf []byte, _type int8) (offset int, err error) { + offset, err = fastpb.ReadList(buf, _type, + func(buf []byte, _type int8) (n int, err error) { + var v int64 + v, offset, err = fastpb.ReadInt64(buf, _type) + if err != nil { + return offset, err + } + x.ListInt64 = append(x.ListInt64, v) + return offset, err + }) + return offset, err +} + +func (x *BasicExample) fastReadField18(buf []byte, _type int8) (offset int, err error) { + offset, err = fastpb.ReadList(buf, _type, + func(buf []byte, _type int8) (n int, err error) { + var v uint32 + v, offset, err = fastpb.ReadUint32(buf, _type) + if err != nil { + return offset, err + } + x.ListUint32 = append(x.ListUint32, v) + return offset, err + }) + return offset, err +} + +func (x *BasicExample) fastReadField19(buf []byte, _type int8) (offset int, err error) { + offset, err = fastpb.ReadList(buf, _type, + func(buf []byte, _type int8) (n int, err error) { + var v uint64 + v, offset, err = fastpb.ReadUint64(buf, _type) + if err != nil { + return offset, err + } + x.ListUint64 = append(x.ListUint64, v) + return offset, err + }) + return offset, err +} + +func (x *BasicExample) fastReadField20(buf []byte, _type int8) (offset int, err error) { + offset, err = fastpb.ReadList(buf, _type, + func(buf []byte, _type int8) (n int, err error) { + var v int32 + v, offset, err = fastpb.ReadSint32(buf, _type) + if err != nil { + return offset, err + } + x.ListSint32 = append(x.ListSint32, v) + return offset, err + }) + return offset, err +} + +func (x *BasicExample) fastReadField21(buf []byte, _type int8) (offset int, err error) { + offset, err = fastpb.ReadList(buf, _type, + func(buf []byte, _type int8) (n int, err error) { + var v int64 + v, offset, err = fastpb.ReadSint64(buf, _type) + if err != nil { + return offset, err + } + x.ListSint64 = append(x.ListSint64, v) + return offset, err + }) + return offset, err +} + +func (x *BasicExample) fastReadField22(buf []byte, _type int8) (offset int, err error) { + offset, err = fastpb.ReadList(buf, _type, + func(buf []byte, _type int8) (n int, err error) { + var v int32 + v, offset, err = fastpb.ReadSfixed32(buf, _type) + if err != nil { + return offset, err + } + x.ListSfixed32 = append(x.ListSfixed32, v) + return offset, err + }) + return offset, err +} + +func (x *BasicExample) fastReadField23(buf []byte, _type int8) (offset int, err error) { + offset, err = fastpb.ReadList(buf, _type, + func(buf []byte, _type int8) (n int, err error) { + var v int64 + v, offset, err = fastpb.ReadSfixed64(buf, _type) + if err != nil { + return offset, err + } + x.ListSfixed64 = append(x.ListSfixed64, v) + return offset, err + }) + return offset, err +} + +func (x *BasicExample) fastReadField24(buf []byte, _type int8) (offset int, err error) { + offset, err = fastpb.ReadList(buf, _type, + func(buf []byte, _type int8) (n int, err error) { + var v uint32 + v, offset, err = fastpb.ReadFixed32(buf, _type) + if err != nil { + return offset, err + } + x.ListFixed32 = append(x.ListFixed32, v) + return offset, err + }) + return offset, err +} + +func (x *BasicExample) fastReadField25(buf []byte, _type int8) (offset int, err error) { + offset, err = fastpb.ReadList(buf, _type, + func(buf []byte, _type int8) (n int, err error) { + var v uint64 + v, offset, err = fastpb.ReadFixed64(buf, _type) + if err != nil { + return offset, err + } + x.ListFixed64 = append(x.ListFixed64, v) + return offset, err + }) + return offset, err +} + +func (x *BasicExample) fastReadField26(buf []byte, _type int8) (offset int, err error) { + offset, err = fastpb.ReadList(buf, _type, + func(buf []byte, _type int8) (n int, err error) { + var v float32 + v, offset, err = fastpb.ReadFloat(buf, _type) + if err != nil { + return offset, err + } + x.ListFloat = append(x.ListFloat, v) + return offset, err + }) + return offset, err +} + +func (x *BasicExample) fastReadField27(buf []byte, _type int8) (offset int, err error) { + offset, err = fastpb.ReadList(buf, _type, + func(buf []byte, _type int8) (n int, err error) { + var v float64 + v, offset, err = fastpb.ReadDouble(buf, _type) + if err != nil { + return offset, err + } + x.ListDouble = append(x.ListDouble, v) + return offset, err + }) + return offset, err +} + +func (x *BasicExample) fastReadField28(buf []byte, _type int8) (offset int, err error) { + offset, err = fastpb.ReadList(buf, _type, + func(buf []byte, _type int8) (n int, err error) { + var v bool + v, offset, err = fastpb.ReadBool(buf, _type) + if err != nil { + return offset, err + } + x.ListBool = append(x.ListBool, v) + return offset, err + }) + return offset, err +} + +func (x *BasicExample) fastReadField29(buf []byte, _type int8) (offset int, err error) { + var v string + v, offset, err = fastpb.ReadString(buf, _type) + if err != nil { + return offset, err + } + x.ListString = append(x.ListString, v) + return offset, err +} + +func (x *BasicExample) fastReadField30(buf []byte, _type int8) (offset int, err error) { + var v []byte + v, offset, err = fastpb.ReadBytes(buf, _type) + if err != nil { + return offset, err + } + x.ListBytes = append(x.ListBytes, v) + return offset, err +} + +func (x *BasicExample) fastReadField31(buf []byte, _type int8) (offset int, err error) { + if x.MapInt64SINT32 == nil { + x.MapInt64SINT32 = make(map[int64]int32) + } + var key int64 + var value int32 + offset, err = fastpb.ReadMapEntry(buf, _type, + func(buf []byte, _type int8) (offset int, err error) { + key, offset, err = fastpb.ReadInt64(buf, _type) + return offset, err + }, + func(buf []byte, _type int8) (offset int, err error) { + value, offset, err = fastpb.ReadSint32(buf, _type) + return offset, err + }) + if err != nil { + return offset, err + } + x.MapInt64SINT32[key] = value + return offset, nil +} + +func (x *BasicExample) fastReadField32(buf []byte, _type int8) (offset int, err error) { + if x.MapInt64Sfixed32 == nil { + x.MapInt64Sfixed32 = make(map[int64]int32) + } + var key int64 + var value int32 + offset, err = fastpb.ReadMapEntry(buf, _type, + func(buf []byte, _type int8) (offset int, err error) { + key, offset, err = fastpb.ReadInt64(buf, _type) + return offset, err + }, + func(buf []byte, _type int8) (offset int, err error) { + value, offset, err = fastpb.ReadSfixed32(buf, _type) + return offset, err + }) + if err != nil { + return offset, err + } + x.MapInt64Sfixed32[key] = value + return offset, nil +} + +func (x *BasicExample) fastReadField33(buf []byte, _type int8) (offset int, err error) { + if x.MapInt64Fixed32 == nil { + x.MapInt64Fixed32 = make(map[int64]uint32) + } + var key int64 + var value uint32 + offset, err = fastpb.ReadMapEntry(buf, _type, + func(buf []byte, _type int8) (offset int, err error) { + key, offset, err = fastpb.ReadInt64(buf, _type) + return offset, err + }, + func(buf []byte, _type int8) (offset int, err error) { + value, offset, err = fastpb.ReadFixed32(buf, _type) + return offset, err + }) + if err != nil { + return offset, err + } + x.MapInt64Fixed32[key] = value + return offset, nil +} + +func (x *BasicExample) fastReadField34(buf []byte, _type int8) (offset int, err error) { + if x.MapInt64Uint32 == nil { + x.MapInt64Uint32 = make(map[int64]uint32) + } + var key int64 + var value uint32 + offset, err = fastpb.ReadMapEntry(buf, _type, + func(buf []byte, _type int8) (offset int, err error) { + key, offset, err = fastpb.ReadInt64(buf, _type) + return offset, err + }, + func(buf []byte, _type int8) (offset int, err error) { + value, offset, err = fastpb.ReadUint32(buf, _type) + return offset, err + }) + if err != nil { + return offset, err + } + x.MapInt64Uint32[key] = value + return offset, nil +} + +func (x *BasicExample) fastReadField35(buf []byte, _type int8) (offset int, err error) { + if x.MapInt64Double == nil { + x.MapInt64Double = make(map[int64]float64) + } + var key int64 + var value float64 + offset, err = fastpb.ReadMapEntry(buf, _type, + func(buf []byte, _type int8) (offset int, err error) { + key, offset, err = fastpb.ReadInt64(buf, _type) + return offset, err + }, + func(buf []byte, _type int8) (offset int, err error) { + value, offset, err = fastpb.ReadDouble(buf, _type) + return offset, err + }) + if err != nil { + return offset, err + } + x.MapInt64Double[key] = value + return offset, nil +} + +func (x *BasicExample) fastReadField36(buf []byte, _type int8) (offset int, err error) { + if x.MapInt64Bool == nil { + x.MapInt64Bool = make(map[int64]bool) + } + var key int64 + var value bool + offset, err = fastpb.ReadMapEntry(buf, _type, + func(buf []byte, _type int8) (offset int, err error) { + key, offset, err = fastpb.ReadInt64(buf, _type) + return offset, err + }, + func(buf []byte, _type int8) (offset int, err error) { + value, offset, err = fastpb.ReadBool(buf, _type) + return offset, err + }) + if err != nil { + return offset, err + } + x.MapInt64Bool[key] = value + return offset, nil +} + +func (x *BasicExample) fastReadField37(buf []byte, _type int8) (offset int, err error) { + if x.MapInt64String == nil { + x.MapInt64String = make(map[int64]string) + } + var key int64 + var value string + offset, err = fastpb.ReadMapEntry(buf, _type, + func(buf []byte, _type int8) (offset int, err error) { + key, offset, err = fastpb.ReadInt64(buf, _type) + return offset, err + }, + func(buf []byte, _type int8) (offset int, err error) { + value, offset, err = fastpb.ReadString(buf, _type) + return offset, err + }) + if err != nil { + return offset, err + } + x.MapInt64String[key] = value + return offset, nil +} + +func (x *BasicExample) fastReadField38(buf []byte, _type int8) (offset int, err error) { + if x.MapInt64Bytes == nil { + x.MapInt64Bytes = make(map[int64][]byte) + } + var key int64 + var value []byte + offset, err = fastpb.ReadMapEntry(buf, _type, + func(buf []byte, _type int8) (offset int, err error) { + key, offset, err = fastpb.ReadInt64(buf, _type) + return offset, err + }, + func(buf []byte, _type int8) (offset int, err error) { + value, offset, err = fastpb.ReadBytes(buf, _type) + return offset, err + }) + if err != nil { + return offset, err + } + x.MapInt64Bytes[key] = value + return offset, nil +} + +func (x *BasicExample) fastReadField39(buf []byte, _type int8) (offset int, err error) { + if x.MapInt64Float == nil { + x.MapInt64Float = make(map[int64]float32) + } + var key int64 + var value float32 + offset, err = fastpb.ReadMapEntry(buf, _type, + func(buf []byte, _type int8) (offset int, err error) { + key, offset, err = fastpb.ReadInt64(buf, _type) + return offset, err + }, + func(buf []byte, _type int8) (offset int, err error) { + value, offset, err = fastpb.ReadFloat(buf, _type) + return offset, err + }) + if err != nil { + return offset, err + } + x.MapInt64Float[key] = value + return offset, nil +} + +func (x *BasicExample) fastReadField40(buf []byte, _type int8) (offset int, err error) { + if x.MapInt64Int32 == nil { + x.MapInt64Int32 = make(map[int64]int32) + } + var key int64 + var value int32 + offset, err = fastpb.ReadMapEntry(buf, _type, + func(buf []byte, _type int8) (offset int, err error) { + key, offset, err = fastpb.ReadInt64(buf, _type) + return offset, err + }, + func(buf []byte, _type int8) (offset int, err error) { + value, offset, err = fastpb.ReadInt32(buf, _type) + return offset, err + }) + if err != nil { + return offset, err + } + x.MapInt64Int32[key] = value + return offset, nil +} + +func (x *BasicExample) fastReadField41(buf []byte, _type int8) (offset int, err error) { + if x.MapstringSINT64 == nil { + x.MapstringSINT64 = make(map[string]int64) + } + var key string + var value int64 + offset, err = fastpb.ReadMapEntry(buf, _type, + func(buf []byte, _type int8) (offset int, err error) { + key, offset, err = fastpb.ReadString(buf, _type) + return offset, err + }, + func(buf []byte, _type int8) (offset int, err error) { + value, offset, err = fastpb.ReadSint64(buf, _type) + return offset, err + }) + if err != nil { + return offset, err + } + x.MapstringSINT64[key] = value + return offset, nil +} + +func (x *BasicExample) fastReadField42(buf []byte, _type int8) (offset int, err error) { + if x.MapstringSfixed64 == nil { + x.MapstringSfixed64 = make(map[string]int64) + } + var key string + var value int64 + offset, err = fastpb.ReadMapEntry(buf, _type, + func(buf []byte, _type int8) (offset int, err error) { + key, offset, err = fastpb.ReadString(buf, _type) + return offset, err + }, + func(buf []byte, _type int8) (offset int, err error) { + value, offset, err = fastpb.ReadSfixed64(buf, _type) + return offset, err + }) + if err != nil { + return offset, err + } + x.MapstringSfixed64[key] = value + return offset, nil +} + +func (x *BasicExample) fastReadField43(buf []byte, _type int8) (offset int, err error) { + if x.MapstringFixed64 == nil { + x.MapstringFixed64 = make(map[string]uint64) + } + var key string + var value uint64 + offset, err = fastpb.ReadMapEntry(buf, _type, + func(buf []byte, _type int8) (offset int, err error) { + key, offset, err = fastpb.ReadString(buf, _type) + return offset, err + }, + func(buf []byte, _type int8) (offset int, err error) { + value, offset, err = fastpb.ReadFixed64(buf, _type) + return offset, err + }) + if err != nil { + return offset, err + } + x.MapstringFixed64[key] = value + return offset, nil +} + +func (x *BasicExample) fastReadField44(buf []byte, _type int8) (offset int, err error) { + if x.MapstringUint64 == nil { + x.MapstringUint64 = make(map[string]uint64) + } + var key string + var value uint64 + offset, err = fastpb.ReadMapEntry(buf, _type, + func(buf []byte, _type int8) (offset int, err error) { + key, offset, err = fastpb.ReadString(buf, _type) + return offset, err + }, + func(buf []byte, _type int8) (offset int, err error) { + value, offset, err = fastpb.ReadUint64(buf, _type) + return offset, err + }) + if err != nil { + return offset, err + } + x.MapstringUint64[key] = value + return offset, nil +} + +func (x *BasicExample) fastReadField45(buf []byte, _type int8) (offset int, err error) { + if x.MapstringDouble == nil { + x.MapstringDouble = make(map[string]float64) + } + var key string + var value float64 + offset, err = fastpb.ReadMapEntry(buf, _type, + func(buf []byte, _type int8) (offset int, err error) { + key, offset, err = fastpb.ReadString(buf, _type) + return offset, err + }, + func(buf []byte, _type int8) (offset int, err error) { + value, offset, err = fastpb.ReadDouble(buf, _type) + return offset, err + }) + if err != nil { + return offset, err + } + x.MapstringDouble[key] = value + return offset, nil +} + +func (x *BasicExample) fastReadField46(buf []byte, _type int8) (offset int, err error) { + if x.MapstringBool == nil { + x.MapstringBool = make(map[string]bool) + } + var key string + var value bool + offset, err = fastpb.ReadMapEntry(buf, _type, + func(buf []byte, _type int8) (offset int, err error) { + key, offset, err = fastpb.ReadString(buf, _type) + return offset, err + }, + func(buf []byte, _type int8) (offset int, err error) { + value, offset, err = fastpb.ReadBool(buf, _type) + return offset, err + }) + if err != nil { + return offset, err + } + x.MapstringBool[key] = value + return offset, nil +} + +func (x *BasicExample) fastReadField47(buf []byte, _type int8) (offset int, err error) { + if x.MapstringString == nil { + x.MapstringString = make(map[string]string) + } + var key string + var value string + offset, err = fastpb.ReadMapEntry(buf, _type, + func(buf []byte, _type int8) (offset int, err error) { + key, offset, err = fastpb.ReadString(buf, _type) + return offset, err + }, + func(buf []byte, _type int8) (offset int, err error) { + value, offset, err = fastpb.ReadString(buf, _type) + return offset, err + }) + if err != nil { + return offset, err + } + x.MapstringString[key] = value + return offset, nil +} + +func (x *BasicExample) fastReadField48(buf []byte, _type int8) (offset int, err error) { + if x.MapstringBytes == nil { + x.MapstringBytes = make(map[string][]byte) + } + var key string + var value []byte + offset, err = fastpb.ReadMapEntry(buf, _type, + func(buf []byte, _type int8) (offset int, err error) { + key, offset, err = fastpb.ReadString(buf, _type) + return offset, err + }, + func(buf []byte, _type int8) (offset int, err error) { + value, offset, err = fastpb.ReadBytes(buf, _type) + return offset, err + }) + if err != nil { + return offset, err + } + x.MapstringBytes[key] = value + return offset, nil +} + +func (x *BasicExample) fastReadField49(buf []byte, _type int8) (offset int, err error) { + if x.MapstringFloat == nil { + x.MapstringFloat = make(map[string]float32) + } + var key string + var value float32 + offset, err = fastpb.ReadMapEntry(buf, _type, + func(buf []byte, _type int8) (offset int, err error) { + key, offset, err = fastpb.ReadString(buf, _type) + return offset, err + }, + func(buf []byte, _type int8) (offset int, err error) { + value, offset, err = fastpb.ReadFloat(buf, _type) + return offset, err + }) + if err != nil { + return offset, err + } + x.MapstringFloat[key] = value + return offset, nil +} + +func (x *BasicExample) fastReadField50(buf []byte, _type int8) (offset int, err error) { + if x.MapstringInt64 == nil { + x.MapstringInt64 = make(map[string]int64) + } + var key string + var value int64 + offset, err = fastpb.ReadMapEntry(buf, _type, + func(buf []byte, _type int8) (offset int, err error) { + key, offset, err = fastpb.ReadString(buf, _type) + return offset, err + }, + func(buf []byte, _type int8) (offset int, err error) { + value, offset, err = fastpb.ReadInt64(buf, _type) + return offset, err + }) + if err != nil { + return offset, err + } + x.MapstringInt64[key] = value + return offset, nil +} + +func (x *BasicExample) FastWrite(buf []byte) (offset int) { + if x == nil { + return offset + } + offset += x.fastWriteField1(buf[offset:]) + offset += x.fastWriteField2(buf[offset:]) + offset += x.fastWriteField3(buf[offset:]) + offset += x.fastWriteField4(buf[offset:]) + offset += x.fastWriteField5(buf[offset:]) + offset += x.fastWriteField6(buf[offset:]) + offset += x.fastWriteField7(buf[offset:]) + offset += x.fastWriteField8(buf[offset:]) + offset += x.fastWriteField9(buf[offset:]) + offset += x.fastWriteField10(buf[offset:]) + offset += x.fastWriteField11(buf[offset:]) + offset += x.fastWriteField12(buf[offset:]) + offset += x.fastWriteField13(buf[offset:]) + offset += x.fastWriteField14(buf[offset:]) + offset += x.fastWriteField15(buf[offset:]) + offset += x.fastWriteField16(buf[offset:]) + offset += x.fastWriteField17(buf[offset:]) + offset += x.fastWriteField18(buf[offset:]) + offset += x.fastWriteField19(buf[offset:]) + offset += x.fastWriteField20(buf[offset:]) + offset += x.fastWriteField21(buf[offset:]) + offset += x.fastWriteField22(buf[offset:]) + offset += x.fastWriteField23(buf[offset:]) + offset += x.fastWriteField24(buf[offset:]) + offset += x.fastWriteField25(buf[offset:]) + offset += x.fastWriteField26(buf[offset:]) + offset += x.fastWriteField27(buf[offset:]) + offset += x.fastWriteField28(buf[offset:]) + offset += x.fastWriteField29(buf[offset:]) + offset += x.fastWriteField30(buf[offset:]) + offset += x.fastWriteField31(buf[offset:]) + offset += x.fastWriteField32(buf[offset:]) + offset += x.fastWriteField33(buf[offset:]) + offset += x.fastWriteField34(buf[offset:]) + offset += x.fastWriteField35(buf[offset:]) + offset += x.fastWriteField36(buf[offset:]) + offset += x.fastWriteField37(buf[offset:]) + offset += x.fastWriteField38(buf[offset:]) + offset += x.fastWriteField39(buf[offset:]) + offset += x.fastWriteField40(buf[offset:]) + offset += x.fastWriteField41(buf[offset:]) + offset += x.fastWriteField42(buf[offset:]) + offset += x.fastWriteField43(buf[offset:]) + offset += x.fastWriteField44(buf[offset:]) + offset += x.fastWriteField45(buf[offset:]) + offset += x.fastWriteField46(buf[offset:]) + offset += x.fastWriteField47(buf[offset:]) + offset += x.fastWriteField48(buf[offset:]) + offset += x.fastWriteField49(buf[offset:]) + offset += x.fastWriteField50(buf[offset:]) + return offset +} + +func (x *BasicExample) fastWriteField1(buf []byte) (offset int) { + if x.Int32 == 0 { + return offset + } + offset += fastpb.WriteInt32(buf[offset:], 1, x.GetInt32()) + return offset +} + +func (x *BasicExample) fastWriteField2(buf []byte) (offset int) { + if x.Int64 == 0 { + return offset + } + offset += fastpb.WriteInt64(buf[offset:], 2, x.GetInt64()) + return offset +} + +func (x *BasicExample) fastWriteField3(buf []byte) (offset int) { + if x.Uint32 == 0 { + return offset + } + offset += fastpb.WriteUint32(buf[offset:], 3, x.GetUint32()) + return offset +} + +func (x *BasicExample) fastWriteField4(buf []byte) (offset int) { + if x.Uint64 == 0 { + return offset + } + offset += fastpb.WriteUint64(buf[offset:], 4, x.GetUint64()) + return offset +} + +func (x *BasicExample) fastWriteField5(buf []byte) (offset int) { + if x.Sint32 == 0 { + return offset + } + offset += fastpb.WriteSint32(buf[offset:], 5, x.GetSint32()) + return offset +} + +func (x *BasicExample) fastWriteField6(buf []byte) (offset int) { + if x.Sint64 == 0 { + return offset + } + offset += fastpb.WriteSint64(buf[offset:], 6, x.GetSint64()) + return offset +} + +func (x *BasicExample) fastWriteField7(buf []byte) (offset int) { + if x.Sfixed32 == 0 { + return offset + } + offset += fastpb.WriteSfixed32(buf[offset:], 7, x.GetSfixed32()) + return offset +} + +func (x *BasicExample) fastWriteField8(buf []byte) (offset int) { + if x.Sfixed64 == 0 { + return offset + } + offset += fastpb.WriteSfixed64(buf[offset:], 8, x.GetSfixed64()) + return offset +} + +func (x *BasicExample) fastWriteField9(buf []byte) (offset int) { + if x.Fixed32 == 0 { + return offset + } + offset += fastpb.WriteFixed32(buf[offset:], 9, x.GetFixed32()) + return offset +} + +func (x *BasicExample) fastWriteField10(buf []byte) (offset int) { + if x.Fixed64 == 0 { + return offset + } + offset += fastpb.WriteFixed64(buf[offset:], 10, x.GetFixed64()) + return offset +} + +func (x *BasicExample) fastWriteField11(buf []byte) (offset int) { + if x.Float == 0 { + return offset + } + offset += fastpb.WriteFloat(buf[offset:], 11, x.GetFloat()) + return offset +} + +func (x *BasicExample) fastWriteField12(buf []byte) (offset int) { + if x.Double == 0 { + return offset + } + offset += fastpb.WriteDouble(buf[offset:], 12, x.GetDouble()) + return offset +} + +func (x *BasicExample) fastWriteField13(buf []byte) (offset int) { + if !x.Bool { + return offset + } + offset += fastpb.WriteBool(buf[offset:], 13, x.GetBool()) + return offset +} + +func (x *BasicExample) fastWriteField14(buf []byte) (offset int) { + if x.Str == "" { + return offset + } + offset += fastpb.WriteString(buf[offset:], 14, x.GetStr()) + return offset +} + +func (x *BasicExample) fastWriteField15(buf []byte) (offset int) { + if len(x.Bytes) == 0 { + return offset + } + offset += fastpb.WriteBytes(buf[offset:], 15, x.GetBytes()) + return offset +} + +func (x *BasicExample) fastWriteField16(buf []byte) (offset int) { + if len(x.ListInt32) == 0 { + return offset + } + offset += fastpb.WriteListPacked(buf[offset:], 16, len(x.GetListInt32()), + func(buf []byte, numTagOrKey, numIdxOrVal int32) int { + offset := 0 + offset += fastpb.WriteInt32(buf[offset:], numTagOrKey, x.GetListInt32()[numIdxOrVal]) + return offset + }) + return offset +} + +func (x *BasicExample) fastWriteField17(buf []byte) (offset int) { + if len(x.ListInt64) == 0 { + return offset + } + offset += fastpb.WriteListPacked(buf[offset:], 17, len(x.GetListInt64()), + func(buf []byte, numTagOrKey, numIdxOrVal int32) int { + offset := 0 + offset += fastpb.WriteInt64(buf[offset:], numTagOrKey, x.GetListInt64()[numIdxOrVal]) + return offset + }) + return offset +} + +func (x *BasicExample) fastWriteField18(buf []byte) (offset int) { + if len(x.ListUint32) == 0 { + return offset + } + offset += fastpb.WriteListPacked(buf[offset:], 18, len(x.GetListUint32()), + func(buf []byte, numTagOrKey, numIdxOrVal int32) int { + offset := 0 + offset += fastpb.WriteUint32(buf[offset:], numTagOrKey, x.GetListUint32()[numIdxOrVal]) + return offset + }) + return offset +} + +func (x *BasicExample) fastWriteField19(buf []byte) (offset int) { + if len(x.ListUint64) == 0 { + return offset + } + offset += fastpb.WriteListPacked(buf[offset:], 19, len(x.GetListUint64()), + func(buf []byte, numTagOrKey, numIdxOrVal int32) int { + offset := 0 + offset += fastpb.WriteUint64(buf[offset:], numTagOrKey, x.GetListUint64()[numIdxOrVal]) + return offset + }) + return offset +} + +func (x *BasicExample) fastWriteField20(buf []byte) (offset int) { + if len(x.ListSint32) == 0 { + return offset + } + offset += fastpb.WriteListPacked(buf[offset:], 20, len(x.GetListSint32()), + func(buf []byte, numTagOrKey, numIdxOrVal int32) int { + offset := 0 + offset += fastpb.WriteSint32(buf[offset:], numTagOrKey, x.GetListSint32()[numIdxOrVal]) + return offset + }) + return offset +} + +func (x *BasicExample) fastWriteField21(buf []byte) (offset int) { + if len(x.ListSint64) == 0 { + return offset + } + offset += fastpb.WriteListPacked(buf[offset:], 21, len(x.GetListSint64()), + func(buf []byte, numTagOrKey, numIdxOrVal int32) int { + offset := 0 + offset += fastpb.WriteSint64(buf[offset:], numTagOrKey, x.GetListSint64()[numIdxOrVal]) + return offset + }) + return offset +} + +func (x *BasicExample) fastWriteField22(buf []byte) (offset int) { + if len(x.ListSfixed32) == 0 { + return offset + } + offset += fastpb.WriteListPacked(buf[offset:], 22, len(x.GetListSfixed32()), + func(buf []byte, numTagOrKey, numIdxOrVal int32) int { + offset := 0 + offset += fastpb.WriteSfixed32(buf[offset:], numTagOrKey, x.GetListSfixed32()[numIdxOrVal]) + return offset + }) + return offset +} + +func (x *BasicExample) fastWriteField23(buf []byte) (offset int) { + if len(x.ListSfixed64) == 0 { + return offset + } + offset += fastpb.WriteListPacked(buf[offset:], 23, len(x.GetListSfixed64()), + func(buf []byte, numTagOrKey, numIdxOrVal int32) int { + offset := 0 + offset += fastpb.WriteSfixed64(buf[offset:], numTagOrKey, x.GetListSfixed64()[numIdxOrVal]) + return offset + }) + return offset +} + +func (x *BasicExample) fastWriteField24(buf []byte) (offset int) { + if len(x.ListFixed32) == 0 { + return offset + } + offset += fastpb.WriteListPacked(buf[offset:], 24, len(x.GetListFixed32()), + func(buf []byte, numTagOrKey, numIdxOrVal int32) int { + offset := 0 + offset += fastpb.WriteFixed32(buf[offset:], numTagOrKey, x.GetListFixed32()[numIdxOrVal]) + return offset + }) + return offset +} + +func (x *BasicExample) fastWriteField25(buf []byte) (offset int) { + if len(x.ListFixed64) == 0 { + return offset + } + offset += fastpb.WriteListPacked(buf[offset:], 25, len(x.GetListFixed64()), + func(buf []byte, numTagOrKey, numIdxOrVal int32) int { + offset := 0 + offset += fastpb.WriteFixed64(buf[offset:], numTagOrKey, x.GetListFixed64()[numIdxOrVal]) + return offset + }) + return offset +} + +func (x *BasicExample) fastWriteField26(buf []byte) (offset int) { + if len(x.ListFloat) == 0 { + return offset + } + offset += fastpb.WriteListPacked(buf[offset:], 26, len(x.GetListFloat()), + func(buf []byte, numTagOrKey, numIdxOrVal int32) int { + offset := 0 + offset += fastpb.WriteFloat(buf[offset:], numTagOrKey, x.GetListFloat()[numIdxOrVal]) + return offset + }) + return offset +} + +func (x *BasicExample) fastWriteField27(buf []byte) (offset int) { + if len(x.ListDouble) == 0 { + return offset + } + offset += fastpb.WriteListPacked(buf[offset:], 27, len(x.GetListDouble()), + func(buf []byte, numTagOrKey, numIdxOrVal int32) int { + offset := 0 + offset += fastpb.WriteDouble(buf[offset:], numTagOrKey, x.GetListDouble()[numIdxOrVal]) + return offset + }) + return offset +} + +func (x *BasicExample) fastWriteField28(buf []byte) (offset int) { + if len(x.ListBool) == 0 { + return offset + } + offset += fastpb.WriteListPacked(buf[offset:], 28, len(x.GetListBool()), + func(buf []byte, numTagOrKey, numIdxOrVal int32) int { + offset := 0 + offset += fastpb.WriteBool(buf[offset:], numTagOrKey, x.GetListBool()[numIdxOrVal]) + return offset + }) + return offset +} + +func (x *BasicExample) fastWriteField29(buf []byte) (offset int) { + if len(x.ListString) == 0 { + return offset + } + for i := range x.GetListString() { + offset += fastpb.WriteString(buf[offset:], 29, x.GetListString()[i]) + } + return offset +} + +func (x *BasicExample) fastWriteField30(buf []byte) (offset int) { + if len(x.ListBytes) == 0 { + return offset + } + for i := range x.GetListBytes() { + offset += fastpb.WriteBytes(buf[offset:], 30, x.GetListBytes()[i]) + } + return offset +} + +func (x *BasicExample) fastWriteField31(buf []byte) (offset int) { + if x.MapInt64SINT32 == nil { + return offset + } + for k, v := range x.GetMapInt64SINT32() { + offset += fastpb.WriteMapEntry(buf[offset:], 31, + func(buf []byte, numTagOrKey, numIdxOrVal int32) int { + offset := 0 + offset += fastpb.WriteInt64(buf[offset:], numTagOrKey, k) + offset += fastpb.WriteSint32(buf[offset:], numIdxOrVal, v) + return offset + }) + } + return offset +} + +func (x *BasicExample) fastWriteField32(buf []byte) (offset int) { + if x.MapInt64Sfixed32 == nil { + return offset + } + for k, v := range x.GetMapInt64Sfixed32() { + offset += fastpb.WriteMapEntry(buf[offset:], 32, + func(buf []byte, numTagOrKey, numIdxOrVal int32) int { + offset := 0 + offset += fastpb.WriteInt64(buf[offset:], numTagOrKey, k) + offset += fastpb.WriteSfixed32(buf[offset:], numIdxOrVal, v) + return offset + }) + } + return offset +} + +func (x *BasicExample) fastWriteField33(buf []byte) (offset int) { + if x.MapInt64Fixed32 == nil { + return offset + } + for k, v := range x.GetMapInt64Fixed32() { + offset += fastpb.WriteMapEntry(buf[offset:], 33, + func(buf []byte, numTagOrKey, numIdxOrVal int32) int { + offset := 0 + offset += fastpb.WriteInt64(buf[offset:], numTagOrKey, k) + offset += fastpb.WriteFixed32(buf[offset:], numIdxOrVal, v) + return offset + }) + } + return offset +} + +func (x *BasicExample) fastWriteField34(buf []byte) (offset int) { + if x.MapInt64Uint32 == nil { + return offset + } + for k, v := range x.GetMapInt64Uint32() { + offset += fastpb.WriteMapEntry(buf[offset:], 34, + func(buf []byte, numTagOrKey, numIdxOrVal int32) int { + offset := 0 + offset += fastpb.WriteInt64(buf[offset:], numTagOrKey, k) + offset += fastpb.WriteUint32(buf[offset:], numIdxOrVal, v) + return offset + }) + } + return offset +} + +func (x *BasicExample) fastWriteField35(buf []byte) (offset int) { + if x.MapInt64Double == nil { + return offset + } + for k, v := range x.GetMapInt64Double() { + offset += fastpb.WriteMapEntry(buf[offset:], 35, + func(buf []byte, numTagOrKey, numIdxOrVal int32) int { + offset := 0 + offset += fastpb.WriteInt64(buf[offset:], numTagOrKey, k) + offset += fastpb.WriteDouble(buf[offset:], numIdxOrVal, v) + return offset + }) + } + return offset +} + +func (x *BasicExample) fastWriteField36(buf []byte) (offset int) { + if x.MapInt64Bool == nil { + return offset + } + for k, v := range x.GetMapInt64Bool() { + offset += fastpb.WriteMapEntry(buf[offset:], 36, + func(buf []byte, numTagOrKey, numIdxOrVal int32) int { + offset := 0 + offset += fastpb.WriteInt64(buf[offset:], numTagOrKey, k) + offset += fastpb.WriteBool(buf[offset:], numIdxOrVal, v) + return offset + }) + } + return offset +} + +func (x *BasicExample) fastWriteField37(buf []byte) (offset int) { + if x.MapInt64String == nil { + return offset + } + for k, v := range x.GetMapInt64String() { + offset += fastpb.WriteMapEntry(buf[offset:], 37, + func(buf []byte, numTagOrKey, numIdxOrVal int32) int { + offset := 0 + offset += fastpb.WriteInt64(buf[offset:], numTagOrKey, k) + offset += fastpb.WriteString(buf[offset:], numIdxOrVal, v) + return offset + }) + } + return offset +} + +func (x *BasicExample) fastWriteField38(buf []byte) (offset int) { + if x.MapInt64Bytes == nil { + return offset + } + for k, v := range x.GetMapInt64Bytes() { + offset += fastpb.WriteMapEntry(buf[offset:], 38, + func(buf []byte, numTagOrKey, numIdxOrVal int32) int { + offset := 0 + offset += fastpb.WriteInt64(buf[offset:], numTagOrKey, k) + offset += fastpb.WriteBytes(buf[offset:], numIdxOrVal, v) + return offset + }) + } + return offset +} + +func (x *BasicExample) fastWriteField39(buf []byte) (offset int) { + if x.MapInt64Float == nil { + return offset + } + for k, v := range x.GetMapInt64Float() { + offset += fastpb.WriteMapEntry(buf[offset:], 39, + func(buf []byte, numTagOrKey, numIdxOrVal int32) int { + offset := 0 + offset += fastpb.WriteInt64(buf[offset:], numTagOrKey, k) + offset += fastpb.WriteFloat(buf[offset:], numIdxOrVal, v) + return offset + }) + } + return offset +} + +func (x *BasicExample) fastWriteField40(buf []byte) (offset int) { + if x.MapInt64Int32 == nil { + return offset + } + for k, v := range x.GetMapInt64Int32() { + offset += fastpb.WriteMapEntry(buf[offset:], 40, + func(buf []byte, numTagOrKey, numIdxOrVal int32) int { + offset := 0 + offset += fastpb.WriteInt64(buf[offset:], numTagOrKey, k) + offset += fastpb.WriteInt32(buf[offset:], numIdxOrVal, v) + return offset + }) + } + return offset +} + +func (x *BasicExample) fastWriteField41(buf []byte) (offset int) { + if x.MapstringSINT64 == nil { + return offset + } + for k, v := range x.GetMapstringSINT64() { + offset += fastpb.WriteMapEntry(buf[offset:], 41, + func(buf []byte, numTagOrKey, numIdxOrVal int32) int { + offset := 0 + offset += fastpb.WriteString(buf[offset:], numTagOrKey, k) + offset += fastpb.WriteSint64(buf[offset:], numIdxOrVal, v) + return offset + }) + } + return offset +} + +func (x *BasicExample) fastWriteField42(buf []byte) (offset int) { + if x.MapstringSfixed64 == nil { + return offset + } + for k, v := range x.GetMapstringSfixed64() { + offset += fastpb.WriteMapEntry(buf[offset:], 42, + func(buf []byte, numTagOrKey, numIdxOrVal int32) int { + offset := 0 + offset += fastpb.WriteString(buf[offset:], numTagOrKey, k) + offset += fastpb.WriteSfixed64(buf[offset:], numIdxOrVal, v) + return offset + }) + } + return offset +} + +func (x *BasicExample) fastWriteField43(buf []byte) (offset int) { + if x.MapstringFixed64 == nil { + return offset + } + for k, v := range x.GetMapstringFixed64() { + offset += fastpb.WriteMapEntry(buf[offset:], 43, + func(buf []byte, numTagOrKey, numIdxOrVal int32) int { + offset := 0 + offset += fastpb.WriteString(buf[offset:], numTagOrKey, k) + offset += fastpb.WriteFixed64(buf[offset:], numIdxOrVal, v) + return offset + }) + } + return offset +} + +func (x *BasicExample) fastWriteField44(buf []byte) (offset int) { + if x.MapstringUint64 == nil { + return offset + } + for k, v := range x.GetMapstringUint64() { + offset += fastpb.WriteMapEntry(buf[offset:], 44, + func(buf []byte, numTagOrKey, numIdxOrVal int32) int { + offset := 0 + offset += fastpb.WriteString(buf[offset:], numTagOrKey, k) + offset += fastpb.WriteUint64(buf[offset:], numIdxOrVal, v) + return offset + }) + } + return offset +} + +func (x *BasicExample) fastWriteField45(buf []byte) (offset int) { + if x.MapstringDouble == nil { + return offset + } + for k, v := range x.GetMapstringDouble() { + offset += fastpb.WriteMapEntry(buf[offset:], 45, + func(buf []byte, numTagOrKey, numIdxOrVal int32) int { + offset := 0 + offset += fastpb.WriteString(buf[offset:], numTagOrKey, k) + offset += fastpb.WriteDouble(buf[offset:], numIdxOrVal, v) + return offset + }) + } + return offset +} + +func (x *BasicExample) fastWriteField46(buf []byte) (offset int) { + if x.MapstringBool == nil { + return offset + } + for k, v := range x.GetMapstringBool() { + offset += fastpb.WriteMapEntry(buf[offset:], 46, + func(buf []byte, numTagOrKey, numIdxOrVal int32) int { + offset := 0 + offset += fastpb.WriteString(buf[offset:], numTagOrKey, k) + offset += fastpb.WriteBool(buf[offset:], numIdxOrVal, v) + return offset + }) + } + return offset +} + +func (x *BasicExample) fastWriteField47(buf []byte) (offset int) { + if x.MapstringString == nil { + return offset + } + for k, v := range x.GetMapstringString() { + offset += fastpb.WriteMapEntry(buf[offset:], 47, + func(buf []byte, numTagOrKey, numIdxOrVal int32) int { + offset := 0 + offset += fastpb.WriteString(buf[offset:], numTagOrKey, k) + offset += fastpb.WriteString(buf[offset:], numIdxOrVal, v) + return offset + }) + } + return offset +} + +func (x *BasicExample) fastWriteField48(buf []byte) (offset int) { + if x.MapstringBytes == nil { + return offset + } + for k, v := range x.GetMapstringBytes() { + offset += fastpb.WriteMapEntry(buf[offset:], 48, + func(buf []byte, numTagOrKey, numIdxOrVal int32) int { + offset := 0 + offset += fastpb.WriteString(buf[offset:], numTagOrKey, k) + offset += fastpb.WriteBytes(buf[offset:], numIdxOrVal, v) + return offset + }) + } + return offset +} + +func (x *BasicExample) fastWriteField49(buf []byte) (offset int) { + if x.MapstringFloat == nil { + return offset + } + for k, v := range x.GetMapstringFloat() { + offset += fastpb.WriteMapEntry(buf[offset:], 49, + func(buf []byte, numTagOrKey, numIdxOrVal int32) int { + offset := 0 + offset += fastpb.WriteString(buf[offset:], numTagOrKey, k) + offset += fastpb.WriteFloat(buf[offset:], numIdxOrVal, v) + return offset + }) + } + return offset +} + +func (x *BasicExample) fastWriteField50(buf []byte) (offset int) { + if x.MapstringInt64 == nil { + return offset + } + for k, v := range x.GetMapstringInt64() { + offset += fastpb.WriteMapEntry(buf[offset:], 50, + func(buf []byte, numTagOrKey, numIdxOrVal int32) int { + offset := 0 + offset += fastpb.WriteString(buf[offset:], numTagOrKey, k) + offset += fastpb.WriteInt64(buf[offset:], numIdxOrVal, v) + return offset + }) + } + return offset +} + +func (x *BasicExample) Size() (n int) { + if x == nil { + return n + } + n += x.sizeField1() + n += x.sizeField2() + n += x.sizeField3() + n += x.sizeField4() + n += x.sizeField5() + n += x.sizeField6() + n += x.sizeField7() + n += x.sizeField8() + n += x.sizeField9() + n += x.sizeField10() + n += x.sizeField11() + n += x.sizeField12() + n += x.sizeField13() + n += x.sizeField14() + n += x.sizeField15() + n += x.sizeField16() + n += x.sizeField17() + n += x.sizeField18() + n += x.sizeField19() + n += x.sizeField20() + n += x.sizeField21() + n += x.sizeField22() + n += x.sizeField23() + n += x.sizeField24() + n += x.sizeField25() + n += x.sizeField26() + n += x.sizeField27() + n += x.sizeField28() + n += x.sizeField29() + n += x.sizeField30() + n += x.sizeField31() + n += x.sizeField32() + n += x.sizeField33() + n += x.sizeField34() + n += x.sizeField35() + n += x.sizeField36() + n += x.sizeField37() + n += x.sizeField38() + n += x.sizeField39() + n += x.sizeField40() + n += x.sizeField41() + n += x.sizeField42() + n += x.sizeField43() + n += x.sizeField44() + n += x.sizeField45() + n += x.sizeField46() + n += x.sizeField47() + n += x.sizeField48() + n += x.sizeField49() + n += x.sizeField50() + return n +} + +func (x *BasicExample) sizeField1() (n int) { + if x.Int32 == 0 { + return n + } + n += fastpb.SizeInt32(1, x.GetInt32()) + return n +} + +func (x *BasicExample) sizeField2() (n int) { + if x.Int64 == 0 { + return n + } + n += fastpb.SizeInt64(2, x.GetInt64()) + return n +} + +func (x *BasicExample) sizeField3() (n int) { + if x.Uint32 == 0 { + return n + } + n += fastpb.SizeUint32(3, x.GetUint32()) + return n +} + +func (x *BasicExample) sizeField4() (n int) { + if x.Uint64 == 0 { + return n + } + n += fastpb.SizeUint64(4, x.GetUint64()) + return n +} + +func (x *BasicExample) sizeField5() (n int) { + if x.Sint32 == 0 { + return n + } + n += fastpb.SizeSint32(5, x.GetSint32()) + return n +} + +func (x *BasicExample) sizeField6() (n int) { + if x.Sint64 == 0 { + return n + } + n += fastpb.SizeSint64(6, x.GetSint64()) + return n +} + +func (x *BasicExample) sizeField7() (n int) { + if x.Sfixed32 == 0 { + return n + } + n += fastpb.SizeSfixed32(7, x.GetSfixed32()) + return n +} + +func (x *BasicExample) sizeField8() (n int) { + if x.Sfixed64 == 0 { + return n + } + n += fastpb.SizeSfixed64(8, x.GetSfixed64()) + return n +} + +func (x *BasicExample) sizeField9() (n int) { + if x.Fixed32 == 0 { + return n + } + n += fastpb.SizeFixed32(9, x.GetFixed32()) + return n +} + +func (x *BasicExample) sizeField10() (n int) { + if x.Fixed64 == 0 { + return n + } + n += fastpb.SizeFixed64(10, x.GetFixed64()) + return n +} + +func (x *BasicExample) sizeField11() (n int) { + if x.Float == 0 { + return n + } + n += fastpb.SizeFloat(11, x.GetFloat()) + return n +} + +func (x *BasicExample) sizeField12() (n int) { + if x.Double == 0 { + return n + } + n += fastpb.SizeDouble(12, x.GetDouble()) + return n +} + +func (x *BasicExample) sizeField13() (n int) { + if !x.Bool { + return n + } + n += fastpb.SizeBool(13, x.GetBool()) + return n +} + +func (x *BasicExample) sizeField14() (n int) { + if x.Str == "" { + return n + } + n += fastpb.SizeString(14, x.GetStr()) + return n +} + +func (x *BasicExample) sizeField15() (n int) { + if len(x.Bytes) == 0 { + return n + } + n += fastpb.SizeBytes(15, x.GetBytes()) + return n +} + +func (x *BasicExample) sizeField16() (n int) { + if len(x.ListInt32) == 0 { + return n + } + n += fastpb.SizeListPacked(16, len(x.GetListInt32()), + func(numTagOrKey, numIdxOrVal int32) int { + n := 0 + n += fastpb.SizeInt32(numTagOrKey, x.GetListInt32()[numIdxOrVal]) + return n + }) + return n +} + +func (x *BasicExample) sizeField17() (n int) { + if len(x.ListInt64) == 0 { + return n + } + n += fastpb.SizeListPacked(17, len(x.GetListInt64()), + func(numTagOrKey, numIdxOrVal int32) int { + n := 0 + n += fastpb.SizeInt64(numTagOrKey, x.GetListInt64()[numIdxOrVal]) + return n + }) + return n +} + +func (x *BasicExample) sizeField18() (n int) { + if len(x.ListUint32) == 0 { + return n + } + n += fastpb.SizeListPacked(18, len(x.GetListUint32()), + func(numTagOrKey, numIdxOrVal int32) int { + n := 0 + n += fastpb.SizeUint32(numTagOrKey, x.GetListUint32()[numIdxOrVal]) + return n + }) + return n +} + +func (x *BasicExample) sizeField19() (n int) { + if len(x.ListUint64) == 0 { + return n + } + n += fastpb.SizeListPacked(19, len(x.GetListUint64()), + func(numTagOrKey, numIdxOrVal int32) int { + n := 0 + n += fastpb.SizeUint64(numTagOrKey, x.GetListUint64()[numIdxOrVal]) + return n + }) + return n +} + +func (x *BasicExample) sizeField20() (n int) { + if len(x.ListSint32) == 0 { + return n + } + n += fastpb.SizeListPacked(20, len(x.GetListSint32()), + func(numTagOrKey, numIdxOrVal int32) int { + n := 0 + n += fastpb.SizeSint32(numTagOrKey, x.GetListSint32()[numIdxOrVal]) + return n + }) + return n +} + +func (x *BasicExample) sizeField21() (n int) { + if len(x.ListSint64) == 0 { + return n + } + n += fastpb.SizeListPacked(21, len(x.GetListSint64()), + func(numTagOrKey, numIdxOrVal int32) int { + n := 0 + n += fastpb.SizeSint64(numTagOrKey, x.GetListSint64()[numIdxOrVal]) + return n + }) + return n +} + +func (x *BasicExample) sizeField22() (n int) { + if len(x.ListSfixed32) == 0 { + return n + } + n += fastpb.SizeListPacked(22, len(x.GetListSfixed32()), + func(numTagOrKey, numIdxOrVal int32) int { + n := 0 + n += fastpb.SizeSfixed32(numTagOrKey, x.GetListSfixed32()[numIdxOrVal]) + return n + }) + return n +} + +func (x *BasicExample) sizeField23() (n int) { + if len(x.ListSfixed64) == 0 { + return n + } + n += fastpb.SizeListPacked(23, len(x.GetListSfixed64()), + func(numTagOrKey, numIdxOrVal int32) int { + n := 0 + n += fastpb.SizeSfixed64(numTagOrKey, x.GetListSfixed64()[numIdxOrVal]) + return n + }) + return n +} + +func (x *BasicExample) sizeField24() (n int) { + if len(x.ListFixed32) == 0 { + return n + } + n += fastpb.SizeListPacked(24, len(x.GetListFixed32()), + func(numTagOrKey, numIdxOrVal int32) int { + n := 0 + n += fastpb.SizeFixed32(numTagOrKey, x.GetListFixed32()[numIdxOrVal]) + return n + }) + return n +} + +func (x *BasicExample) sizeField25() (n int) { + if len(x.ListFixed64) == 0 { + return n + } + n += fastpb.SizeListPacked(25, len(x.GetListFixed64()), + func(numTagOrKey, numIdxOrVal int32) int { + n := 0 + n += fastpb.SizeFixed64(numTagOrKey, x.GetListFixed64()[numIdxOrVal]) + return n + }) + return n +} + +func (x *BasicExample) sizeField26() (n int) { + if len(x.ListFloat) == 0 { + return n + } + n += fastpb.SizeListPacked(26, len(x.GetListFloat()), + func(numTagOrKey, numIdxOrVal int32) int { + n := 0 + n += fastpb.SizeFloat(numTagOrKey, x.GetListFloat()[numIdxOrVal]) + return n + }) + return n +} + +func (x *BasicExample) sizeField27() (n int) { + if len(x.ListDouble) == 0 { + return n + } + n += fastpb.SizeListPacked(27, len(x.GetListDouble()), + func(numTagOrKey, numIdxOrVal int32) int { + n := 0 + n += fastpb.SizeDouble(numTagOrKey, x.GetListDouble()[numIdxOrVal]) + return n + }) + return n +} + +func (x *BasicExample) sizeField28() (n int) { + if len(x.ListBool) == 0 { + return n + } + n += fastpb.SizeListPacked(28, len(x.GetListBool()), + func(numTagOrKey, numIdxOrVal int32) int { + n := 0 + n += fastpb.SizeBool(numTagOrKey, x.GetListBool()[numIdxOrVal]) + return n + }) + return n +} + +func (x *BasicExample) sizeField29() (n int) { + if len(x.ListString) == 0 { + return n + } + for i := range x.GetListString() { + n += fastpb.SizeString(29, x.GetListString()[i]) + } + return n +} + +func (x *BasicExample) sizeField30() (n int) { + if len(x.ListBytes) == 0 { + return n + } + for i := range x.GetListBytes() { + n += fastpb.SizeBytes(30, x.GetListBytes()[i]) + } + return n +} + +func (x *BasicExample) sizeField31() (n int) { + if x.MapInt64SINT32 == nil { + return n + } + for k, v := range x.GetMapInt64SINT32() { + n += fastpb.SizeMapEntry(31, + func(numTagOrKey, numIdxOrVal int32) int { + n := 0 + n += fastpb.SizeInt64(numTagOrKey, k) + n += fastpb.SizeSint32(numIdxOrVal, v) + return n + }) + } + return n +} + +func (x *BasicExample) sizeField32() (n int) { + if x.MapInt64Sfixed32 == nil { + return n + } + for k, v := range x.GetMapInt64Sfixed32() { + n += fastpb.SizeMapEntry(32, + func(numTagOrKey, numIdxOrVal int32) int { + n := 0 + n += fastpb.SizeInt64(numTagOrKey, k) + n += fastpb.SizeSfixed32(numIdxOrVal, v) + return n + }) + } + return n +} + +func (x *BasicExample) sizeField33() (n int) { + if x.MapInt64Fixed32 == nil { + return n + } + for k, v := range x.GetMapInt64Fixed32() { + n += fastpb.SizeMapEntry(33, + func(numTagOrKey, numIdxOrVal int32) int { + n := 0 + n += fastpb.SizeInt64(numTagOrKey, k) + n += fastpb.SizeFixed32(numIdxOrVal, v) + return n + }) + } + return n +} + +func (x *BasicExample) sizeField34() (n int) { + if x.MapInt64Uint32 == nil { + return n + } + for k, v := range x.GetMapInt64Uint32() { + n += fastpb.SizeMapEntry(34, + func(numTagOrKey, numIdxOrVal int32) int { + n := 0 + n += fastpb.SizeInt64(numTagOrKey, k) + n += fastpb.SizeUint32(numIdxOrVal, v) + return n + }) + } + return n +} + +func (x *BasicExample) sizeField35() (n int) { + if x.MapInt64Double == nil { + return n + } + for k, v := range x.GetMapInt64Double() { + n += fastpb.SizeMapEntry(35, + func(numTagOrKey, numIdxOrVal int32) int { + n := 0 + n += fastpb.SizeInt64(numTagOrKey, k) + n += fastpb.SizeDouble(numIdxOrVal, v) + return n + }) + } + return n +} + +func (x *BasicExample) sizeField36() (n int) { + if x.MapInt64Bool == nil { + return n + } + for k, v := range x.GetMapInt64Bool() { + n += fastpb.SizeMapEntry(36, + func(numTagOrKey, numIdxOrVal int32) int { + n := 0 + n += fastpb.SizeInt64(numTagOrKey, k) + n += fastpb.SizeBool(numIdxOrVal, v) + return n + }) + } + return n +} + +func (x *BasicExample) sizeField37() (n int) { + if x.MapInt64String == nil { + return n + } + for k, v := range x.GetMapInt64String() { + n += fastpb.SizeMapEntry(37, + func(numTagOrKey, numIdxOrVal int32) int { + n := 0 + n += fastpb.SizeInt64(numTagOrKey, k) + n += fastpb.SizeString(numIdxOrVal, v) + return n + }) + } + return n +} + +func (x *BasicExample) sizeField38() (n int) { + if x.MapInt64Bytes == nil { + return n + } + for k, v := range x.GetMapInt64Bytes() { + n += fastpb.SizeMapEntry(38, + func(numTagOrKey, numIdxOrVal int32) int { + n := 0 + n += fastpb.SizeInt64(numTagOrKey, k) + n += fastpb.SizeBytes(numIdxOrVal, v) + return n + }) + } + return n +} + +func (x *BasicExample) sizeField39() (n int) { + if x.MapInt64Float == nil { + return n + } + for k, v := range x.GetMapInt64Float() { + n += fastpb.SizeMapEntry(39, + func(numTagOrKey, numIdxOrVal int32) int { + n := 0 + n += fastpb.SizeInt64(numTagOrKey, k) + n += fastpb.SizeFloat(numIdxOrVal, v) + return n + }) + } + return n +} + +func (x *BasicExample) sizeField40() (n int) { + if x.MapInt64Int32 == nil { + return n + } + for k, v := range x.GetMapInt64Int32() { + n += fastpb.SizeMapEntry(40, + func(numTagOrKey, numIdxOrVal int32) int { + n := 0 + n += fastpb.SizeInt64(numTagOrKey, k) + n += fastpb.SizeInt32(numIdxOrVal, v) + return n + }) + } + return n +} + +func (x *BasicExample) sizeField41() (n int) { + if x.MapstringSINT64 == nil { + return n + } + for k, v := range x.GetMapstringSINT64() { + n += fastpb.SizeMapEntry(41, + func(numTagOrKey, numIdxOrVal int32) int { + n := 0 + n += fastpb.SizeString(numTagOrKey, k) + n += fastpb.SizeSint64(numIdxOrVal, v) + return n + }) + } + return n +} + +func (x *BasicExample) sizeField42() (n int) { + if x.MapstringSfixed64 == nil { + return n + } + for k, v := range x.GetMapstringSfixed64() { + n += fastpb.SizeMapEntry(42, + func(numTagOrKey, numIdxOrVal int32) int { + n := 0 + n += fastpb.SizeString(numTagOrKey, k) + n += fastpb.SizeSfixed64(numIdxOrVal, v) + return n + }) + } + return n +} + +func (x *BasicExample) sizeField43() (n int) { + if x.MapstringFixed64 == nil { + return n + } + for k, v := range x.GetMapstringFixed64() { + n += fastpb.SizeMapEntry(43, + func(numTagOrKey, numIdxOrVal int32) int { + n := 0 + n += fastpb.SizeString(numTagOrKey, k) + n += fastpb.SizeFixed64(numIdxOrVal, v) + return n + }) + } + return n +} + +func (x *BasicExample) sizeField44() (n int) { + if x.MapstringUint64 == nil { + return n + } + for k, v := range x.GetMapstringUint64() { + n += fastpb.SizeMapEntry(44, + func(numTagOrKey, numIdxOrVal int32) int { + n := 0 + n += fastpb.SizeString(numTagOrKey, k) + n += fastpb.SizeUint64(numIdxOrVal, v) + return n + }) + } + return n +} + +func (x *BasicExample) sizeField45() (n int) { + if x.MapstringDouble == nil { + return n + } + for k, v := range x.GetMapstringDouble() { + n += fastpb.SizeMapEntry(45, + func(numTagOrKey, numIdxOrVal int32) int { + n := 0 + n += fastpb.SizeString(numTagOrKey, k) + n += fastpb.SizeDouble(numIdxOrVal, v) + return n + }) + } + return n +} + +func (x *BasicExample) sizeField46() (n int) { + if x.MapstringBool == nil { + return n + } + for k, v := range x.GetMapstringBool() { + n += fastpb.SizeMapEntry(46, + func(numTagOrKey, numIdxOrVal int32) int { + n := 0 + n += fastpb.SizeString(numTagOrKey, k) + n += fastpb.SizeBool(numIdxOrVal, v) + return n + }) + } + return n +} + +func (x *BasicExample) sizeField47() (n int) { + if x.MapstringString == nil { + return n + } + for k, v := range x.GetMapstringString() { + n += fastpb.SizeMapEntry(47, + func(numTagOrKey, numIdxOrVal int32) int { + n := 0 + n += fastpb.SizeString(numTagOrKey, k) + n += fastpb.SizeString(numIdxOrVal, v) + return n + }) + } + return n +} + +func (x *BasicExample) sizeField48() (n int) { + if x.MapstringBytes == nil { + return n + } + for k, v := range x.GetMapstringBytes() { + n += fastpb.SizeMapEntry(48, + func(numTagOrKey, numIdxOrVal int32) int { + n := 0 + n += fastpb.SizeString(numTagOrKey, k) + n += fastpb.SizeBytes(numIdxOrVal, v) + return n + }) + } + return n +} + +func (x *BasicExample) sizeField49() (n int) { + if x.MapstringFloat == nil { + return n + } + for k, v := range x.GetMapstringFloat() { + n += fastpb.SizeMapEntry(49, + func(numTagOrKey, numIdxOrVal int32) int { + n := 0 + n += fastpb.SizeString(numTagOrKey, k) + n += fastpb.SizeFloat(numIdxOrVal, v) + return n + }) + } + return n +} + +func (x *BasicExample) sizeField50() (n int) { + if x.MapstringInt64 == nil { + return n + } + for k, v := range x.GetMapstringInt64() { + n += fastpb.SizeMapEntry(50, + func(numTagOrKey, numIdxOrVal int32) int { + n := 0 + n += fastpb.SizeString(numTagOrKey, k) + n += fastpb.SizeInt64(numIdxOrVal, v) + return n + }) + } + return n +} + +var fieldIDToName_BasicExample = map[int32]string{ + 1: "Int32", + 2: "Int64", + 3: "Uint32", + 4: "Uint64", + 5: "Sint32", + 6: "Sint64", + 7: "Sfixed32", + 8: "Sfixed64", + 9: "Fixed32", + 10: "Fixed64", + 11: "Float", + 12: "Double", + 13: "Bool", + 14: "Str", + 15: "Bytes", + 16: "ListInt32", + 17: "ListInt64", + 18: "ListUint32", + 19: "ListUint64", + 20: "ListSint32", + 21: "ListSint64", + 22: "ListSfixed32", + 23: "ListSfixed64", + 24: "ListFixed32", + 25: "ListFixed64", + 26: "ListFloat", + 27: "ListDouble", + 28: "ListBool", + 29: "ListString", + 30: "ListBytes", + 31: "MapInt64SINT32", + 32: "MapInt64Sfixed32", + 33: "MapInt64Fixed32", + 34: "MapInt64Uint32", + 35: "MapInt64Double", + 36: "MapInt64Bool", + 37: "MapInt64String", + 38: "MapInt64Bytes", + 39: "MapInt64Float", + 40: "MapInt64Int32", + 41: "MapstringSINT64", + 42: "MapstringSfixed64", + 43: "MapstringFixed64", + 44: "MapstringUint64", + 45: "MapstringDouble", + 46: "MapstringBool", + 47: "MapstringString", + 48: "MapstringBytes", + 49: "MapstringFloat", + 50: "MapstringInt64", +} diff --git a/testdata/kitex_gen/pb/base/basic_example.pb.go b/testdata/kitex_gen/pb/base/basic_example.pb.go new file mode 100644 index 00000000..a19387d8 --- /dev/null +++ b/testdata/kitex_gen/pb/base/basic_example.pb.go @@ -0,0 +1,827 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.28.1 +// protoc v5.26.1 +// source: idl/basic_example.proto + +package base + +import ( + context "context" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +type BasicExample struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Int32 int32 `protobuf:"varint,1,opt,name=Int32,proto3" json:"Int32,omitempty"` + Int64 int64 `protobuf:"varint,2,opt,name=Int64,proto3" json:"Int64,omitempty"` + Uint32 uint32 `protobuf:"varint,3,opt,name=Uint32,proto3" json:"Uint32,omitempty"` + Uint64 uint64 `protobuf:"varint,4,opt,name=Uint64,proto3" json:"Uint64,omitempty"` + Sint32 int32 `protobuf:"zigzag32,5,opt,name=Sint32,proto3" json:"Sint32,omitempty"` + Sint64 int64 `protobuf:"zigzag64,6,opt,name=Sint64,proto3" json:"Sint64,omitempty"` + Sfixed32 int32 `protobuf:"fixed32,7,opt,name=Sfixed32,proto3" json:"Sfixed32,omitempty"` + Sfixed64 int64 `protobuf:"fixed64,8,opt,name=Sfixed64,proto3" json:"Sfixed64,omitempty"` + Fixed32 uint32 `protobuf:"fixed32,9,opt,name=Fixed32,proto3" json:"Fixed32,omitempty"` + Fixed64 uint64 `protobuf:"fixed64,10,opt,name=Fixed64,proto3" json:"Fixed64,omitempty"` + Float float32 `protobuf:"fixed32,11,opt,name=Float,proto3" json:"Float,omitempty"` + Double float64 `protobuf:"fixed64,12,opt,name=Double,proto3" json:"Double,omitempty"` + Bool bool `protobuf:"varint,13,opt,name=Bool,proto3" json:"Bool,omitempty"` + Str string `protobuf:"bytes,14,opt,name=Str,proto3" json:"Str,omitempty"` + Bytes []byte `protobuf:"bytes,15,opt,name=Bytes,proto3" json:"Bytes,omitempty"` + ListInt32 []int32 `protobuf:"varint,16,rep,packed,name=ListInt32,proto3" json:"ListInt32,omitempty"` + ListInt64 []int64 `protobuf:"varint,17,rep,packed,name=ListInt64,proto3" json:"ListInt64,omitempty"` + ListUint32 []uint32 `protobuf:"varint,18,rep,packed,name=ListUint32,proto3" json:"ListUint32,omitempty"` + ListUint64 []uint64 `protobuf:"varint,19,rep,packed,name=ListUint64,proto3" json:"ListUint64,omitempty"` + ListSint32 []int32 `protobuf:"zigzag32,20,rep,packed,name=ListSint32,proto3" json:"ListSint32,omitempty"` + ListSint64 []int64 `protobuf:"zigzag64,21,rep,packed,name=ListSint64,proto3" json:"ListSint64,omitempty"` + ListSfixed32 []int32 `protobuf:"fixed32,22,rep,packed,name=ListSfixed32,proto3" json:"ListSfixed32,omitempty"` + ListSfixed64 []int64 `protobuf:"fixed64,23,rep,packed,name=ListSfixed64,proto3" json:"ListSfixed64,omitempty"` + ListFixed32 []uint32 `protobuf:"fixed32,24,rep,packed,name=ListFixed32,proto3" json:"ListFixed32,omitempty"` + ListFixed64 []uint64 `protobuf:"fixed64,25,rep,packed,name=ListFixed64,proto3" json:"ListFixed64,omitempty"` + ListFloat []float32 `protobuf:"fixed32,26,rep,packed,name=ListFloat,proto3" json:"ListFloat,omitempty"` + ListDouble []float64 `protobuf:"fixed64,27,rep,packed,name=ListDouble,proto3" json:"ListDouble,omitempty"` + ListBool []bool `protobuf:"varint,28,rep,packed,name=ListBool,proto3" json:"ListBool,omitempty"` + ListString []string `protobuf:"bytes,29,rep,name=ListString,proto3" json:"ListString,omitempty"` + ListBytes [][]byte `protobuf:"bytes,30,rep,name=ListBytes,proto3" json:"ListBytes,omitempty"` + MapInt64SINT32 map[int64]int32 `protobuf:"bytes,31,rep,name=MapInt64SINT32,proto3" json:"MapInt64SINT32,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"zigzag32,2,opt,name=value,proto3"` + MapInt64Sfixed32 map[int64]int32 `protobuf:"bytes,32,rep,name=MapInt64Sfixed32,proto3" json:"MapInt64Sfixed32,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"fixed32,2,opt,name=value,proto3"` + MapInt64Fixed32 map[int64]uint32 `protobuf:"bytes,33,rep,name=MapInt64Fixed32,proto3" json:"MapInt64Fixed32,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"fixed32,2,opt,name=value,proto3"` + MapInt64Uint32 map[int64]uint32 `protobuf:"bytes,34,rep,name=MapInt64Uint32,proto3" json:"MapInt64Uint32,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` + MapInt64Double map[int64]float64 `protobuf:"bytes,35,rep,name=MapInt64Double,proto3" json:"MapInt64Double,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"` + MapInt64Bool map[int64]bool `protobuf:"bytes,36,rep,name=MapInt64Bool,proto3" json:"MapInt64Bool,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` + MapInt64String map[int64]string `protobuf:"bytes,37,rep,name=MapInt64String,proto3" json:"MapInt64String,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + MapInt64Bytes map[int64][]byte `protobuf:"bytes,38,rep,name=MapInt64Bytes,proto3" json:"MapInt64Bytes,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + MapInt64Float map[int64]float32 `protobuf:"bytes,39,rep,name=MapInt64Float,proto3" json:"MapInt64Float,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"fixed32,2,opt,name=value,proto3"` + MapInt64Int32 map[int64]int32 `protobuf:"bytes,40,rep,name=MapInt64Int32,proto3" json:"MapInt64Int32,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` + MapstringSINT64 map[string]int64 `protobuf:"bytes,41,rep,name=MapstringSINT64,proto3" json:"MapstringSINT64,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"zigzag64,2,opt,name=value,proto3"` + MapstringSfixed64 map[string]int64 `protobuf:"bytes,42,rep,name=MapstringSfixed64,proto3" json:"MapstringSfixed64,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"` + MapstringFixed64 map[string]uint64 `protobuf:"bytes,43,rep,name=MapstringFixed64,proto3" json:"MapstringFixed64,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"` + MapstringUint64 map[string]uint64 `protobuf:"bytes,44,rep,name=MapstringUint64,proto3" json:"MapstringUint64,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` + MapstringDouble map[string]float64 `protobuf:"bytes,45,rep,name=MapstringDouble,proto3" json:"MapstringDouble,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"` + MapstringBool map[string]bool `protobuf:"bytes,46,rep,name=MapstringBool,proto3" json:"MapstringBool,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` + MapstringString map[string]string `protobuf:"bytes,47,rep,name=MapstringString,proto3" json:"MapstringString,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + MapstringBytes map[string][]byte `protobuf:"bytes,48,rep,name=MapstringBytes,proto3" json:"MapstringBytes,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + MapstringFloat map[string]float32 `protobuf:"bytes,49,rep,name=MapstringFloat,proto3" json:"MapstringFloat,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"fixed32,2,opt,name=value,proto3"` + MapstringInt64 map[string]int64 `protobuf:"bytes,50,rep,name=MapstringInt64,proto3" json:"MapstringInt64,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` +} + +func (x *BasicExample) Reset() { + *x = BasicExample{} + if protoimpl.UnsafeEnabled { + mi := &file_idl_basic_example_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *BasicExample) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*BasicExample) ProtoMessage() {} + +func (x *BasicExample) ProtoReflect() protoreflect.Message { + mi := &file_idl_basic_example_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use BasicExample.ProtoReflect.Descriptor instead. +func (*BasicExample) Descriptor() ([]byte, []int) { + return file_idl_basic_example_proto_rawDescGZIP(), []int{0} +} + +func (x *BasicExample) GetInt32() int32 { + if x != nil { + return x.Int32 + } + return 0 +} + +func (x *BasicExample) GetInt64() int64 { + if x != nil { + return x.Int64 + } + return 0 +} + +func (x *BasicExample) GetUint32() uint32 { + if x != nil { + return x.Uint32 + } + return 0 +} + +func (x *BasicExample) GetUint64() uint64 { + if x != nil { + return x.Uint64 + } + return 0 +} + +func (x *BasicExample) GetSint32() int32 { + if x != nil { + return x.Sint32 + } + return 0 +} + +func (x *BasicExample) GetSint64() int64 { + if x != nil { + return x.Sint64 + } + return 0 +} + +func (x *BasicExample) GetSfixed32() int32 { + if x != nil { + return x.Sfixed32 + } + return 0 +} + +func (x *BasicExample) GetSfixed64() int64 { + if x != nil { + return x.Sfixed64 + } + return 0 +} + +func (x *BasicExample) GetFixed32() uint32 { + if x != nil { + return x.Fixed32 + } + return 0 +} + +func (x *BasicExample) GetFixed64() uint64 { + if x != nil { + return x.Fixed64 + } + return 0 +} + +func (x *BasicExample) GetFloat() float32 { + if x != nil { + return x.Float + } + return 0 +} + +func (x *BasicExample) GetDouble() float64 { + if x != nil { + return x.Double + } + return 0 +} + +func (x *BasicExample) GetBool() bool { + if x != nil { + return x.Bool + } + return false +} + +func (x *BasicExample) GetStr() string { + if x != nil { + return x.Str + } + return "" +} + +func (x *BasicExample) GetBytes() []byte { + if x != nil { + return x.Bytes + } + return nil +} + +func (x *BasicExample) GetListInt32() []int32 { + if x != nil { + return x.ListInt32 + } + return nil +} + +func (x *BasicExample) GetListInt64() []int64 { + if x != nil { + return x.ListInt64 + } + return nil +} + +func (x *BasicExample) GetListUint32() []uint32 { + if x != nil { + return x.ListUint32 + } + return nil +} + +func (x *BasicExample) GetListUint64() []uint64 { + if x != nil { + return x.ListUint64 + } + return nil +} + +func (x *BasicExample) GetListSint32() []int32 { + if x != nil { + return x.ListSint32 + } + return nil +} + +func (x *BasicExample) GetListSint64() []int64 { + if x != nil { + return x.ListSint64 + } + return nil +} + +func (x *BasicExample) GetListSfixed32() []int32 { + if x != nil { + return x.ListSfixed32 + } + return nil +} + +func (x *BasicExample) GetListSfixed64() []int64 { + if x != nil { + return x.ListSfixed64 + } + return nil +} + +func (x *BasicExample) GetListFixed32() []uint32 { + if x != nil { + return x.ListFixed32 + } + return nil +} + +func (x *BasicExample) GetListFixed64() []uint64 { + if x != nil { + return x.ListFixed64 + } + return nil +} + +func (x *BasicExample) GetListFloat() []float32 { + if x != nil { + return x.ListFloat + } + return nil +} + +func (x *BasicExample) GetListDouble() []float64 { + if x != nil { + return x.ListDouble + } + return nil +} + +func (x *BasicExample) GetListBool() []bool { + if x != nil { + return x.ListBool + } + return nil +} + +func (x *BasicExample) GetListString() []string { + if x != nil { + return x.ListString + } + return nil +} + +func (x *BasicExample) GetListBytes() [][]byte { + if x != nil { + return x.ListBytes + } + return nil +} + +func (x *BasicExample) GetMapInt64SINT32() map[int64]int32 { + if x != nil { + return x.MapInt64SINT32 + } + return nil +} + +func (x *BasicExample) GetMapInt64Sfixed32() map[int64]int32 { + if x != nil { + return x.MapInt64Sfixed32 + } + return nil +} + +func (x *BasicExample) GetMapInt64Fixed32() map[int64]uint32 { + if x != nil { + return x.MapInt64Fixed32 + } + return nil +} + +func (x *BasicExample) GetMapInt64Uint32() map[int64]uint32 { + if x != nil { + return x.MapInt64Uint32 + } + return nil +} + +func (x *BasicExample) GetMapInt64Double() map[int64]float64 { + if x != nil { + return x.MapInt64Double + } + return nil +} + +func (x *BasicExample) GetMapInt64Bool() map[int64]bool { + if x != nil { + return x.MapInt64Bool + } + return nil +} + +func (x *BasicExample) GetMapInt64String() map[int64]string { + if x != nil { + return x.MapInt64String + } + return nil +} + +func (x *BasicExample) GetMapInt64Bytes() map[int64][]byte { + if x != nil { + return x.MapInt64Bytes + } + return nil +} + +func (x *BasicExample) GetMapInt64Float() map[int64]float32 { + if x != nil { + return x.MapInt64Float + } + return nil +} + +func (x *BasicExample) GetMapInt64Int32() map[int64]int32 { + if x != nil { + return x.MapInt64Int32 + } + return nil +} + +func (x *BasicExample) GetMapstringSINT64() map[string]int64 { + if x != nil { + return x.MapstringSINT64 + } + return nil +} + +func (x *BasicExample) GetMapstringSfixed64() map[string]int64 { + if x != nil { + return x.MapstringSfixed64 + } + return nil +} + +func (x *BasicExample) GetMapstringFixed64() map[string]uint64 { + if x != nil { + return x.MapstringFixed64 + } + return nil +} + +func (x *BasicExample) GetMapstringUint64() map[string]uint64 { + if x != nil { + return x.MapstringUint64 + } + return nil +} + +func (x *BasicExample) GetMapstringDouble() map[string]float64 { + if x != nil { + return x.MapstringDouble + } + return nil +} + +func (x *BasicExample) GetMapstringBool() map[string]bool { + if x != nil { + return x.MapstringBool + } + return nil +} + +func (x *BasicExample) GetMapstringString() map[string]string { + if x != nil { + return x.MapstringString + } + return nil +} + +func (x *BasicExample) GetMapstringBytes() map[string][]byte { + if x != nil { + return x.MapstringBytes + } + return nil +} + +func (x *BasicExample) GetMapstringFloat() map[string]float32 { + if x != nil { + return x.MapstringFloat + } + return nil +} + +func (x *BasicExample) GetMapstringInt64() map[string]int64 { + if x != nil { + return x.MapstringInt64 + } + return nil +} + +var File_idl_basic_example_proto protoreflect.FileDescriptor + +var file_idl_basic_example_proto_rawDesc = []byte{ + 0x0a, 0x17, 0x69, 0x64, 0x6c, 0x2f, 0x62, 0x61, 0x73, 0x69, 0x63, 0x5f, 0x65, 0x78, 0x61, 0x6d, + 0x70, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x03, 0x70, 0x62, 0x33, 0x22, 0xd0, + 0x1d, 0x0a, 0x0c, 0x42, 0x61, 0x73, 0x69, 0x63, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x12, + 0x14, 0x0a, 0x05, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, + 0x49, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x14, 0x0a, 0x05, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x16, 0x0a, 0x06, 0x55, + 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x06, 0x55, 0x69, 0x6e, + 0x74, 0x33, 0x32, 0x12, 0x16, 0x0a, 0x06, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x04, 0x20, + 0x01, 0x28, 0x04, 0x52, 0x06, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x16, 0x0a, 0x06, 0x53, + 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x05, 0x20, 0x01, 0x28, 0x11, 0x52, 0x06, 0x53, 0x69, 0x6e, + 0x74, 0x33, 0x32, 0x12, 0x16, 0x0a, 0x06, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x06, 0x20, + 0x01, 0x28, 0x12, 0x52, 0x06, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x1a, 0x0a, 0x08, 0x53, + 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0f, 0x52, 0x08, 0x53, + 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x1a, 0x0a, 0x08, 0x53, 0x66, 0x69, 0x78, 0x65, + 0x64, 0x36, 0x34, 0x18, 0x08, 0x20, 0x01, 0x28, 0x10, 0x52, 0x08, 0x53, 0x66, 0x69, 0x78, 0x65, + 0x64, 0x36, 0x34, 0x12, 0x18, 0x0a, 0x07, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x18, 0x09, + 0x20, 0x01, 0x28, 0x07, 0x52, 0x07, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x18, 0x0a, + 0x07, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x06, 0x52, 0x07, + 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x14, 0x0a, 0x05, 0x46, 0x6c, 0x6f, 0x61, 0x74, + 0x18, 0x0b, 0x20, 0x01, 0x28, 0x02, 0x52, 0x05, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x12, 0x16, 0x0a, + 0x06, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x01, 0x52, 0x06, 0x44, + 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x42, 0x6f, 0x6f, 0x6c, 0x18, 0x0d, 0x20, + 0x01, 0x28, 0x08, 0x52, 0x04, 0x42, 0x6f, 0x6f, 0x6c, 0x12, 0x10, 0x0a, 0x03, 0x53, 0x74, 0x72, + 0x18, 0x0e, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x53, 0x74, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x42, + 0x79, 0x74, 0x65, 0x73, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x42, 0x79, 0x74, 0x65, + 0x73, 0x12, 0x1c, 0x0a, 0x09, 0x4c, 0x69, 0x73, 0x74, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x10, + 0x20, 0x03, 0x28, 0x05, 0x52, 0x09, 0x4c, 0x69, 0x73, 0x74, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x12, + 0x1c, 0x0a, 0x09, 0x4c, 0x69, 0x73, 0x74, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x11, 0x20, 0x03, + 0x28, 0x03, 0x52, 0x09, 0x4c, 0x69, 0x73, 0x74, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x1e, 0x0a, + 0x0a, 0x4c, 0x69, 0x73, 0x74, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x12, 0x20, 0x03, 0x28, + 0x0d, 0x52, 0x0a, 0x4c, 0x69, 0x73, 0x74, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x1e, 0x0a, + 0x0a, 0x4c, 0x69, 0x73, 0x74, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x13, 0x20, 0x03, 0x28, + 0x04, 0x52, 0x0a, 0x4c, 0x69, 0x73, 0x74, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x1e, 0x0a, + 0x0a, 0x4c, 0x69, 0x73, 0x74, 0x53, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x14, 0x20, 0x03, 0x28, + 0x11, 0x52, 0x0a, 0x4c, 0x69, 0x73, 0x74, 0x53, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x1e, 0x0a, + 0x0a, 0x4c, 0x69, 0x73, 0x74, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x15, 0x20, 0x03, 0x28, + 0x12, 0x52, 0x0a, 0x4c, 0x69, 0x73, 0x74, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x22, 0x0a, + 0x0c, 0x4c, 0x69, 0x73, 0x74, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x18, 0x16, 0x20, + 0x03, 0x28, 0x0f, 0x52, 0x0c, 0x4c, 0x69, 0x73, 0x74, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, + 0x32, 0x12, 0x22, 0x0a, 0x0c, 0x4c, 0x69, 0x73, 0x74, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, + 0x34, 0x18, 0x17, 0x20, 0x03, 0x28, 0x10, 0x52, 0x0c, 0x4c, 0x69, 0x73, 0x74, 0x53, 0x66, 0x69, + 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x20, 0x0a, 0x0b, 0x4c, 0x69, 0x73, 0x74, 0x46, 0x69, 0x78, + 0x65, 0x64, 0x33, 0x32, 0x18, 0x18, 0x20, 0x03, 0x28, 0x07, 0x52, 0x0b, 0x4c, 0x69, 0x73, 0x74, + 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x20, 0x0a, 0x0b, 0x4c, 0x69, 0x73, 0x74, 0x46, + 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0x19, 0x20, 0x03, 0x28, 0x06, 0x52, 0x0b, 0x4c, 0x69, + 0x73, 0x74, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x1c, 0x0a, 0x09, 0x4c, 0x69, 0x73, + 0x74, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x18, 0x1a, 0x20, 0x03, 0x28, 0x02, 0x52, 0x09, 0x4c, 0x69, + 0x73, 0x74, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x12, 0x1e, 0x0a, 0x0a, 0x4c, 0x69, 0x73, 0x74, 0x44, + 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x18, 0x1b, 0x20, 0x03, 0x28, 0x01, 0x52, 0x0a, 0x4c, 0x69, 0x73, + 0x74, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x4c, 0x69, 0x73, 0x74, 0x42, + 0x6f, 0x6f, 0x6c, 0x18, 0x1c, 0x20, 0x03, 0x28, 0x08, 0x52, 0x08, 0x4c, 0x69, 0x73, 0x74, 0x42, + 0x6f, 0x6f, 0x6c, 0x12, 0x1e, 0x0a, 0x0a, 0x4c, 0x69, 0x73, 0x74, 0x53, 0x74, 0x72, 0x69, 0x6e, + 0x67, 0x18, 0x1d, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x4c, 0x69, 0x73, 0x74, 0x53, 0x74, 0x72, + 0x69, 0x6e, 0x67, 0x12, 0x1c, 0x0a, 0x09, 0x4c, 0x69, 0x73, 0x74, 0x42, 0x79, 0x74, 0x65, 0x73, + 0x18, 0x1e, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x09, 0x4c, 0x69, 0x73, 0x74, 0x42, 0x79, 0x74, 0x65, + 0x73, 0x12, 0x4d, 0x0a, 0x0e, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x53, 0x49, 0x4e, + 0x54, 0x33, 0x32, 0x18, 0x1f, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x70, 0x62, 0x33, 0x2e, + 0x42, 0x61, 0x73, 0x69, 0x63, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x2e, 0x4d, 0x61, 0x70, + 0x49, 0x6e, 0x74, 0x36, 0x34, 0x53, 0x49, 0x4e, 0x54, 0x33, 0x32, 0x45, 0x6e, 0x74, 0x72, 0x79, + 0x52, 0x0e, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x53, 0x49, 0x4e, 0x54, 0x33, 0x32, + 0x12, 0x53, 0x0a, 0x10, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x53, 0x66, 0x69, 0x78, + 0x65, 0x64, 0x33, 0x32, 0x18, 0x20, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x70, 0x62, 0x33, + 0x2e, 0x42, 0x61, 0x73, 0x69, 0x63, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x2e, 0x4d, 0x61, + 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x45, 0x6e, + 0x74, 0x72, 0x79, 0x52, 0x10, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x53, 0x66, 0x69, + 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x50, 0x0a, 0x0f, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, + 0x34, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x18, 0x21, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x26, + 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x42, 0x61, 0x73, 0x69, 0x63, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, + 0x65, 0x2e, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, + 0x32, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0f, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, + 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x4d, 0x0a, 0x0e, 0x4d, 0x61, 0x70, 0x49, 0x6e, + 0x74, 0x36, 0x34, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x22, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x25, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x42, 0x61, 0x73, 0x69, 0x63, 0x45, 0x78, 0x61, 0x6d, 0x70, + 0x6c, 0x65, 0x2e, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x55, 0x69, 0x6e, 0x74, 0x33, + 0x32, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0e, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, + 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x4d, 0x0a, 0x0e, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, + 0x36, 0x34, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x18, 0x23, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x25, + 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x42, 0x61, 0x73, 0x69, 0x63, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, + 0x65, 0x2e, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, + 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0e, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x44, + 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x12, 0x47, 0x0a, 0x0c, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, + 0x34, 0x42, 0x6f, 0x6f, 0x6c, 0x18, 0x24, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x70, 0x62, + 0x33, 0x2e, 0x42, 0x61, 0x73, 0x69, 0x63, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x2e, 0x4d, + 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x42, 0x6f, 0x6f, 0x6c, 0x45, 0x6e, 0x74, 0x72, 0x79, + 0x52, 0x0c, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x42, 0x6f, 0x6f, 0x6c, 0x12, 0x4d, + 0x0a, 0x0e, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, + 0x18, 0x25, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x42, 0x61, 0x73, + 0x69, 0x63, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x2e, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, + 0x36, 0x34, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0e, 0x4d, + 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x4a, 0x0a, + 0x0d, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x42, 0x79, 0x74, 0x65, 0x73, 0x18, 0x26, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x42, 0x61, 0x73, 0x69, 0x63, + 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x2e, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, + 0x42, 0x79, 0x74, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0d, 0x4d, 0x61, 0x70, 0x49, + 0x6e, 0x74, 0x36, 0x34, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x4a, 0x0a, 0x0d, 0x4d, 0x61, 0x70, + 0x49, 0x6e, 0x74, 0x36, 0x34, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x18, 0x27, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x24, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x42, 0x61, 0x73, 0x69, 0x63, 0x45, 0x78, 0x61, 0x6d, + 0x70, 0x6c, 0x65, 0x2e, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x46, 0x6c, 0x6f, 0x61, + 0x74, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0d, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, + 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x12, 0x4a, 0x0a, 0x0d, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, + 0x34, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x28, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x70, + 0x62, 0x33, 0x2e, 0x42, 0x61, 0x73, 0x69, 0x63, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x2e, + 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x45, 0x6e, 0x74, + 0x72, 0x79, 0x52, 0x0d, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x49, 0x6e, 0x74, 0x33, + 0x32, 0x12, 0x50, 0x0a, 0x0f, 0x4d, 0x61, 0x70, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x53, 0x49, + 0x4e, 0x54, 0x36, 0x34, 0x18, 0x29, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x70, 0x62, 0x33, + 0x2e, 0x42, 0x61, 0x73, 0x69, 0x63, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x2e, 0x4d, 0x61, + 0x70, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x53, 0x49, 0x4e, 0x54, 0x36, 0x34, 0x45, 0x6e, 0x74, + 0x72, 0x79, 0x52, 0x0f, 0x4d, 0x61, 0x70, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x53, 0x49, 0x4e, + 0x54, 0x36, 0x34, 0x12, 0x56, 0x0a, 0x11, 0x4d, 0x61, 0x70, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, + 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0x2a, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, + 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x42, 0x61, 0x73, 0x69, 0x63, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, + 0x65, 0x2e, 0x4d, 0x61, 0x70, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x53, 0x66, 0x69, 0x78, 0x65, + 0x64, 0x36, 0x34, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x11, 0x4d, 0x61, 0x70, 0x73, 0x74, 0x72, + 0x69, 0x6e, 0x67, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x53, 0x0a, 0x10, 0x4d, + 0x61, 0x70, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, + 0x2b, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x42, 0x61, 0x73, 0x69, + 0x63, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x2e, 0x4d, 0x61, 0x70, 0x73, 0x74, 0x72, 0x69, + 0x6e, 0x67, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x10, + 0x4d, 0x61, 0x70, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, + 0x12, 0x50, 0x0a, 0x0f, 0x4d, 0x61, 0x70, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x55, 0x69, 0x6e, + 0x74, 0x36, 0x34, 0x18, 0x2c, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x70, 0x62, 0x33, 0x2e, + 0x42, 0x61, 0x73, 0x69, 0x63, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x2e, 0x4d, 0x61, 0x70, + 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x45, 0x6e, 0x74, 0x72, + 0x79, 0x52, 0x0f, 0x4d, 0x61, 0x70, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x55, 0x69, 0x6e, 0x74, + 0x36, 0x34, 0x12, 0x50, 0x0a, 0x0f, 0x4d, 0x61, 0x70, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x44, + 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x18, 0x2d, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x70, 0x62, + 0x33, 0x2e, 0x42, 0x61, 0x73, 0x69, 0x63, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x2e, 0x4d, + 0x61, 0x70, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x45, 0x6e, + 0x74, 0x72, 0x79, 0x52, 0x0f, 0x4d, 0x61, 0x70, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x44, 0x6f, + 0x75, 0x62, 0x6c, 0x65, 0x12, 0x4a, 0x0a, 0x0d, 0x4d, 0x61, 0x70, 0x73, 0x74, 0x72, 0x69, 0x6e, + 0x67, 0x42, 0x6f, 0x6f, 0x6c, 0x18, 0x2e, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x70, 0x62, + 0x33, 0x2e, 0x42, 0x61, 0x73, 0x69, 0x63, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x2e, 0x4d, + 0x61, 0x70, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x42, 0x6f, 0x6f, 0x6c, 0x45, 0x6e, 0x74, 0x72, + 0x79, 0x52, 0x0d, 0x4d, 0x61, 0x70, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x42, 0x6f, 0x6f, 0x6c, + 0x12, 0x50, 0x0a, 0x0f, 0x4d, 0x61, 0x70, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x72, + 0x69, 0x6e, 0x67, 0x18, 0x2f, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x70, 0x62, 0x33, 0x2e, + 0x42, 0x61, 0x73, 0x69, 0x63, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x2e, 0x4d, 0x61, 0x70, + 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x45, 0x6e, 0x74, 0x72, + 0x79, 0x52, 0x0f, 0x4d, 0x61, 0x70, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x72, 0x69, + 0x6e, 0x67, 0x12, 0x4d, 0x0a, 0x0e, 0x4d, 0x61, 0x70, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x42, + 0x79, 0x74, 0x65, 0x73, 0x18, 0x30, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x70, 0x62, 0x33, + 0x2e, 0x42, 0x61, 0x73, 0x69, 0x63, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x2e, 0x4d, 0x61, + 0x70, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x42, 0x79, 0x74, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, + 0x79, 0x52, 0x0e, 0x4d, 0x61, 0x70, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x42, 0x79, 0x74, 0x65, + 0x73, 0x12, 0x4d, 0x0a, 0x0e, 0x4d, 0x61, 0x70, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x46, 0x6c, + 0x6f, 0x61, 0x74, 0x18, 0x31, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x70, 0x62, 0x33, 0x2e, + 0x42, 0x61, 0x73, 0x69, 0x63, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x2e, 0x4d, 0x61, 0x70, + 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x45, 0x6e, 0x74, 0x72, 0x79, + 0x52, 0x0e, 0x4d, 0x61, 0x70, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x46, 0x6c, 0x6f, 0x61, 0x74, + 0x12, 0x4d, 0x0a, 0x0e, 0x4d, 0x61, 0x70, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x49, 0x6e, 0x74, + 0x36, 0x34, 0x18, 0x32, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x42, + 0x61, 0x73, 0x69, 0x63, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x2e, 0x4d, 0x61, 0x70, 0x73, + 0x74, 0x72, 0x69, 0x6e, 0x67, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, + 0x0e, 0x4d, 0x61, 0x70, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x1a, + 0x41, 0x0a, 0x13, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x53, 0x49, 0x4e, 0x54, 0x33, + 0x32, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x11, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, + 0x38, 0x01, 0x1a, 0x43, 0x0a, 0x15, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x53, 0x66, + 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, + 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, + 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0f, 0x52, 0x05, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x42, 0x0a, 0x14, 0x4d, 0x61, 0x70, 0x49, 0x6e, + 0x74, 0x36, 0x34, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, + 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, + 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x07, + 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x41, 0x0a, 0x13, 0x4d, + 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x45, 0x6e, 0x74, + 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, + 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0d, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x41, + 0x0a, 0x13, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, + 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x01, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, + 0x01, 0x1a, 0x3f, 0x0a, 0x11, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x42, 0x6f, 0x6f, + 0x6c, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, + 0x38, 0x01, 0x1a, 0x41, 0x0a, 0x13, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x53, 0x74, + 0x72, 0x69, 0x6e, 0x67, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x40, 0x0a, 0x12, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, + 0x34, 0x42, 0x79, 0x74, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, + 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, + 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x40, 0x0a, 0x12, 0x4d, 0x61, 0x70, 0x49, 0x6e, + 0x74, 0x36, 0x34, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, + 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, + 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x02, 0x52, 0x05, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x40, 0x0a, 0x12, 0x4d, 0x61, 0x70, + 0x49, 0x6e, 0x74, 0x36, 0x34, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, + 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, + 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, + 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x42, 0x0a, 0x14, 0x4d, + 0x61, 0x70, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x53, 0x49, 0x4e, 0x54, 0x36, 0x34, 0x45, 0x6e, + 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x12, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, + 0x44, 0x0a, 0x16, 0x4d, 0x61, 0x70, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x53, 0x66, 0x69, 0x78, + 0x65, 0x64, 0x36, 0x34, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x10, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x43, 0x0a, 0x15, 0x4d, 0x61, 0x70, 0x73, 0x74, 0x72, 0x69, + 0x6e, 0x67, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, + 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, + 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x06, 0x52, + 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x42, 0x0a, 0x14, 0x4d, 0x61, + 0x70, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x45, 0x6e, 0x74, + 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x04, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x42, + 0x0a, 0x14, 0x4d, 0x61, 0x70, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x44, 0x6f, 0x75, 0x62, 0x6c, + 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x01, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, + 0x38, 0x01, 0x1a, 0x40, 0x0a, 0x12, 0x4d, 0x61, 0x70, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x42, + 0x6f, 0x6f, 0x6c, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x42, 0x0a, 0x14, 0x4d, 0x61, 0x70, 0x73, 0x74, 0x72, 0x69, 0x6e, + 0x67, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, + 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, + 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x41, 0x0a, 0x13, 0x4d, 0x61, 0x70, 0x73, + 0x74, 0x72, 0x69, 0x6e, 0x67, 0x42, 0x79, 0x74, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, + 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, + 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, + 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x41, 0x0a, 0x13, 0x4d, + 0x61, 0x70, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x45, 0x6e, 0x74, + 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x02, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x41, + 0x0a, 0x13, 0x4d, 0x61, 0x70, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x49, 0x6e, 0x74, 0x36, 0x34, + 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, + 0x01, 0x32, 0x45, 0x0a, 0x0c, 0x42, 0x61, 0x73, 0x69, 0x63, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, + 0x65, 0x12, 0x35, 0x0a, 0x0d, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x4d, 0x65, 0x74, 0x68, + 0x6f, 0x64, 0x12, 0x11, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x42, 0x61, 0x73, 0x69, 0x63, 0x45, 0x78, + 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x1a, 0x11, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x42, 0x61, 0x73, 0x69, + 0x63, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x42, 0x3b, 0x5a, 0x39, 0x67, 0x69, 0x74, 0x68, + 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x63, 0x6c, 0x6f, 0x75, 0x64, 0x77, 0x65, 0x67, 0x6f, + 0x2f, 0x64, 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, + 0x61, 0x74, 0x61, 0x2f, 0x6b, 0x69, 0x74, 0x65, 0x78, 0x5f, 0x67, 0x65, 0x6e, 0x2f, 0x70, 0x62, + 0x2f, 0x62, 0x61, 0x73, 0x65, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_idl_basic_example_proto_rawDescOnce sync.Once + file_idl_basic_example_proto_rawDescData = file_idl_basic_example_proto_rawDesc +) + +func file_idl_basic_example_proto_rawDescGZIP() []byte { + file_idl_basic_example_proto_rawDescOnce.Do(func() { + file_idl_basic_example_proto_rawDescData = protoimpl.X.CompressGZIP(file_idl_basic_example_proto_rawDescData) + }) + return file_idl_basic_example_proto_rawDescData +} + +var file_idl_basic_example_proto_msgTypes = make([]protoimpl.MessageInfo, 21) +var file_idl_basic_example_proto_goTypes = []interface{}{ + (*BasicExample)(nil), // 0: pb3.BasicExample + nil, // 1: pb3.BasicExample.MapInt64SINT32Entry + nil, // 2: pb3.BasicExample.MapInt64Sfixed32Entry + nil, // 3: pb3.BasicExample.MapInt64Fixed32Entry + nil, // 4: pb3.BasicExample.MapInt64Uint32Entry + nil, // 5: pb3.BasicExample.MapInt64DoubleEntry + nil, // 6: pb3.BasicExample.MapInt64BoolEntry + nil, // 7: pb3.BasicExample.MapInt64StringEntry + nil, // 8: pb3.BasicExample.MapInt64BytesEntry + nil, // 9: pb3.BasicExample.MapInt64FloatEntry + nil, // 10: pb3.BasicExample.MapInt64Int32Entry + nil, // 11: pb3.BasicExample.MapstringSINT64Entry + nil, // 12: pb3.BasicExample.MapstringSfixed64Entry + nil, // 13: pb3.BasicExample.MapstringFixed64Entry + nil, // 14: pb3.BasicExample.MapstringUint64Entry + nil, // 15: pb3.BasicExample.MapstringDoubleEntry + nil, // 16: pb3.BasicExample.MapstringBoolEntry + nil, // 17: pb3.BasicExample.MapstringStringEntry + nil, // 18: pb3.BasicExample.MapstringBytesEntry + nil, // 19: pb3.BasicExample.MapstringFloatEntry + nil, // 20: pb3.BasicExample.MapstringInt64Entry +} +var file_idl_basic_example_proto_depIdxs = []int32{ + 1, // 0: pb3.BasicExample.MapInt64SINT32:type_name -> pb3.BasicExample.MapInt64SINT32Entry + 2, // 1: pb3.BasicExample.MapInt64Sfixed32:type_name -> pb3.BasicExample.MapInt64Sfixed32Entry + 3, // 2: pb3.BasicExample.MapInt64Fixed32:type_name -> pb3.BasicExample.MapInt64Fixed32Entry + 4, // 3: pb3.BasicExample.MapInt64Uint32:type_name -> pb3.BasicExample.MapInt64Uint32Entry + 5, // 4: pb3.BasicExample.MapInt64Double:type_name -> pb3.BasicExample.MapInt64DoubleEntry + 6, // 5: pb3.BasicExample.MapInt64Bool:type_name -> pb3.BasicExample.MapInt64BoolEntry + 7, // 6: pb3.BasicExample.MapInt64String:type_name -> pb3.BasicExample.MapInt64StringEntry + 8, // 7: pb3.BasicExample.MapInt64Bytes:type_name -> pb3.BasicExample.MapInt64BytesEntry + 9, // 8: pb3.BasicExample.MapInt64Float:type_name -> pb3.BasicExample.MapInt64FloatEntry + 10, // 9: pb3.BasicExample.MapInt64Int32:type_name -> pb3.BasicExample.MapInt64Int32Entry + 11, // 10: pb3.BasicExample.MapstringSINT64:type_name -> pb3.BasicExample.MapstringSINT64Entry + 12, // 11: pb3.BasicExample.MapstringSfixed64:type_name -> pb3.BasicExample.MapstringSfixed64Entry + 13, // 12: pb3.BasicExample.MapstringFixed64:type_name -> pb3.BasicExample.MapstringFixed64Entry + 14, // 13: pb3.BasicExample.MapstringUint64:type_name -> pb3.BasicExample.MapstringUint64Entry + 15, // 14: pb3.BasicExample.MapstringDouble:type_name -> pb3.BasicExample.MapstringDoubleEntry + 16, // 15: pb3.BasicExample.MapstringBool:type_name -> pb3.BasicExample.MapstringBoolEntry + 17, // 16: pb3.BasicExample.MapstringString:type_name -> pb3.BasicExample.MapstringStringEntry + 18, // 17: pb3.BasicExample.MapstringBytes:type_name -> pb3.BasicExample.MapstringBytesEntry + 19, // 18: pb3.BasicExample.MapstringFloat:type_name -> pb3.BasicExample.MapstringFloatEntry + 20, // 19: pb3.BasicExample.MapstringInt64:type_name -> pb3.BasicExample.MapstringInt64Entry + 0, // 20: pb3.BasicService.ExampleMethod:input_type -> pb3.BasicExample + 0, // 21: pb3.BasicService.ExampleMethod:output_type -> pb3.BasicExample + 21, // [21:22] is the sub-list for method output_type + 20, // [20:21] is the sub-list for method input_type + 20, // [20:20] is the sub-list for extension type_name + 20, // [20:20] is the sub-list for extension extendee + 0, // [0:20] is the sub-list for field type_name +} + +func init() { file_idl_basic_example_proto_init() } +func file_idl_basic_example_proto_init() { + if File_idl_basic_example_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_idl_basic_example_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*BasicExample); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_idl_basic_example_proto_rawDesc, + NumEnums: 0, + NumMessages: 21, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_idl_basic_example_proto_goTypes, + DependencyIndexes: file_idl_basic_example_proto_depIdxs, + MessageInfos: file_idl_basic_example_proto_msgTypes, + }.Build() + File_idl_basic_example_proto = out.File + file_idl_basic_example_proto_rawDesc = nil + file_idl_basic_example_proto_goTypes = nil + file_idl_basic_example_proto_depIdxs = nil +} + +var _ context.Context + +// Code generated by Kitex v0.9.1. DO NOT EDIT. + +type BasicService interface { + ExampleMethod(ctx context.Context, req *BasicExample) (res *BasicExample, err error) +} diff --git a/testdata/kitex_gen/pb/baseline/baselineservice/baselineservice.go b/testdata/kitex_gen/pb/baseline/baselineservice/baselineservice.go deleted file mode 100644 index 5aba65ed..00000000 --- a/testdata/kitex_gen/pb/baseline/baselineservice/baselineservice.go +++ /dev/null @@ -1,868 +0,0 @@ -// Code generated by Kitex v0.5.2. DO NOT EDIT. - -package baselineservice - -import ( - "context" - "fmt" - baseline "github.com/cloudwego/dynamicgo/testdata/kitex_gen/pb/baseline" - client "github.com/cloudwego/kitex/client" - kitex "github.com/cloudwego/kitex/pkg/serviceinfo" - streaming "github.com/cloudwego/kitex/pkg/streaming" - proto "google.golang.org/protobuf/proto" -) - -func serviceInfo() *kitex.ServiceInfo { - return baselineServiceServiceInfo -} - -var baselineServiceServiceInfo = NewServiceInfo() - -func NewServiceInfo() *kitex.ServiceInfo { - serviceName := "BaselineService" - handlerType := (*baseline.BaselineService)(nil) - methods := map[string]kitex.MethodInfo{ - "SimpleMethod": kitex.NewMethodInfo(simpleMethodHandler, newSimpleMethodArgs, newSimpleMethodResult, false), - "PartialSimpleMethod": kitex.NewMethodInfo(partialSimpleMethodHandler, newPartialSimpleMethodArgs, newPartialSimpleMethodResult, false), - "NestingMethod": kitex.NewMethodInfo(nestingMethodHandler, newNestingMethodArgs, newNestingMethodResult, false), - "PartialNestingMethod": kitex.NewMethodInfo(partialNestingMethodHandler, newPartialNestingMethodArgs, newPartialNestingMethodResult, false), - "Nesting2Method": kitex.NewMethodInfo(nesting2MethodHandler, newNesting2MethodArgs, newNesting2MethodResult, false), - } - extra := map[string]interface{}{ - "PackageName": "pb3", - } - svcInfo := &kitex.ServiceInfo{ - ServiceName: serviceName, - HandlerType: handlerType, - Methods: methods, - PayloadCodec: kitex.Protobuf, - KiteXGenVersion: "v0.5.2", - Extra: extra, - } - return svcInfo -} - -func simpleMethodHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { - switch s := arg.(type) { - case *streaming.Args: - st := s.Stream - req := new(baseline.Simple) - if err := st.RecvMsg(req); err != nil { - return err - } - resp, err := handler.(baseline.BaselineService).SimpleMethod(ctx, req) - if err != nil { - return err - } - if err := st.SendMsg(resp); err != nil { - return err - } - case *SimpleMethodArgs: - success, err := handler.(baseline.BaselineService).SimpleMethod(ctx, s.Req) - if err != nil { - return err - } - realResult := result.(*SimpleMethodResult) - realResult.Success = success - } - return nil -} -func newSimpleMethodArgs() interface{} { - return &SimpleMethodArgs{} -} - -func newSimpleMethodResult() interface{} { - return &SimpleMethodResult{} -} - -type SimpleMethodArgs struct { - Req *baseline.Simple -} - -func (p *SimpleMethodArgs) FastRead(buf []byte, _type int8, number int32) (n int, err error) { - if !p.IsSetReq() { - p.Req = new(baseline.Simple) - } - return p.Req.FastRead(buf, _type, number) -} - -func (p *SimpleMethodArgs) FastWrite(buf []byte) (n int) { - if !p.IsSetReq() { - return 0 - } - return p.Req.FastWrite(buf) -} - -func (p *SimpleMethodArgs) Size() (n int) { - if !p.IsSetReq() { - return 0 - } - return p.Req.Size() -} - -func (p *SimpleMethodArgs) Marshal(out []byte) ([]byte, error) { - if !p.IsSetReq() { - return out, fmt.Errorf("No req in SimpleMethodArgs") - } - return proto.Marshal(p.Req) -} - -func (p *SimpleMethodArgs) Unmarshal(in []byte) error { - msg := new(baseline.Simple) - if err := proto.Unmarshal(in, msg); err != nil { - return err - } - p.Req = msg - return nil -} - -var SimpleMethodArgs_Req_DEFAULT *baseline.Simple - -func (p *SimpleMethodArgs) GetReq() *baseline.Simple { - if !p.IsSetReq() { - return SimpleMethodArgs_Req_DEFAULT - } - return p.Req -} - -func (p *SimpleMethodArgs) IsSetReq() bool { - return p.Req != nil -} - -func (p *SimpleMethodArgs) GetFirstArgument() interface{} { - return p.Req -} - -type SimpleMethodResult struct { - Success *baseline.Simple -} - -var SimpleMethodResult_Success_DEFAULT *baseline.Simple - -func (p *SimpleMethodResult) FastRead(buf []byte, _type int8, number int32) (n int, err error) { - if !p.IsSetSuccess() { - p.Success = new(baseline.Simple) - } - return p.Success.FastRead(buf, _type, number) -} - -func (p *SimpleMethodResult) FastWrite(buf []byte) (n int) { - if !p.IsSetSuccess() { - return 0 - } - return p.Success.FastWrite(buf) -} - -func (p *SimpleMethodResult) Size() (n int) { - if !p.IsSetSuccess() { - return 0 - } - return p.Success.Size() -} - -func (p *SimpleMethodResult) Marshal(out []byte) ([]byte, error) { - if !p.IsSetSuccess() { - return out, fmt.Errorf("No req in SimpleMethodResult") - } - return proto.Marshal(p.Success) -} - -func (p *SimpleMethodResult) Unmarshal(in []byte) error { - msg := new(baseline.Simple) - if err := proto.Unmarshal(in, msg); err != nil { - return err - } - p.Success = msg - return nil -} - -func (p *SimpleMethodResult) GetSuccess() *baseline.Simple { - if !p.IsSetSuccess() { - return SimpleMethodResult_Success_DEFAULT - } - return p.Success -} - -func (p *SimpleMethodResult) SetSuccess(x interface{}) { - p.Success = x.(*baseline.Simple) -} - -func (p *SimpleMethodResult) IsSetSuccess() bool { - return p.Success != nil -} - -func (p *SimpleMethodResult) GetResult() interface{} { - return p.Success -} - -func partialSimpleMethodHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { - switch s := arg.(type) { - case *streaming.Args: - st := s.Stream - req := new(baseline.PartialSimple) - if err := st.RecvMsg(req); err != nil { - return err - } - resp, err := handler.(baseline.BaselineService).PartialSimpleMethod(ctx, req) - if err != nil { - return err - } - if err := st.SendMsg(resp); err != nil { - return err - } - case *PartialSimpleMethodArgs: - success, err := handler.(baseline.BaselineService).PartialSimpleMethod(ctx, s.Req) - if err != nil { - return err - } - realResult := result.(*PartialSimpleMethodResult) - realResult.Success = success - } - return nil -} -func newPartialSimpleMethodArgs() interface{} { - return &PartialSimpleMethodArgs{} -} - -func newPartialSimpleMethodResult() interface{} { - return &PartialSimpleMethodResult{} -} - -type PartialSimpleMethodArgs struct { - Req *baseline.PartialSimple -} - -func (p *PartialSimpleMethodArgs) FastRead(buf []byte, _type int8, number int32) (n int, err error) { - if !p.IsSetReq() { - p.Req = new(baseline.PartialSimple) - } - return p.Req.FastRead(buf, _type, number) -} - -func (p *PartialSimpleMethodArgs) FastWrite(buf []byte) (n int) { - if !p.IsSetReq() { - return 0 - } - return p.Req.FastWrite(buf) -} - -func (p *PartialSimpleMethodArgs) Size() (n int) { - if !p.IsSetReq() { - return 0 - } - return p.Req.Size() -} - -func (p *PartialSimpleMethodArgs) Marshal(out []byte) ([]byte, error) { - if !p.IsSetReq() { - return out, fmt.Errorf("No req in PartialSimpleMethodArgs") - } - return proto.Marshal(p.Req) -} - -func (p *PartialSimpleMethodArgs) Unmarshal(in []byte) error { - msg := new(baseline.PartialSimple) - if err := proto.Unmarshal(in, msg); err != nil { - return err - } - p.Req = msg - return nil -} - -var PartialSimpleMethodArgs_Req_DEFAULT *baseline.PartialSimple - -func (p *PartialSimpleMethodArgs) GetReq() *baseline.PartialSimple { - if !p.IsSetReq() { - return PartialSimpleMethodArgs_Req_DEFAULT - } - return p.Req -} - -func (p *PartialSimpleMethodArgs) IsSetReq() bool { - return p.Req != nil -} - -func (p *PartialSimpleMethodArgs) GetFirstArgument() interface{} { - return p.Req -} - -type PartialSimpleMethodResult struct { - Success *baseline.PartialSimple -} - -var PartialSimpleMethodResult_Success_DEFAULT *baseline.PartialSimple - -func (p *PartialSimpleMethodResult) FastRead(buf []byte, _type int8, number int32) (n int, err error) { - if !p.IsSetSuccess() { - p.Success = new(baseline.PartialSimple) - } - return p.Success.FastRead(buf, _type, number) -} - -func (p *PartialSimpleMethodResult) FastWrite(buf []byte) (n int) { - if !p.IsSetSuccess() { - return 0 - } - return p.Success.FastWrite(buf) -} - -func (p *PartialSimpleMethodResult) Size() (n int) { - if !p.IsSetSuccess() { - return 0 - } - return p.Success.Size() -} - -func (p *PartialSimpleMethodResult) Marshal(out []byte) ([]byte, error) { - if !p.IsSetSuccess() { - return out, fmt.Errorf("No req in PartialSimpleMethodResult") - } - return proto.Marshal(p.Success) -} - -func (p *PartialSimpleMethodResult) Unmarshal(in []byte) error { - msg := new(baseline.PartialSimple) - if err := proto.Unmarshal(in, msg); err != nil { - return err - } - p.Success = msg - return nil -} - -func (p *PartialSimpleMethodResult) GetSuccess() *baseline.PartialSimple { - if !p.IsSetSuccess() { - return PartialSimpleMethodResult_Success_DEFAULT - } - return p.Success -} - -func (p *PartialSimpleMethodResult) SetSuccess(x interface{}) { - p.Success = x.(*baseline.PartialSimple) -} - -func (p *PartialSimpleMethodResult) IsSetSuccess() bool { - return p.Success != nil -} - -func (p *PartialSimpleMethodResult) GetResult() interface{} { - return p.Success -} - -func nestingMethodHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { - switch s := arg.(type) { - case *streaming.Args: - st := s.Stream - req := new(baseline.Nesting) - if err := st.RecvMsg(req); err != nil { - return err - } - resp, err := handler.(baseline.BaselineService).NestingMethod(ctx, req) - if err != nil { - return err - } - if err := st.SendMsg(resp); err != nil { - return err - } - case *NestingMethodArgs: - success, err := handler.(baseline.BaselineService).NestingMethod(ctx, s.Req) - if err != nil { - return err - } - realResult := result.(*NestingMethodResult) - realResult.Success = success - } - return nil -} -func newNestingMethodArgs() interface{} { - return &NestingMethodArgs{} -} - -func newNestingMethodResult() interface{} { - return &NestingMethodResult{} -} - -type NestingMethodArgs struct { - Req *baseline.Nesting -} - -func (p *NestingMethodArgs) FastRead(buf []byte, _type int8, number int32) (n int, err error) { - if !p.IsSetReq() { - p.Req = new(baseline.Nesting) - } - return p.Req.FastRead(buf, _type, number) -} - -func (p *NestingMethodArgs) FastWrite(buf []byte) (n int) { - if !p.IsSetReq() { - return 0 - } - return p.Req.FastWrite(buf) -} - -func (p *NestingMethodArgs) Size() (n int) { - if !p.IsSetReq() { - return 0 - } - return p.Req.Size() -} - -func (p *NestingMethodArgs) Marshal(out []byte) ([]byte, error) { - if !p.IsSetReq() { - return out, fmt.Errorf("No req in NestingMethodArgs") - } - return proto.Marshal(p.Req) -} - -func (p *NestingMethodArgs) Unmarshal(in []byte) error { - msg := new(baseline.Nesting) - if err := proto.Unmarshal(in, msg); err != nil { - return err - } - p.Req = msg - return nil -} - -var NestingMethodArgs_Req_DEFAULT *baseline.Nesting - -func (p *NestingMethodArgs) GetReq() *baseline.Nesting { - if !p.IsSetReq() { - return NestingMethodArgs_Req_DEFAULT - } - return p.Req -} - -func (p *NestingMethodArgs) IsSetReq() bool { - return p.Req != nil -} - -func (p *NestingMethodArgs) GetFirstArgument() interface{} { - return p.Req -} - -type NestingMethodResult struct { - Success *baseline.Nesting -} - -var NestingMethodResult_Success_DEFAULT *baseline.Nesting - -func (p *NestingMethodResult) FastRead(buf []byte, _type int8, number int32) (n int, err error) { - if !p.IsSetSuccess() { - p.Success = new(baseline.Nesting) - } - return p.Success.FastRead(buf, _type, number) -} - -func (p *NestingMethodResult) FastWrite(buf []byte) (n int) { - if !p.IsSetSuccess() { - return 0 - } - return p.Success.FastWrite(buf) -} - -func (p *NestingMethodResult) Size() (n int) { - if !p.IsSetSuccess() { - return 0 - } - return p.Success.Size() -} - -func (p *NestingMethodResult) Marshal(out []byte) ([]byte, error) { - if !p.IsSetSuccess() { - return out, fmt.Errorf("No req in NestingMethodResult") - } - return proto.Marshal(p.Success) -} - -func (p *NestingMethodResult) Unmarshal(in []byte) error { - msg := new(baseline.Nesting) - if err := proto.Unmarshal(in, msg); err != nil { - return err - } - p.Success = msg - return nil -} - -func (p *NestingMethodResult) GetSuccess() *baseline.Nesting { - if !p.IsSetSuccess() { - return NestingMethodResult_Success_DEFAULT - } - return p.Success -} - -func (p *NestingMethodResult) SetSuccess(x interface{}) { - p.Success = x.(*baseline.Nesting) -} - -func (p *NestingMethodResult) IsSetSuccess() bool { - return p.Success != nil -} - -func (p *NestingMethodResult) GetResult() interface{} { - return p.Success -} - -func partialNestingMethodHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { - switch s := arg.(type) { - case *streaming.Args: - st := s.Stream - req := new(baseline.PartialNesting) - if err := st.RecvMsg(req); err != nil { - return err - } - resp, err := handler.(baseline.BaselineService).PartialNestingMethod(ctx, req) - if err != nil { - return err - } - if err := st.SendMsg(resp); err != nil { - return err - } - case *PartialNestingMethodArgs: - success, err := handler.(baseline.BaselineService).PartialNestingMethod(ctx, s.Req) - if err != nil { - return err - } - realResult := result.(*PartialNestingMethodResult) - realResult.Success = success - } - return nil -} -func newPartialNestingMethodArgs() interface{} { - return &PartialNestingMethodArgs{} -} - -func newPartialNestingMethodResult() interface{} { - return &PartialNestingMethodResult{} -} - -type PartialNestingMethodArgs struct { - Req *baseline.PartialNesting -} - -func (p *PartialNestingMethodArgs) FastRead(buf []byte, _type int8, number int32) (n int, err error) { - if !p.IsSetReq() { - p.Req = new(baseline.PartialNesting) - } - return p.Req.FastRead(buf, _type, number) -} - -func (p *PartialNestingMethodArgs) FastWrite(buf []byte) (n int) { - if !p.IsSetReq() { - return 0 - } - return p.Req.FastWrite(buf) -} - -func (p *PartialNestingMethodArgs) Size() (n int) { - if !p.IsSetReq() { - return 0 - } - return p.Req.Size() -} - -func (p *PartialNestingMethodArgs) Marshal(out []byte) ([]byte, error) { - if !p.IsSetReq() { - return out, fmt.Errorf("No req in PartialNestingMethodArgs") - } - return proto.Marshal(p.Req) -} - -func (p *PartialNestingMethodArgs) Unmarshal(in []byte) error { - msg := new(baseline.PartialNesting) - if err := proto.Unmarshal(in, msg); err != nil { - return err - } - p.Req = msg - return nil -} - -var PartialNestingMethodArgs_Req_DEFAULT *baseline.PartialNesting - -func (p *PartialNestingMethodArgs) GetReq() *baseline.PartialNesting { - if !p.IsSetReq() { - return PartialNestingMethodArgs_Req_DEFAULT - } - return p.Req -} - -func (p *PartialNestingMethodArgs) IsSetReq() bool { - return p.Req != nil -} - -func (p *PartialNestingMethodArgs) GetFirstArgument() interface{} { - return p.Req -} - -type PartialNestingMethodResult struct { - Success *baseline.PartialNesting -} - -var PartialNestingMethodResult_Success_DEFAULT *baseline.PartialNesting - -func (p *PartialNestingMethodResult) FastRead(buf []byte, _type int8, number int32) (n int, err error) { - if !p.IsSetSuccess() { - p.Success = new(baseline.PartialNesting) - } - return p.Success.FastRead(buf, _type, number) -} - -func (p *PartialNestingMethodResult) FastWrite(buf []byte) (n int) { - if !p.IsSetSuccess() { - return 0 - } - return p.Success.FastWrite(buf) -} - -func (p *PartialNestingMethodResult) Size() (n int) { - if !p.IsSetSuccess() { - return 0 - } - return p.Success.Size() -} - -func (p *PartialNestingMethodResult) Marshal(out []byte) ([]byte, error) { - if !p.IsSetSuccess() { - return out, fmt.Errorf("No req in PartialNestingMethodResult") - } - return proto.Marshal(p.Success) -} - -func (p *PartialNestingMethodResult) Unmarshal(in []byte) error { - msg := new(baseline.PartialNesting) - if err := proto.Unmarshal(in, msg); err != nil { - return err - } - p.Success = msg - return nil -} - -func (p *PartialNestingMethodResult) GetSuccess() *baseline.PartialNesting { - if !p.IsSetSuccess() { - return PartialNestingMethodResult_Success_DEFAULT - } - return p.Success -} - -func (p *PartialNestingMethodResult) SetSuccess(x interface{}) { - p.Success = x.(*baseline.PartialNesting) -} - -func (p *PartialNestingMethodResult) IsSetSuccess() bool { - return p.Success != nil -} - -func (p *PartialNestingMethodResult) GetResult() interface{} { - return p.Success -} - -func nesting2MethodHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { - switch s := arg.(type) { - case *streaming.Args: - st := s.Stream - req := new(baseline.Nesting2) - if err := st.RecvMsg(req); err != nil { - return err - } - resp, err := handler.(baseline.BaselineService).Nesting2Method(ctx, req) - if err != nil { - return err - } - if err := st.SendMsg(resp); err != nil { - return err - } - case *Nesting2MethodArgs: - success, err := handler.(baseline.BaselineService).Nesting2Method(ctx, s.Req) - if err != nil { - return err - } - realResult := result.(*Nesting2MethodResult) - realResult.Success = success - } - return nil -} -func newNesting2MethodArgs() interface{} { - return &Nesting2MethodArgs{} -} - -func newNesting2MethodResult() interface{} { - return &Nesting2MethodResult{} -} - -type Nesting2MethodArgs struct { - Req *baseline.Nesting2 -} - -func (p *Nesting2MethodArgs) FastRead(buf []byte, _type int8, number int32) (n int, err error) { - if !p.IsSetReq() { - p.Req = new(baseline.Nesting2) - } - return p.Req.FastRead(buf, _type, number) -} - -func (p *Nesting2MethodArgs) FastWrite(buf []byte) (n int) { - if !p.IsSetReq() { - return 0 - } - return p.Req.FastWrite(buf) -} - -func (p *Nesting2MethodArgs) Size() (n int) { - if !p.IsSetReq() { - return 0 - } - return p.Req.Size() -} - -func (p *Nesting2MethodArgs) Marshal(out []byte) ([]byte, error) { - if !p.IsSetReq() { - return out, fmt.Errorf("No req in Nesting2MethodArgs") - } - return proto.Marshal(p.Req) -} - -func (p *Nesting2MethodArgs) Unmarshal(in []byte) error { - msg := new(baseline.Nesting2) - if err := proto.Unmarshal(in, msg); err != nil { - return err - } - p.Req = msg - return nil -} - -var Nesting2MethodArgs_Req_DEFAULT *baseline.Nesting2 - -func (p *Nesting2MethodArgs) GetReq() *baseline.Nesting2 { - if !p.IsSetReq() { - return Nesting2MethodArgs_Req_DEFAULT - } - return p.Req -} - -func (p *Nesting2MethodArgs) IsSetReq() bool { - return p.Req != nil -} - -func (p *Nesting2MethodArgs) GetFirstArgument() interface{} { - return p.Req -} - -type Nesting2MethodResult struct { - Success *baseline.Nesting2 -} - -var Nesting2MethodResult_Success_DEFAULT *baseline.Nesting2 - -func (p *Nesting2MethodResult) FastRead(buf []byte, _type int8, number int32) (n int, err error) { - if !p.IsSetSuccess() { - p.Success = new(baseline.Nesting2) - } - return p.Success.FastRead(buf, _type, number) -} - -func (p *Nesting2MethodResult) FastWrite(buf []byte) (n int) { - if !p.IsSetSuccess() { - return 0 - } - return p.Success.FastWrite(buf) -} - -func (p *Nesting2MethodResult) Size() (n int) { - if !p.IsSetSuccess() { - return 0 - } - return p.Success.Size() -} - -func (p *Nesting2MethodResult) Marshal(out []byte) ([]byte, error) { - if !p.IsSetSuccess() { - return out, fmt.Errorf("No req in Nesting2MethodResult") - } - return proto.Marshal(p.Success) -} - -func (p *Nesting2MethodResult) Unmarshal(in []byte) error { - msg := new(baseline.Nesting2) - if err := proto.Unmarshal(in, msg); err != nil { - return err - } - p.Success = msg - return nil -} - -func (p *Nesting2MethodResult) GetSuccess() *baseline.Nesting2 { - if !p.IsSetSuccess() { - return Nesting2MethodResult_Success_DEFAULT - } - return p.Success -} - -func (p *Nesting2MethodResult) SetSuccess(x interface{}) { - p.Success = x.(*baseline.Nesting2) -} - -func (p *Nesting2MethodResult) IsSetSuccess() bool { - return p.Success != nil -} - -func (p *Nesting2MethodResult) GetResult() interface{} { - return p.Success -} - -type kClient struct { - c client.Client -} - -func newServiceClient(c client.Client) *kClient { - return &kClient{ - c: c, - } -} - -func (p *kClient) SimpleMethod(ctx context.Context, Req *baseline.Simple) (r *baseline.Simple, err error) { - var _args SimpleMethodArgs - _args.Req = Req - var _result SimpleMethodResult - if err = p.c.Call(ctx, "SimpleMethod", &_args, &_result); err != nil { - return - } - return _result.GetSuccess(), nil -} - -func (p *kClient) PartialSimpleMethod(ctx context.Context, Req *baseline.PartialSimple) (r *baseline.PartialSimple, err error) { - var _args PartialSimpleMethodArgs - _args.Req = Req - var _result PartialSimpleMethodResult - if err = p.c.Call(ctx, "PartialSimpleMethod", &_args, &_result); err != nil { - return - } - return _result.GetSuccess(), nil -} - -func (p *kClient) NestingMethod(ctx context.Context, Req *baseline.Nesting) (r *baseline.Nesting, err error) { - var _args NestingMethodArgs - _args.Req = Req - var _result NestingMethodResult - if err = p.c.Call(ctx, "NestingMethod", &_args, &_result); err != nil { - return - } - return _result.GetSuccess(), nil -} - -func (p *kClient) PartialNestingMethod(ctx context.Context, Req *baseline.PartialNesting) (r *baseline.PartialNesting, err error) { - var _args PartialNestingMethodArgs - _args.Req = Req - var _result PartialNestingMethodResult - if err = p.c.Call(ctx, "PartialNestingMethod", &_args, &_result); err != nil { - return - } - return _result.GetSuccess(), nil -} - -func (p *kClient) Nesting2Method(ctx context.Context, Req *baseline.Nesting2) (r *baseline.Nesting2, err error) { - var _args Nesting2MethodArgs - _args.Req = Req - var _result Nesting2MethodResult - if err = p.c.Call(ctx, "Nesting2Method", &_args, &_result); err != nil { - return - } - return _result.GetSuccess(), nil -} diff --git a/testdata/kitex_gen/pb/baseline/baselineservice/client.go b/testdata/kitex_gen/pb/baseline/baselineservice/client.go deleted file mode 100644 index bcec86cd..00000000 --- a/testdata/kitex_gen/pb/baseline/baselineservice/client.go +++ /dev/null @@ -1,73 +0,0 @@ -// Code generated by Kitex v0.5.2. DO NOT EDIT. - -package baselineservice - -import ( - "context" - baseline "github.com/cloudwego/dynamicgo/testdata/kitex_gen/pb/baseline" - client "github.com/cloudwego/kitex/client" - callopt "github.com/cloudwego/kitex/client/callopt" -) - -// Client is designed to provide IDL-compatible methods with call-option parameter for kitex framework. -type Client interface { - SimpleMethod(ctx context.Context, Req *baseline.Simple, callOptions ...callopt.Option) (r *baseline.Simple, err error) - PartialSimpleMethod(ctx context.Context, Req *baseline.PartialSimple, callOptions ...callopt.Option) (r *baseline.PartialSimple, err error) - NestingMethod(ctx context.Context, Req *baseline.Nesting, callOptions ...callopt.Option) (r *baseline.Nesting, err error) - PartialNestingMethod(ctx context.Context, Req *baseline.PartialNesting, callOptions ...callopt.Option) (r *baseline.PartialNesting, err error) - Nesting2Method(ctx context.Context, Req *baseline.Nesting2, callOptions ...callopt.Option) (r *baseline.Nesting2, err error) -} - -// NewClient creates a client for the service defined in IDL. -func NewClient(destService string, opts ...client.Option) (Client, error) { - var options []client.Option - options = append(options, client.WithDestService(destService)) - - options = append(options, opts...) - - kc, err := client.NewClient(serviceInfo(), options...) - if err != nil { - return nil, err - } - return &kBaselineServiceClient{ - kClient: newServiceClient(kc), - }, nil -} - -// MustNewClient creates a client for the service defined in IDL. It panics if any error occurs. -func MustNewClient(destService string, opts ...client.Option) Client { - kc, err := NewClient(destService, opts...) - if err != nil { - panic(err) - } - return kc -} - -type kBaselineServiceClient struct { - *kClient -} - -func (p *kBaselineServiceClient) SimpleMethod(ctx context.Context, Req *baseline.Simple, callOptions ...callopt.Option) (r *baseline.Simple, err error) { - ctx = client.NewCtxWithCallOptions(ctx, callOptions) - return p.kClient.SimpleMethod(ctx, Req) -} - -func (p *kBaselineServiceClient) PartialSimpleMethod(ctx context.Context, Req *baseline.PartialSimple, callOptions ...callopt.Option) (r *baseline.PartialSimple, err error) { - ctx = client.NewCtxWithCallOptions(ctx, callOptions) - return p.kClient.PartialSimpleMethod(ctx, Req) -} - -func (p *kBaselineServiceClient) NestingMethod(ctx context.Context, Req *baseline.Nesting, callOptions ...callopt.Option) (r *baseline.Nesting, err error) { - ctx = client.NewCtxWithCallOptions(ctx, callOptions) - return p.kClient.NestingMethod(ctx, Req) -} - -func (p *kBaselineServiceClient) PartialNestingMethod(ctx context.Context, Req *baseline.PartialNesting, callOptions ...callopt.Option) (r *baseline.PartialNesting, err error) { - ctx = client.NewCtxWithCallOptions(ctx, callOptions) - return p.kClient.PartialNestingMethod(ctx, Req) -} - -func (p *kBaselineServiceClient) Nesting2Method(ctx context.Context, Req *baseline.Nesting2, callOptions ...callopt.Option) (r *baseline.Nesting2, err error) { - ctx = client.NewCtxWithCallOptions(ctx, callOptions) - return p.kClient.Nesting2Method(ctx, Req) -} diff --git a/testdata/kitex_gen/pb/baseline/baselineservice/invoker.go b/testdata/kitex_gen/pb/baseline/baselineservice/invoker.go deleted file mode 100644 index 25799df0..00000000 --- a/testdata/kitex_gen/pb/baseline/baselineservice/invoker.go +++ /dev/null @@ -1,24 +0,0 @@ -// Code generated by Kitex v0.5.2. DO NOT EDIT. - -package baselineservice - -import ( - baseline "github.com/cloudwego/dynamicgo/testdata/kitex_gen/pb/baseline" - server "github.com/cloudwego/kitex/server" -) - -// NewInvoker creates a server.Invoker with the given handler and options. -func NewInvoker(handler baseline.BaselineService, opts ...server.Option) server.Invoker { - var options []server.Option - - options = append(options, opts...) - - s := server.NewInvoker(options...) - if err := s.RegisterService(serviceInfo(), handler); err != nil { - panic(err) - } - if err := s.Init(); err != nil { - panic(err) - } - return s -} diff --git a/testdata/kitex_gen/pb/baseline/baselineservice/server.go b/testdata/kitex_gen/pb/baseline/baselineservice/server.go deleted file mode 100644 index 26b92c8d..00000000 --- a/testdata/kitex_gen/pb/baseline/baselineservice/server.go +++ /dev/null @@ -1,20 +0,0 @@ -// Code generated by Kitex v0.5.2. DO NOT EDIT. -package baselineservice - -import ( - baseline "github.com/cloudwego/dynamicgo/testdata/kitex_gen/pb/baseline" - server "github.com/cloudwego/kitex/server" -) - -// NewServer creates a server.Server with the given handler and options. -func NewServer(handler baseline.BaselineService, opts ...server.Option) server.Server { - var options []server.Option - - options = append(options, opts...) - - svr := server.NewServer(options...) - if err := svr.RegisterService(serviceInfo(), handler); err != nil { - panic(err) - } - return svr -} diff --git a/testdata/kitex_gen/pb/example/testservice/client.go b/testdata/kitex_gen/pb/example/testservice/client.go deleted file mode 100644 index 4a4c3521..00000000 --- a/testdata/kitex_gen/pb/example/testservice/client.go +++ /dev/null @@ -1,85 +0,0 @@ -// Code generated by Kitex v0.5.2. DO NOT EDIT. - -package testservice - -import ( - "context" - example "github.com/cloudwego/dynamicgo/testdata/kitex_gen/pb/example" - client "github.com/cloudwego/kitex/client" - callopt "github.com/cloudwego/kitex/client/callopt" -) - -// Client is designed to provide IDL-compatible methods with call-option parameter for kitex framework. -type Client interface { - ScalarsMethodTest(ctx context.Context, Req *example.ExampleScalarsReq, callOptions ...callopt.Option) (r *example.ExampleScalarsResp, err error) - MessageMethodTest(ctx context.Context, Req *example.ExampleMessageReq, callOptions ...callopt.Option) (r *example.ExampleMessageResp, err error) - NestedMethodTest(ctx context.Context, Req *example.ExampleNestedReq, callOptions ...callopt.Option) (r *example.ExampleNestedResp, err error) - PartialMethodTest(ctx context.Context, Req *example.ExampleParitalReq, callOptions ...callopt.Option) (r *example.ExamplePartialResp, err error) - ListMethodTest(ctx context.Context, Req *example.ExampleListReq, callOptions ...callopt.Option) (r *example.ExampleListResp, err error) - MapMethodTest(ctx context.Context, Req *example.ExampleMapReq, callOptions ...callopt.Option) (r *example.ExampleMapResp, err error) - OneofMethodTest(ctx context.Context, Req *example.ExampleOneofReq, callOptions ...callopt.Option) (r *example.ExampleOneofResp, err error) -} - -// NewClient creates a client for the service defined in IDL. -func NewClient(destService string, opts ...client.Option) (Client, error) { - var options []client.Option - options = append(options, client.WithDestService(destService)) - - options = append(options, opts...) - - kc, err := client.NewClient(serviceInfo(), options...) - if err != nil { - return nil, err - } - return &kTestServiceClient{ - kClient: newServiceClient(kc), - }, nil -} - -// MustNewClient creates a client for the service defined in IDL. It panics if any error occurs. -func MustNewClient(destService string, opts ...client.Option) Client { - kc, err := NewClient(destService, opts...) - if err != nil { - panic(err) - } - return kc -} - -type kTestServiceClient struct { - *kClient -} - -func (p *kTestServiceClient) ScalarsMethodTest(ctx context.Context, Req *example.ExampleScalarsReq, callOptions ...callopt.Option) (r *example.ExampleScalarsResp, err error) { - ctx = client.NewCtxWithCallOptions(ctx, callOptions) - return p.kClient.ScalarsMethodTest(ctx, Req) -} - -func (p *kTestServiceClient) MessageMethodTest(ctx context.Context, Req *example.ExampleMessageReq, callOptions ...callopt.Option) (r *example.ExampleMessageResp, err error) { - ctx = client.NewCtxWithCallOptions(ctx, callOptions) - return p.kClient.MessageMethodTest(ctx, Req) -} - -func (p *kTestServiceClient) NestedMethodTest(ctx context.Context, Req *example.ExampleNestedReq, callOptions ...callopt.Option) (r *example.ExampleNestedResp, err error) { - ctx = client.NewCtxWithCallOptions(ctx, callOptions) - return p.kClient.NestedMethodTest(ctx, Req) -} - -func (p *kTestServiceClient) PartialMethodTest(ctx context.Context, Req *example.ExampleParitalReq, callOptions ...callopt.Option) (r *example.ExamplePartialResp, err error) { - ctx = client.NewCtxWithCallOptions(ctx, callOptions) - return p.kClient.PartialMethodTest(ctx, Req) -} - -func (p *kTestServiceClient) ListMethodTest(ctx context.Context, Req *example.ExampleListReq, callOptions ...callopt.Option) (r *example.ExampleListResp, err error) { - ctx = client.NewCtxWithCallOptions(ctx, callOptions) - return p.kClient.ListMethodTest(ctx, Req) -} - -func (p *kTestServiceClient) MapMethodTest(ctx context.Context, Req *example.ExampleMapReq, callOptions ...callopt.Option) (r *example.ExampleMapResp, err error) { - ctx = client.NewCtxWithCallOptions(ctx, callOptions) - return p.kClient.MapMethodTest(ctx, Req) -} - -func (p *kTestServiceClient) OneofMethodTest(ctx context.Context, Req *example.ExampleOneofReq, callOptions ...callopt.Option) (r *example.ExampleOneofResp, err error) { - ctx = client.NewCtxWithCallOptions(ctx, callOptions) - return p.kClient.OneofMethodTest(ctx, Req) -} diff --git a/testdata/kitex_gen/pb/example/testservice/invoker.go b/testdata/kitex_gen/pb/example/testservice/invoker.go deleted file mode 100644 index 364c74f1..00000000 --- a/testdata/kitex_gen/pb/example/testservice/invoker.go +++ /dev/null @@ -1,24 +0,0 @@ -// Code generated by Kitex v0.5.2. DO NOT EDIT. - -package testservice - -import ( - example "github.com/cloudwego/dynamicgo/testdata/kitex_gen/pb/example" - server "github.com/cloudwego/kitex/server" -) - -// NewInvoker creates a server.Invoker with the given handler and options. -func NewInvoker(handler example.TestService, opts ...server.Option) server.Invoker { - var options []server.Option - - options = append(options, opts...) - - s := server.NewInvoker(options...) - if err := s.RegisterService(serviceInfo(), handler); err != nil { - panic(err) - } - if err := s.Init(); err != nil { - panic(err) - } - return s -} diff --git a/testdata/kitex_gen/pb/example/testservice/server.go b/testdata/kitex_gen/pb/example/testservice/server.go deleted file mode 100644 index 7b7c7d27..00000000 --- a/testdata/kitex_gen/pb/example/testservice/server.go +++ /dev/null @@ -1,20 +0,0 @@ -// Code generated by Kitex v0.5.2. DO NOT EDIT. -package testservice - -import ( - example "github.com/cloudwego/dynamicgo/testdata/kitex_gen/pb/example" - server "github.com/cloudwego/kitex/server" -) - -// NewServer creates a server.Server with the given handler and options. -func NewServer(handler example.TestService, opts ...server.Option) server.Server { - var options []server.Option - - options = append(options, opts...) - - svr := server.NewServer(options...) - if err := svr.RegisterService(serviceInfo(), handler); err != nil { - panic(err) - } - return svr -} diff --git a/testdata/kitex_gen/pb/example/testservice/testservice.go b/testdata/kitex_gen/pb/example/testservice/testservice.go deleted file mode 100644 index 5ed9b54e..00000000 --- a/testdata/kitex_gen/pb/example/testservice/testservice.go +++ /dev/null @@ -1,1196 +0,0 @@ -// Code generated by Kitex v0.5.2. DO NOT EDIT. - -package testservice - -import ( - "context" - "fmt" - example "github.com/cloudwego/dynamicgo/testdata/kitex_gen/pb/example" - client "github.com/cloudwego/kitex/client" - kitex "github.com/cloudwego/kitex/pkg/serviceinfo" - streaming "github.com/cloudwego/kitex/pkg/streaming" - proto "google.golang.org/protobuf/proto" -) - -func serviceInfo() *kitex.ServiceInfo { - return testServiceServiceInfo -} - -var testServiceServiceInfo = NewServiceInfo() - -func NewServiceInfo() *kitex.ServiceInfo { - serviceName := "TestService" - handlerType := (*example.TestService)(nil) - methods := map[string]kitex.MethodInfo{ - "ScalarsMethodTest": kitex.NewMethodInfo(scalarsMethodTestHandler, newScalarsMethodTestArgs, newScalarsMethodTestResult, false), - "MessageMethodTest": kitex.NewMethodInfo(messageMethodTestHandler, newMessageMethodTestArgs, newMessageMethodTestResult, false), - "NestedMethodTest": kitex.NewMethodInfo(nestedMethodTestHandler, newNestedMethodTestArgs, newNestedMethodTestResult, false), - "PartialMethodTest": kitex.NewMethodInfo(partialMethodTestHandler, newPartialMethodTestArgs, newPartialMethodTestResult, false), - "ListMethodTest": kitex.NewMethodInfo(listMethodTestHandler, newListMethodTestArgs, newListMethodTestResult, false), - "MapMethodTest": kitex.NewMethodInfo(mapMethodTestHandler, newMapMethodTestArgs, newMapMethodTestResult, false), - "OneofMethodTest": kitex.NewMethodInfo(oneofMethodTestHandler, newOneofMethodTestArgs, newOneofMethodTestResult, false), - } - extra := map[string]interface{}{ - "PackageName": "pb3", - } - svcInfo := &kitex.ServiceInfo{ - ServiceName: serviceName, - HandlerType: handlerType, - Methods: methods, - PayloadCodec: kitex.Protobuf, - KiteXGenVersion: "v0.5.2", - Extra: extra, - } - return svcInfo -} - -func scalarsMethodTestHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { - switch s := arg.(type) { - case *streaming.Args: - st := s.Stream - req := new(example.ExampleScalarsReq) - if err := st.RecvMsg(req); err != nil { - return err - } - resp, err := handler.(example.TestService).ScalarsMethodTest(ctx, req) - if err != nil { - return err - } - if err := st.SendMsg(resp); err != nil { - return err - } - case *ScalarsMethodTestArgs: - success, err := handler.(example.TestService).ScalarsMethodTest(ctx, s.Req) - if err != nil { - return err - } - realResult := result.(*ScalarsMethodTestResult) - realResult.Success = success - } - return nil -} -func newScalarsMethodTestArgs() interface{} { - return &ScalarsMethodTestArgs{} -} - -func newScalarsMethodTestResult() interface{} { - return &ScalarsMethodTestResult{} -} - -type ScalarsMethodTestArgs struct { - Req *example.ExampleScalarsReq -} - -func (p *ScalarsMethodTestArgs) FastRead(buf []byte, _type int8, number int32) (n int, err error) { - if !p.IsSetReq() { - p.Req = new(example.ExampleScalarsReq) - } - return p.Req.FastRead(buf, _type, number) -} - -func (p *ScalarsMethodTestArgs) FastWrite(buf []byte) (n int) { - if !p.IsSetReq() { - return 0 - } - return p.Req.FastWrite(buf) -} - -func (p *ScalarsMethodTestArgs) Size() (n int) { - if !p.IsSetReq() { - return 0 - } - return p.Req.Size() -} - -func (p *ScalarsMethodTestArgs) Marshal(out []byte) ([]byte, error) { - if !p.IsSetReq() { - return out, fmt.Errorf("No req in ScalarsMethodTestArgs") - } - return proto.Marshal(p.Req) -} - -func (p *ScalarsMethodTestArgs) Unmarshal(in []byte) error { - msg := new(example.ExampleScalarsReq) - if err := proto.Unmarshal(in, msg); err != nil { - return err - } - p.Req = msg - return nil -} - -var ScalarsMethodTestArgs_Req_DEFAULT *example.ExampleScalarsReq - -func (p *ScalarsMethodTestArgs) GetReq() *example.ExampleScalarsReq { - if !p.IsSetReq() { - return ScalarsMethodTestArgs_Req_DEFAULT - } - return p.Req -} - -func (p *ScalarsMethodTestArgs) IsSetReq() bool { - return p.Req != nil -} - -func (p *ScalarsMethodTestArgs) GetFirstArgument() interface{} { - return p.Req -} - -type ScalarsMethodTestResult struct { - Success *example.ExampleScalarsResp -} - -var ScalarsMethodTestResult_Success_DEFAULT *example.ExampleScalarsResp - -func (p *ScalarsMethodTestResult) FastRead(buf []byte, _type int8, number int32) (n int, err error) { - if !p.IsSetSuccess() { - p.Success = new(example.ExampleScalarsResp) - } - return p.Success.FastRead(buf, _type, number) -} - -func (p *ScalarsMethodTestResult) FastWrite(buf []byte) (n int) { - if !p.IsSetSuccess() { - return 0 - } - return p.Success.FastWrite(buf) -} - -func (p *ScalarsMethodTestResult) Size() (n int) { - if !p.IsSetSuccess() { - return 0 - } - return p.Success.Size() -} - -func (p *ScalarsMethodTestResult) Marshal(out []byte) ([]byte, error) { - if !p.IsSetSuccess() { - return out, fmt.Errorf("No req in ScalarsMethodTestResult") - } - return proto.Marshal(p.Success) -} - -func (p *ScalarsMethodTestResult) Unmarshal(in []byte) error { - msg := new(example.ExampleScalarsResp) - if err := proto.Unmarshal(in, msg); err != nil { - return err - } - p.Success = msg - return nil -} - -func (p *ScalarsMethodTestResult) GetSuccess() *example.ExampleScalarsResp { - if !p.IsSetSuccess() { - return ScalarsMethodTestResult_Success_DEFAULT - } - return p.Success -} - -func (p *ScalarsMethodTestResult) SetSuccess(x interface{}) { - p.Success = x.(*example.ExampleScalarsResp) -} - -func (p *ScalarsMethodTestResult) IsSetSuccess() bool { - return p.Success != nil -} - -func (p *ScalarsMethodTestResult) GetResult() interface{} { - return p.Success -} - -func messageMethodTestHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { - switch s := arg.(type) { - case *streaming.Args: - st := s.Stream - req := new(example.ExampleMessageReq) - if err := st.RecvMsg(req); err != nil { - return err - } - resp, err := handler.(example.TestService).MessageMethodTest(ctx, req) - if err != nil { - return err - } - if err := st.SendMsg(resp); err != nil { - return err - } - case *MessageMethodTestArgs: - success, err := handler.(example.TestService).MessageMethodTest(ctx, s.Req) - if err != nil { - return err - } - realResult := result.(*MessageMethodTestResult) - realResult.Success = success - } - return nil -} -func newMessageMethodTestArgs() interface{} { - return &MessageMethodTestArgs{} -} - -func newMessageMethodTestResult() interface{} { - return &MessageMethodTestResult{} -} - -type MessageMethodTestArgs struct { - Req *example.ExampleMessageReq -} - -func (p *MessageMethodTestArgs) FastRead(buf []byte, _type int8, number int32) (n int, err error) { - if !p.IsSetReq() { - p.Req = new(example.ExampleMessageReq) - } - return p.Req.FastRead(buf, _type, number) -} - -func (p *MessageMethodTestArgs) FastWrite(buf []byte) (n int) { - if !p.IsSetReq() { - return 0 - } - return p.Req.FastWrite(buf) -} - -func (p *MessageMethodTestArgs) Size() (n int) { - if !p.IsSetReq() { - return 0 - } - return p.Req.Size() -} - -func (p *MessageMethodTestArgs) Marshal(out []byte) ([]byte, error) { - if !p.IsSetReq() { - return out, fmt.Errorf("No req in MessageMethodTestArgs") - } - return proto.Marshal(p.Req) -} - -func (p *MessageMethodTestArgs) Unmarshal(in []byte) error { - msg := new(example.ExampleMessageReq) - if err := proto.Unmarshal(in, msg); err != nil { - return err - } - p.Req = msg - return nil -} - -var MessageMethodTestArgs_Req_DEFAULT *example.ExampleMessageReq - -func (p *MessageMethodTestArgs) GetReq() *example.ExampleMessageReq { - if !p.IsSetReq() { - return MessageMethodTestArgs_Req_DEFAULT - } - return p.Req -} - -func (p *MessageMethodTestArgs) IsSetReq() bool { - return p.Req != nil -} - -func (p *MessageMethodTestArgs) GetFirstArgument() interface{} { - return p.Req -} - -type MessageMethodTestResult struct { - Success *example.ExampleMessageResp -} - -var MessageMethodTestResult_Success_DEFAULT *example.ExampleMessageResp - -func (p *MessageMethodTestResult) FastRead(buf []byte, _type int8, number int32) (n int, err error) { - if !p.IsSetSuccess() { - p.Success = new(example.ExampleMessageResp) - } - return p.Success.FastRead(buf, _type, number) -} - -func (p *MessageMethodTestResult) FastWrite(buf []byte) (n int) { - if !p.IsSetSuccess() { - return 0 - } - return p.Success.FastWrite(buf) -} - -func (p *MessageMethodTestResult) Size() (n int) { - if !p.IsSetSuccess() { - return 0 - } - return p.Success.Size() -} - -func (p *MessageMethodTestResult) Marshal(out []byte) ([]byte, error) { - if !p.IsSetSuccess() { - return out, fmt.Errorf("No req in MessageMethodTestResult") - } - return proto.Marshal(p.Success) -} - -func (p *MessageMethodTestResult) Unmarshal(in []byte) error { - msg := new(example.ExampleMessageResp) - if err := proto.Unmarshal(in, msg); err != nil { - return err - } - p.Success = msg - return nil -} - -func (p *MessageMethodTestResult) GetSuccess() *example.ExampleMessageResp { - if !p.IsSetSuccess() { - return MessageMethodTestResult_Success_DEFAULT - } - return p.Success -} - -func (p *MessageMethodTestResult) SetSuccess(x interface{}) { - p.Success = x.(*example.ExampleMessageResp) -} - -func (p *MessageMethodTestResult) IsSetSuccess() bool { - return p.Success != nil -} - -func (p *MessageMethodTestResult) GetResult() interface{} { - return p.Success -} - -func nestedMethodTestHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { - switch s := arg.(type) { - case *streaming.Args: - st := s.Stream - req := new(example.ExampleNestedReq) - if err := st.RecvMsg(req); err != nil { - return err - } - resp, err := handler.(example.TestService).NestedMethodTest(ctx, req) - if err != nil { - return err - } - if err := st.SendMsg(resp); err != nil { - return err - } - case *NestedMethodTestArgs: - success, err := handler.(example.TestService).NestedMethodTest(ctx, s.Req) - if err != nil { - return err - } - realResult := result.(*NestedMethodTestResult) - realResult.Success = success - } - return nil -} -func newNestedMethodTestArgs() interface{} { - return &NestedMethodTestArgs{} -} - -func newNestedMethodTestResult() interface{} { - return &NestedMethodTestResult{} -} - -type NestedMethodTestArgs struct { - Req *example.ExampleNestedReq -} - -func (p *NestedMethodTestArgs) FastRead(buf []byte, _type int8, number int32) (n int, err error) { - if !p.IsSetReq() { - p.Req = new(example.ExampleNestedReq) - } - return p.Req.FastRead(buf, _type, number) -} - -func (p *NestedMethodTestArgs) FastWrite(buf []byte) (n int) { - if !p.IsSetReq() { - return 0 - } - return p.Req.FastWrite(buf) -} - -func (p *NestedMethodTestArgs) Size() (n int) { - if !p.IsSetReq() { - return 0 - } - return p.Req.Size() -} - -func (p *NestedMethodTestArgs) Marshal(out []byte) ([]byte, error) { - if !p.IsSetReq() { - return out, fmt.Errorf("No req in NestedMethodTestArgs") - } - return proto.Marshal(p.Req) -} - -func (p *NestedMethodTestArgs) Unmarshal(in []byte) error { - msg := new(example.ExampleNestedReq) - if err := proto.Unmarshal(in, msg); err != nil { - return err - } - p.Req = msg - return nil -} - -var NestedMethodTestArgs_Req_DEFAULT *example.ExampleNestedReq - -func (p *NestedMethodTestArgs) GetReq() *example.ExampleNestedReq { - if !p.IsSetReq() { - return NestedMethodTestArgs_Req_DEFAULT - } - return p.Req -} - -func (p *NestedMethodTestArgs) IsSetReq() bool { - return p.Req != nil -} - -func (p *NestedMethodTestArgs) GetFirstArgument() interface{} { - return p.Req -} - -type NestedMethodTestResult struct { - Success *example.ExampleNestedResp -} - -var NestedMethodTestResult_Success_DEFAULT *example.ExampleNestedResp - -func (p *NestedMethodTestResult) FastRead(buf []byte, _type int8, number int32) (n int, err error) { - if !p.IsSetSuccess() { - p.Success = new(example.ExampleNestedResp) - } - return p.Success.FastRead(buf, _type, number) -} - -func (p *NestedMethodTestResult) FastWrite(buf []byte) (n int) { - if !p.IsSetSuccess() { - return 0 - } - return p.Success.FastWrite(buf) -} - -func (p *NestedMethodTestResult) Size() (n int) { - if !p.IsSetSuccess() { - return 0 - } - return p.Success.Size() -} - -func (p *NestedMethodTestResult) Marshal(out []byte) ([]byte, error) { - if !p.IsSetSuccess() { - return out, fmt.Errorf("No req in NestedMethodTestResult") - } - return proto.Marshal(p.Success) -} - -func (p *NestedMethodTestResult) Unmarshal(in []byte) error { - msg := new(example.ExampleNestedResp) - if err := proto.Unmarshal(in, msg); err != nil { - return err - } - p.Success = msg - return nil -} - -func (p *NestedMethodTestResult) GetSuccess() *example.ExampleNestedResp { - if !p.IsSetSuccess() { - return NestedMethodTestResult_Success_DEFAULT - } - return p.Success -} - -func (p *NestedMethodTestResult) SetSuccess(x interface{}) { - p.Success = x.(*example.ExampleNestedResp) -} - -func (p *NestedMethodTestResult) IsSetSuccess() bool { - return p.Success != nil -} - -func (p *NestedMethodTestResult) GetResult() interface{} { - return p.Success -} - -func partialMethodTestHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { - switch s := arg.(type) { - case *streaming.Args: - st := s.Stream - req := new(example.ExampleParitalReq) - if err := st.RecvMsg(req); err != nil { - return err - } - resp, err := handler.(example.TestService).PartialMethodTest(ctx, req) - if err != nil { - return err - } - if err := st.SendMsg(resp); err != nil { - return err - } - case *PartialMethodTestArgs: - success, err := handler.(example.TestService).PartialMethodTest(ctx, s.Req) - if err != nil { - return err - } - realResult := result.(*PartialMethodTestResult) - realResult.Success = success - } - return nil -} -func newPartialMethodTestArgs() interface{} { - return &PartialMethodTestArgs{} -} - -func newPartialMethodTestResult() interface{} { - return &PartialMethodTestResult{} -} - -type PartialMethodTestArgs struct { - Req *example.ExampleParitalReq -} - -func (p *PartialMethodTestArgs) FastRead(buf []byte, _type int8, number int32) (n int, err error) { - if !p.IsSetReq() { - p.Req = new(example.ExampleParitalReq) - } - return p.Req.FastRead(buf, _type, number) -} - -func (p *PartialMethodTestArgs) FastWrite(buf []byte) (n int) { - if !p.IsSetReq() { - return 0 - } - return p.Req.FastWrite(buf) -} - -func (p *PartialMethodTestArgs) Size() (n int) { - if !p.IsSetReq() { - return 0 - } - return p.Req.Size() -} - -func (p *PartialMethodTestArgs) Marshal(out []byte) ([]byte, error) { - if !p.IsSetReq() { - return out, fmt.Errorf("No req in PartialMethodTestArgs") - } - return proto.Marshal(p.Req) -} - -func (p *PartialMethodTestArgs) Unmarshal(in []byte) error { - msg := new(example.ExampleParitalReq) - if err := proto.Unmarshal(in, msg); err != nil { - return err - } - p.Req = msg - return nil -} - -var PartialMethodTestArgs_Req_DEFAULT *example.ExampleParitalReq - -func (p *PartialMethodTestArgs) GetReq() *example.ExampleParitalReq { - if !p.IsSetReq() { - return PartialMethodTestArgs_Req_DEFAULT - } - return p.Req -} - -func (p *PartialMethodTestArgs) IsSetReq() bool { - return p.Req != nil -} - -func (p *PartialMethodTestArgs) GetFirstArgument() interface{} { - return p.Req -} - -type PartialMethodTestResult struct { - Success *example.ExamplePartialResp -} - -var PartialMethodTestResult_Success_DEFAULT *example.ExamplePartialResp - -func (p *PartialMethodTestResult) FastRead(buf []byte, _type int8, number int32) (n int, err error) { - if !p.IsSetSuccess() { - p.Success = new(example.ExamplePartialResp) - } - return p.Success.FastRead(buf, _type, number) -} - -func (p *PartialMethodTestResult) FastWrite(buf []byte) (n int) { - if !p.IsSetSuccess() { - return 0 - } - return p.Success.FastWrite(buf) -} - -func (p *PartialMethodTestResult) Size() (n int) { - if !p.IsSetSuccess() { - return 0 - } - return p.Success.Size() -} - -func (p *PartialMethodTestResult) Marshal(out []byte) ([]byte, error) { - if !p.IsSetSuccess() { - return out, fmt.Errorf("No req in PartialMethodTestResult") - } - return proto.Marshal(p.Success) -} - -func (p *PartialMethodTestResult) Unmarshal(in []byte) error { - msg := new(example.ExamplePartialResp) - if err := proto.Unmarshal(in, msg); err != nil { - return err - } - p.Success = msg - return nil -} - -func (p *PartialMethodTestResult) GetSuccess() *example.ExamplePartialResp { - if !p.IsSetSuccess() { - return PartialMethodTestResult_Success_DEFAULT - } - return p.Success -} - -func (p *PartialMethodTestResult) SetSuccess(x interface{}) { - p.Success = x.(*example.ExamplePartialResp) -} - -func (p *PartialMethodTestResult) IsSetSuccess() bool { - return p.Success != nil -} - -func (p *PartialMethodTestResult) GetResult() interface{} { - return p.Success -} - -func listMethodTestHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { - switch s := arg.(type) { - case *streaming.Args: - st := s.Stream - req := new(example.ExampleListReq) - if err := st.RecvMsg(req); err != nil { - return err - } - resp, err := handler.(example.TestService).ListMethodTest(ctx, req) - if err != nil { - return err - } - if err := st.SendMsg(resp); err != nil { - return err - } - case *ListMethodTestArgs: - success, err := handler.(example.TestService).ListMethodTest(ctx, s.Req) - if err != nil { - return err - } - realResult := result.(*ListMethodTestResult) - realResult.Success = success - } - return nil -} -func newListMethodTestArgs() interface{} { - return &ListMethodTestArgs{} -} - -func newListMethodTestResult() interface{} { - return &ListMethodTestResult{} -} - -type ListMethodTestArgs struct { - Req *example.ExampleListReq -} - -func (p *ListMethodTestArgs) FastRead(buf []byte, _type int8, number int32) (n int, err error) { - if !p.IsSetReq() { - p.Req = new(example.ExampleListReq) - } - return p.Req.FastRead(buf, _type, number) -} - -func (p *ListMethodTestArgs) FastWrite(buf []byte) (n int) { - if !p.IsSetReq() { - return 0 - } - return p.Req.FastWrite(buf) -} - -func (p *ListMethodTestArgs) Size() (n int) { - if !p.IsSetReq() { - return 0 - } - return p.Req.Size() -} - -func (p *ListMethodTestArgs) Marshal(out []byte) ([]byte, error) { - if !p.IsSetReq() { - return out, fmt.Errorf("No req in ListMethodTestArgs") - } - return proto.Marshal(p.Req) -} - -func (p *ListMethodTestArgs) Unmarshal(in []byte) error { - msg := new(example.ExampleListReq) - if err := proto.Unmarshal(in, msg); err != nil { - return err - } - p.Req = msg - return nil -} - -var ListMethodTestArgs_Req_DEFAULT *example.ExampleListReq - -func (p *ListMethodTestArgs) GetReq() *example.ExampleListReq { - if !p.IsSetReq() { - return ListMethodTestArgs_Req_DEFAULT - } - return p.Req -} - -func (p *ListMethodTestArgs) IsSetReq() bool { - return p.Req != nil -} - -func (p *ListMethodTestArgs) GetFirstArgument() interface{} { - return p.Req -} - -type ListMethodTestResult struct { - Success *example.ExampleListResp -} - -var ListMethodTestResult_Success_DEFAULT *example.ExampleListResp - -func (p *ListMethodTestResult) FastRead(buf []byte, _type int8, number int32) (n int, err error) { - if !p.IsSetSuccess() { - p.Success = new(example.ExampleListResp) - } - return p.Success.FastRead(buf, _type, number) -} - -func (p *ListMethodTestResult) FastWrite(buf []byte) (n int) { - if !p.IsSetSuccess() { - return 0 - } - return p.Success.FastWrite(buf) -} - -func (p *ListMethodTestResult) Size() (n int) { - if !p.IsSetSuccess() { - return 0 - } - return p.Success.Size() -} - -func (p *ListMethodTestResult) Marshal(out []byte) ([]byte, error) { - if !p.IsSetSuccess() { - return out, fmt.Errorf("No req in ListMethodTestResult") - } - return proto.Marshal(p.Success) -} - -func (p *ListMethodTestResult) Unmarshal(in []byte) error { - msg := new(example.ExampleListResp) - if err := proto.Unmarshal(in, msg); err != nil { - return err - } - p.Success = msg - return nil -} - -func (p *ListMethodTestResult) GetSuccess() *example.ExampleListResp { - if !p.IsSetSuccess() { - return ListMethodTestResult_Success_DEFAULT - } - return p.Success -} - -func (p *ListMethodTestResult) SetSuccess(x interface{}) { - p.Success = x.(*example.ExampleListResp) -} - -func (p *ListMethodTestResult) IsSetSuccess() bool { - return p.Success != nil -} - -func (p *ListMethodTestResult) GetResult() interface{} { - return p.Success -} - -func mapMethodTestHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { - switch s := arg.(type) { - case *streaming.Args: - st := s.Stream - req := new(example.ExampleMapReq) - if err := st.RecvMsg(req); err != nil { - return err - } - resp, err := handler.(example.TestService).MapMethodTest(ctx, req) - if err != nil { - return err - } - if err := st.SendMsg(resp); err != nil { - return err - } - case *MapMethodTestArgs: - success, err := handler.(example.TestService).MapMethodTest(ctx, s.Req) - if err != nil { - return err - } - realResult := result.(*MapMethodTestResult) - realResult.Success = success - } - return nil -} -func newMapMethodTestArgs() interface{} { - return &MapMethodTestArgs{} -} - -func newMapMethodTestResult() interface{} { - return &MapMethodTestResult{} -} - -type MapMethodTestArgs struct { - Req *example.ExampleMapReq -} - -func (p *MapMethodTestArgs) FastRead(buf []byte, _type int8, number int32) (n int, err error) { - if !p.IsSetReq() { - p.Req = new(example.ExampleMapReq) - } - return p.Req.FastRead(buf, _type, number) -} - -func (p *MapMethodTestArgs) FastWrite(buf []byte) (n int) { - if !p.IsSetReq() { - return 0 - } - return p.Req.FastWrite(buf) -} - -func (p *MapMethodTestArgs) Size() (n int) { - if !p.IsSetReq() { - return 0 - } - return p.Req.Size() -} - -func (p *MapMethodTestArgs) Marshal(out []byte) ([]byte, error) { - if !p.IsSetReq() { - return out, fmt.Errorf("No req in MapMethodTestArgs") - } - return proto.Marshal(p.Req) -} - -func (p *MapMethodTestArgs) Unmarshal(in []byte) error { - msg := new(example.ExampleMapReq) - if err := proto.Unmarshal(in, msg); err != nil { - return err - } - p.Req = msg - return nil -} - -var MapMethodTestArgs_Req_DEFAULT *example.ExampleMapReq - -func (p *MapMethodTestArgs) GetReq() *example.ExampleMapReq { - if !p.IsSetReq() { - return MapMethodTestArgs_Req_DEFAULT - } - return p.Req -} - -func (p *MapMethodTestArgs) IsSetReq() bool { - return p.Req != nil -} - -func (p *MapMethodTestArgs) GetFirstArgument() interface{} { - return p.Req -} - -type MapMethodTestResult struct { - Success *example.ExampleMapResp -} - -var MapMethodTestResult_Success_DEFAULT *example.ExampleMapResp - -func (p *MapMethodTestResult) FastRead(buf []byte, _type int8, number int32) (n int, err error) { - if !p.IsSetSuccess() { - p.Success = new(example.ExampleMapResp) - } - return p.Success.FastRead(buf, _type, number) -} - -func (p *MapMethodTestResult) FastWrite(buf []byte) (n int) { - if !p.IsSetSuccess() { - return 0 - } - return p.Success.FastWrite(buf) -} - -func (p *MapMethodTestResult) Size() (n int) { - if !p.IsSetSuccess() { - return 0 - } - return p.Success.Size() -} - -func (p *MapMethodTestResult) Marshal(out []byte) ([]byte, error) { - if !p.IsSetSuccess() { - return out, fmt.Errorf("No req in MapMethodTestResult") - } - return proto.Marshal(p.Success) -} - -func (p *MapMethodTestResult) Unmarshal(in []byte) error { - msg := new(example.ExampleMapResp) - if err := proto.Unmarshal(in, msg); err != nil { - return err - } - p.Success = msg - return nil -} - -func (p *MapMethodTestResult) GetSuccess() *example.ExampleMapResp { - if !p.IsSetSuccess() { - return MapMethodTestResult_Success_DEFAULT - } - return p.Success -} - -func (p *MapMethodTestResult) SetSuccess(x interface{}) { - p.Success = x.(*example.ExampleMapResp) -} - -func (p *MapMethodTestResult) IsSetSuccess() bool { - return p.Success != nil -} - -func (p *MapMethodTestResult) GetResult() interface{} { - return p.Success -} - -func oneofMethodTestHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { - switch s := arg.(type) { - case *streaming.Args: - st := s.Stream - req := new(example.ExampleOneofReq) - if err := st.RecvMsg(req); err != nil { - return err - } - resp, err := handler.(example.TestService).OneofMethodTest(ctx, req) - if err != nil { - return err - } - if err := st.SendMsg(resp); err != nil { - return err - } - case *OneofMethodTestArgs: - success, err := handler.(example.TestService).OneofMethodTest(ctx, s.Req) - if err != nil { - return err - } - realResult := result.(*OneofMethodTestResult) - realResult.Success = success - } - return nil -} -func newOneofMethodTestArgs() interface{} { - return &OneofMethodTestArgs{} -} - -func newOneofMethodTestResult() interface{} { - return &OneofMethodTestResult{} -} - -type OneofMethodTestArgs struct { - Req *example.ExampleOneofReq -} - -func (p *OneofMethodTestArgs) FastRead(buf []byte, _type int8, number int32) (n int, err error) { - if !p.IsSetReq() { - p.Req = new(example.ExampleOneofReq) - } - return p.Req.FastRead(buf, _type, number) -} - -func (p *OneofMethodTestArgs) FastWrite(buf []byte) (n int) { - if !p.IsSetReq() { - return 0 - } - return p.Req.FastWrite(buf) -} - -func (p *OneofMethodTestArgs) Size() (n int) { - if !p.IsSetReq() { - return 0 - } - return p.Req.Size() -} - -func (p *OneofMethodTestArgs) Marshal(out []byte) ([]byte, error) { - if !p.IsSetReq() { - return out, fmt.Errorf("No req in OneofMethodTestArgs") - } - return proto.Marshal(p.Req) -} - -func (p *OneofMethodTestArgs) Unmarshal(in []byte) error { - msg := new(example.ExampleOneofReq) - if err := proto.Unmarshal(in, msg); err != nil { - return err - } - p.Req = msg - return nil -} - -var OneofMethodTestArgs_Req_DEFAULT *example.ExampleOneofReq - -func (p *OneofMethodTestArgs) GetReq() *example.ExampleOneofReq { - if !p.IsSetReq() { - return OneofMethodTestArgs_Req_DEFAULT - } - return p.Req -} - -func (p *OneofMethodTestArgs) IsSetReq() bool { - return p.Req != nil -} - -func (p *OneofMethodTestArgs) GetFirstArgument() interface{} { - return p.Req -} - -type OneofMethodTestResult struct { - Success *example.ExampleOneofResp -} - -var OneofMethodTestResult_Success_DEFAULT *example.ExampleOneofResp - -func (p *OneofMethodTestResult) FastRead(buf []byte, _type int8, number int32) (n int, err error) { - if !p.IsSetSuccess() { - p.Success = new(example.ExampleOneofResp) - } - return p.Success.FastRead(buf, _type, number) -} - -func (p *OneofMethodTestResult) FastWrite(buf []byte) (n int) { - if !p.IsSetSuccess() { - return 0 - } - return p.Success.FastWrite(buf) -} - -func (p *OneofMethodTestResult) Size() (n int) { - if !p.IsSetSuccess() { - return 0 - } - return p.Success.Size() -} - -func (p *OneofMethodTestResult) Marshal(out []byte) ([]byte, error) { - if !p.IsSetSuccess() { - return out, fmt.Errorf("No req in OneofMethodTestResult") - } - return proto.Marshal(p.Success) -} - -func (p *OneofMethodTestResult) Unmarshal(in []byte) error { - msg := new(example.ExampleOneofResp) - if err := proto.Unmarshal(in, msg); err != nil { - return err - } - p.Success = msg - return nil -} - -func (p *OneofMethodTestResult) GetSuccess() *example.ExampleOneofResp { - if !p.IsSetSuccess() { - return OneofMethodTestResult_Success_DEFAULT - } - return p.Success -} - -func (p *OneofMethodTestResult) SetSuccess(x interface{}) { - p.Success = x.(*example.ExampleOneofResp) -} - -func (p *OneofMethodTestResult) IsSetSuccess() bool { - return p.Success != nil -} - -func (p *OneofMethodTestResult) GetResult() interface{} { - return p.Success -} - -type kClient struct { - c client.Client -} - -func newServiceClient(c client.Client) *kClient { - return &kClient{ - c: c, - } -} - -func (p *kClient) ScalarsMethodTest(ctx context.Context, Req *example.ExampleScalarsReq) (r *example.ExampleScalarsResp, err error) { - var _args ScalarsMethodTestArgs - _args.Req = Req - var _result ScalarsMethodTestResult - if err = p.c.Call(ctx, "ScalarsMethodTest", &_args, &_result); err != nil { - return - } - return _result.GetSuccess(), nil -} - -func (p *kClient) MessageMethodTest(ctx context.Context, Req *example.ExampleMessageReq) (r *example.ExampleMessageResp, err error) { - var _args MessageMethodTestArgs - _args.Req = Req - var _result MessageMethodTestResult - if err = p.c.Call(ctx, "MessageMethodTest", &_args, &_result); err != nil { - return - } - return _result.GetSuccess(), nil -} - -func (p *kClient) NestedMethodTest(ctx context.Context, Req *example.ExampleNestedReq) (r *example.ExampleNestedResp, err error) { - var _args NestedMethodTestArgs - _args.Req = Req - var _result NestedMethodTestResult - if err = p.c.Call(ctx, "NestedMethodTest", &_args, &_result); err != nil { - return - } - return _result.GetSuccess(), nil -} - -func (p *kClient) PartialMethodTest(ctx context.Context, Req *example.ExampleParitalReq) (r *example.ExamplePartialResp, err error) { - var _args PartialMethodTestArgs - _args.Req = Req - var _result PartialMethodTestResult - if err = p.c.Call(ctx, "PartialMethodTest", &_args, &_result); err != nil { - return - } - return _result.GetSuccess(), nil -} - -func (p *kClient) ListMethodTest(ctx context.Context, Req *example.ExampleListReq) (r *example.ExampleListResp, err error) { - var _args ListMethodTestArgs - _args.Req = Req - var _result ListMethodTestResult - if err = p.c.Call(ctx, "ListMethodTest", &_args, &_result); err != nil { - return - } - return _result.GetSuccess(), nil -} - -func (p *kClient) MapMethodTest(ctx context.Context, Req *example.ExampleMapReq) (r *example.ExampleMapResp, err error) { - var _args MapMethodTestArgs - _args.Req = Req - var _result MapMethodTestResult - if err = p.c.Call(ctx, "MapMethodTest", &_args, &_result); err != nil { - return - } - return _result.GetSuccess(), nil -} - -func (p *kClient) OneofMethodTest(ctx context.Context, Req *example.ExampleOneofReq) (r *example.ExampleOneofResp, err error) { - var _args OneofMethodTestArgs - _args.Req = Req - var _result OneofMethodTestResult - if err = p.c.Call(ctx, "OneofMethodTest", &_args, &_result); err != nil { - return - } - return _result.GetSuccess(), nil -} diff --git a/testdata/kitex_gen/pb/example2/example2.pb.fast.go b/testdata/kitex_gen/pb/example2/example2.pb.fast.go index ca650480..c5c3a3c5 100644 --- a/testdata/kitex_gen/pb/example2/example2.pb.fast.go +++ b/testdata/kitex_gen/pb/example2/example2.pb.fast.go @@ -159,7 +159,7 @@ func (x *InnerBase2) fastReadField4(buf []byte, _type int8) (offset int, err err } func (x *InnerBase2) fastReadField5(buf []byte, _type int8) (offset int, err error) { - x.Int64, offset, err = fastpb.ReadInt64(buf, _type) + x.SInt64, offset, err = fastpb.ReadSint64(buf, _type) return offset, err } @@ -212,12 +212,12 @@ func (x *InnerBase2) fastReadField9(buf []byte, _type int8) (offset int, err err func (x *InnerBase2) fastReadField10(buf []byte, _type int8) (offset int, err error) { offset, err = fastpb.ReadList(buf, _type, func(buf []byte, _type int8) (n int, err error) { - var v int32 - v, offset, err = fastpb.ReadInt32(buf, _type) + var v int64 + v, offset, err = fastpb.ReadSint64(buf, _type) if err != nil { return offset, err } - x.SetInt32 = append(x.SetInt32, v) + x.ListSInt64 = append(x.ListSInt64, v) return offset, err }) return offset, err @@ -1270,10 +1270,10 @@ func (x *InnerBase2) fastWriteField4(buf []byte) (offset int) { } func (x *InnerBase2) fastWriteField5(buf []byte) (offset int) { - if x.Int64 == 0 { + if x.SInt64 == 0 { return offset } - offset += fastpb.WriteInt64(buf[offset:], 5, x.GetInt64()) + offset += fastpb.WriteSint64(buf[offset:], 5, x.GetSInt64()) return offset } @@ -1323,13 +1323,13 @@ func (x *InnerBase2) fastWriteField9(buf []byte) (offset int) { } func (x *InnerBase2) fastWriteField10(buf []byte) (offset int) { - if len(x.SetInt32) == 0 { + if len(x.ListSInt64) == 0 { return offset } - offset += fastpb.WriteListPacked(buf[offset:], 10, len(x.GetSetInt32()), + offset += fastpb.WriteListPacked(buf[offset:], 10, len(x.GetListSInt64()), func(buf []byte, numTagOrKey, numIdxOrVal int32) int { offset := 0 - offset += fastpb.WriteInt32(buf[offset:], numTagOrKey, x.GetSetInt32()[numIdxOrVal]) + offset += fastpb.WriteSint64(buf[offset:], numTagOrKey, x.GetListSInt64()[numIdxOrVal]) return offset }) return offset @@ -2072,10 +2072,10 @@ func (x *InnerBase2) sizeField4() (n int) { } func (x *InnerBase2) sizeField5() (n int) { - if x.Int64 == 0 { + if x.SInt64 == 0 { return n } - n += fastpb.SizeInt64(5, x.GetInt64()) + n += fastpb.SizeSint64(5, x.GetSInt64()) return n } @@ -2125,13 +2125,13 @@ func (x *InnerBase2) sizeField9() (n int) { } func (x *InnerBase2) sizeField10() (n int) { - if len(x.SetInt32) == 0 { + if len(x.ListSInt64) == 0 { return n } - n += fastpb.SizeListPacked(10, len(x.GetSetInt32()), + n += fastpb.SizeListPacked(10, len(x.GetListSInt64()), func(numTagOrKey, numIdxOrVal int32) int { n := 0 - n += fastpb.SizeInt32(numTagOrKey, x.GetSetInt32()[numIdxOrVal]) + n += fastpb.SizeSint64(numTagOrKey, x.GetListSInt64()[numIdxOrVal]) return n }) return n @@ -2817,12 +2817,12 @@ var fieldIDToName_InnerBase2 = map[int32]string{ 2: "Uint32", 3: "Uint64", 4: "Int32", - 5: "Int64", + 5: "SInt64", 6: "Double", 7: "String_", 8: "ListInt32", 9: "MapStringString", - 10: "SetInt32", + 10: "ListSInt64", 11: "Foo", 12: "MapInt32String", 13: "Binary", @@ -2924,4 +2924,4 @@ var fieldIDToName_ExampleInt2Float = map[int32]string{ 32767: "Subfix", } -var _ = base.File_base_proto +var _ = base.File_idl_base_proto diff --git a/testdata/kitex_gen/pb/example2/example2.pb.go b/testdata/kitex_gen/pb/example2/example2.pb.go index a25379e1..a8bf3814 100644 --- a/testdata/kitex_gen/pb/example2/example2.pb.go +++ b/testdata/kitex_gen/pb/example2/example2.pb.go @@ -7,8 +7,8 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.28.1 -// protoc v4.23.1 -// source: example2.proto +// protoc v5.26.1 +// source: idl/example2.proto package example2 @@ -55,11 +55,11 @@ func (x FOO) String() string { } func (FOO) Descriptor() protoreflect.EnumDescriptor { - return file_example2_proto_enumTypes[0].Descriptor() + return file_idl_example2_proto_enumTypes[0].Descriptor() } func (FOO) Type() protoreflect.EnumType { - return &file_example2_proto_enumTypes[0] + return &file_idl_example2_proto_enumTypes[0] } func (x FOO) Number() protoreflect.EnumNumber { @@ -68,7 +68,7 @@ func (x FOO) Number() protoreflect.EnumNumber { // Deprecated: Use FOO.Descriptor instead. func (FOO) EnumDescriptor() ([]byte, []int) { - return file_example2_proto_rawDescGZIP(), []int{0} + return file_idl_example2_proto_rawDescGZIP(), []int{0} } type InnerBase2 struct { @@ -80,12 +80,12 @@ type InnerBase2 struct { Uint32 uint32 `protobuf:"varint,2,opt,name=Uint32,proto3" json:"Uint32,omitempty"` Uint64 uint64 `protobuf:"varint,3,opt,name=Uint64,proto3" json:"Uint64,omitempty"` Int32 int32 `protobuf:"varint,4,opt,name=Int32,proto3" json:"Int32,omitempty"` - Int64 int64 `protobuf:"varint,5,opt,name=Int64,proto3" json:"Int64,omitempty"` + SInt64 int64 `protobuf:"zigzag64,5,opt,name=SInt64,proto3" json:"SInt64,omitempty"` Double float64 `protobuf:"fixed64,6,opt,name=Double,proto3" json:"Double,omitempty"` String_ string `protobuf:"bytes,7,opt,name=String,proto3" json:"String,omitempty"` ListInt32 []int32 `protobuf:"varint,8,rep,packed,name=ListInt32,proto3" json:"ListInt32,omitempty"` MapStringString map[string]string `protobuf:"bytes,9,rep,name=MapStringString,proto3" json:"MapStringString,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` - SetInt32 []int32 `protobuf:"varint,10,rep,packed,name=SetInt32,proto3" json:"SetInt32,omitempty"` + ListSInt64 []int64 `protobuf:"zigzag64,10,rep,packed,name=ListSInt64,proto3" json:"ListSInt64,omitempty"` Foo FOO `protobuf:"varint,11,opt,name=Foo,proto3,enum=pb3.FOO" json:"Foo,omitempty"` MapInt32String map[int32]string `protobuf:"bytes,12,rep,name=MapInt32String,proto3" json:"MapInt32String,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` Binary []byte `protobuf:"bytes,13,opt,name=Binary,proto3" json:"Binary,omitempty"` @@ -103,7 +103,7 @@ type InnerBase2 struct { func (x *InnerBase2) Reset() { *x = InnerBase2{} if protoimpl.UnsafeEnabled { - mi := &file_example2_proto_msgTypes[0] + mi := &file_idl_example2_proto_msgTypes[0] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -116,7 +116,7 @@ func (x *InnerBase2) String() string { func (*InnerBase2) ProtoMessage() {} func (x *InnerBase2) ProtoReflect() protoreflect.Message { - mi := &file_example2_proto_msgTypes[0] + mi := &file_idl_example2_proto_msgTypes[0] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -129,7 +129,7 @@ func (x *InnerBase2) ProtoReflect() protoreflect.Message { // Deprecated: Use InnerBase2.ProtoReflect.Descriptor instead. func (*InnerBase2) Descriptor() ([]byte, []int) { - return file_example2_proto_rawDescGZIP(), []int{0} + return file_idl_example2_proto_rawDescGZIP(), []int{0} } func (x *InnerBase2) GetBool() bool { @@ -160,9 +160,9 @@ func (x *InnerBase2) GetInt32() int32 { return 0 } -func (x *InnerBase2) GetInt64() int64 { +func (x *InnerBase2) GetSInt64() int64 { if x != nil { - return x.Int64 + return x.SInt64 } return 0 } @@ -195,9 +195,9 @@ func (x *InnerBase2) GetMapStringString() map[string]string { return nil } -func (x *InnerBase2) GetSetInt32() []int32 { +func (x *InnerBase2) GetListSInt64() []int64 { if x != nil { - return x.SetInt32 + return x.ListSInt64 } return nil } @@ -303,7 +303,7 @@ type InnerBasePartial struct { func (x *InnerBasePartial) Reset() { *x = InnerBasePartial{} if protoimpl.UnsafeEnabled { - mi := &file_example2_proto_msgTypes[1] + mi := &file_idl_example2_proto_msgTypes[1] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -316,7 +316,7 @@ func (x *InnerBasePartial) String() string { func (*InnerBasePartial) ProtoMessage() {} func (x *InnerBasePartial) ProtoReflect() protoreflect.Message { - mi := &file_example2_proto_msgTypes[1] + mi := &file_idl_example2_proto_msgTypes[1] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -329,7 +329,7 @@ func (x *InnerBasePartial) ProtoReflect() protoreflect.Message { // Deprecated: Use InnerBasePartial.ProtoReflect.Descriptor instead. func (*InnerBasePartial) Descriptor() ([]byte, []int) { - return file_example2_proto_rawDescGZIP(), []int{1} + return file_idl_example2_proto_rawDescGZIP(), []int{1} } func (x *InnerBasePartial) GetBool() bool { @@ -392,7 +392,7 @@ type BasePartial struct { func (x *BasePartial) Reset() { *x = BasePartial{} if protoimpl.UnsafeEnabled { - mi := &file_example2_proto_msgTypes[2] + mi := &file_idl_example2_proto_msgTypes[2] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -405,7 +405,7 @@ func (x *BasePartial) String() string { func (*BasePartial) ProtoMessage() {} func (x *BasePartial) ProtoReflect() protoreflect.Message { - mi := &file_example2_proto_msgTypes[2] + mi := &file_idl_example2_proto_msgTypes[2] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -418,7 +418,7 @@ func (x *BasePartial) ProtoReflect() protoreflect.Message { // Deprecated: Use BasePartial.ProtoReflect.Descriptor instead. func (*BasePartial) Descriptor() ([]byte, []int) { - return file_example2_proto_rawDescGZIP(), []int{2} + return file_idl_example2_proto_rawDescGZIP(), []int{2} } func (x *BasePartial) GetTrafficEnv() *base.TrafficEnv { @@ -443,7 +443,7 @@ type ExampleReq struct { func (x *ExampleReq) Reset() { *x = ExampleReq{} if protoimpl.UnsafeEnabled { - mi := &file_example2_proto_msgTypes[3] + mi := &file_idl_example2_proto_msgTypes[3] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -456,7 +456,7 @@ func (x *ExampleReq) String() string { func (*ExampleReq) ProtoMessage() {} func (x *ExampleReq) ProtoReflect() protoreflect.Message { - mi := &file_example2_proto_msgTypes[3] + mi := &file_idl_example2_proto_msgTypes[3] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -469,7 +469,7 @@ func (x *ExampleReq) ProtoReflect() protoreflect.Message { // Deprecated: Use ExampleReq.ProtoReflect.Descriptor instead. func (*ExampleReq) Descriptor() ([]byte, []int) { - return file_example2_proto_rawDescGZIP(), []int{3} + return file_idl_example2_proto_rawDescGZIP(), []int{3} } func (x *ExampleReq) GetMsg() string { @@ -527,7 +527,7 @@ type ExampleSuper struct { func (x *ExampleSuper) Reset() { *x = ExampleSuper{} if protoimpl.UnsafeEnabled { - mi := &file_example2_proto_msgTypes[4] + mi := &file_idl_example2_proto_msgTypes[4] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -540,7 +540,7 @@ func (x *ExampleSuper) String() string { func (*ExampleSuper) ProtoMessage() {} func (x *ExampleSuper) ProtoReflect() protoreflect.Message { - mi := &file_example2_proto_msgTypes[4] + mi := &file_idl_example2_proto_msgTypes[4] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -553,7 +553,7 @@ func (x *ExampleSuper) ProtoReflect() protoreflect.Message { // Deprecated: Use ExampleSuper.ProtoReflect.Descriptor instead. func (*ExampleSuper) Descriptor() ([]byte, []int) { - return file_example2_proto_rawDescGZIP(), []int{4} + return file_idl_example2_proto_rawDescGZIP(), []int{4} } func (x *ExampleSuper) GetMsg() string { @@ -637,7 +637,7 @@ type SelfRef struct { func (x *SelfRef) Reset() { *x = SelfRef{} if protoimpl.UnsafeEnabled { - mi := &file_example2_proto_msgTypes[5] + mi := &file_idl_example2_proto_msgTypes[5] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -650,7 +650,7 @@ func (x *SelfRef) String() string { func (*SelfRef) ProtoMessage() {} func (x *SelfRef) ProtoReflect() protoreflect.Message { - mi := &file_example2_proto_msgTypes[5] + mi := &file_idl_example2_proto_msgTypes[5] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -663,7 +663,7 @@ func (x *SelfRef) ProtoReflect() protoreflect.Message { // Deprecated: Use SelfRef.ProtoReflect.Descriptor instead. func (*SelfRef) Descriptor() ([]byte, []int) { - return file_example2_proto_rawDescGZIP(), []int{5} + return file_idl_example2_proto_rawDescGZIP(), []int{5} } func (x *SelfRef) GetSelf() *SelfRef { @@ -686,7 +686,7 @@ type ExampleReqPartial struct { func (x *ExampleReqPartial) Reset() { *x = ExampleReqPartial{} if protoimpl.UnsafeEnabled { - mi := &file_example2_proto_msgTypes[6] + mi := &file_idl_example2_proto_msgTypes[6] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -699,7 +699,7 @@ func (x *ExampleReqPartial) String() string { func (*ExampleReqPartial) ProtoMessage() {} func (x *ExampleReqPartial) ProtoReflect() protoreflect.Message { - mi := &file_example2_proto_msgTypes[6] + mi := &file_idl_example2_proto_msgTypes[6] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -712,7 +712,7 @@ func (x *ExampleReqPartial) ProtoReflect() protoreflect.Message { // Deprecated: Use ExampleReqPartial.ProtoReflect.Descriptor instead. func (*ExampleReqPartial) Descriptor() ([]byte, []int) { - return file_example2_proto_rawDescGZIP(), []int{6} + return file_idl_example2_proto_rawDescGZIP(), []int{6} } func (x *ExampleReqPartial) GetMsg() string { @@ -749,7 +749,7 @@ type ExampleResp struct { func (x *ExampleResp) Reset() { *x = ExampleResp{} if protoimpl.UnsafeEnabled { - mi := &file_example2_proto_msgTypes[7] + mi := &file_idl_example2_proto_msgTypes[7] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -762,7 +762,7 @@ func (x *ExampleResp) String() string { func (*ExampleResp) ProtoMessage() {} func (x *ExampleResp) ProtoReflect() protoreflect.Message { - mi := &file_example2_proto_msgTypes[7] + mi := &file_idl_example2_proto_msgTypes[7] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -775,7 +775,7 @@ func (x *ExampleResp) ProtoReflect() protoreflect.Message { // Deprecated: Use ExampleResp.ProtoReflect.Descriptor instead. func (*ExampleResp) Descriptor() ([]byte, []int) { - return file_example2_proto_rawDescGZIP(), []int{7} + return file_idl_example2_proto_rawDescGZIP(), []int{7} } func (x *ExampleResp) GetMsg() string { @@ -811,7 +811,7 @@ type ExampleRespPartial struct { func (x *ExampleRespPartial) Reset() { *x = ExampleRespPartial{} if protoimpl.UnsafeEnabled { - mi := &file_example2_proto_msgTypes[8] + mi := &file_idl_example2_proto_msgTypes[8] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -824,7 +824,7 @@ func (x *ExampleRespPartial) String() string { func (*ExampleRespPartial) ProtoMessage() {} func (x *ExampleRespPartial) ProtoReflect() protoreflect.Message { - mi := &file_example2_proto_msgTypes[8] + mi := &file_idl_example2_proto_msgTypes[8] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -837,7 +837,7 @@ func (x *ExampleRespPartial) ProtoReflect() protoreflect.Message { // Deprecated: Use ExampleRespPartial.ProtoReflect.Descriptor instead. func (*ExampleRespPartial) Descriptor() ([]byte, []int) { - return file_example2_proto_rawDescGZIP(), []int{8} + return file_idl_example2_proto_rawDescGZIP(), []int{8} } func (x *ExampleRespPartial) GetRequiredField() string { @@ -866,7 +866,7 @@ type Exception struct { func (x *Exception) Reset() { *x = Exception{} if protoimpl.UnsafeEnabled { - mi := &file_example2_proto_msgTypes[9] + mi := &file_idl_example2_proto_msgTypes[9] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -879,7 +879,7 @@ func (x *Exception) String() string { func (*Exception) ProtoMessage() {} func (x *Exception) ProtoReflect() protoreflect.Message { - mi := &file_example2_proto_msgTypes[9] + mi := &file_idl_example2_proto_msgTypes[9] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -892,7 +892,7 @@ func (x *Exception) ProtoReflect() protoreflect.Message { // Deprecated: Use Exception.ProtoReflect.Descriptor instead. func (*Exception) Descriptor() ([]byte, []int) { - return file_example2_proto_rawDescGZIP(), []int{9} + return file_idl_example2_proto_rawDescGZIP(), []int{9} } func (x *Exception) GetCode() int32 { @@ -920,7 +920,7 @@ type A struct { func (x *A) Reset() { *x = A{} if protoimpl.UnsafeEnabled { - mi := &file_example2_proto_msgTypes[10] + mi := &file_idl_example2_proto_msgTypes[10] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -933,7 +933,7 @@ func (x *A) String() string { func (*A) ProtoMessage() {} func (x *A) ProtoReflect() protoreflect.Message { - mi := &file_example2_proto_msgTypes[10] + mi := &file_idl_example2_proto_msgTypes[10] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -946,7 +946,7 @@ func (x *A) ProtoReflect() protoreflect.Message { // Deprecated: Use A.ProtoReflect.Descriptor instead. func (*A) Descriptor() ([]byte, []int) { - return file_example2_proto_rawDescGZIP(), []int{10} + return file_idl_example2_proto_rawDescGZIP(), []int{10} } func (x *A) GetSelf() *A { @@ -967,7 +967,7 @@ type PingResponse struct { func (x *PingResponse) Reset() { *x = PingResponse{} if protoimpl.UnsafeEnabled { - mi := &file_example2_proto_msgTypes[11] + mi := &file_idl_example2_proto_msgTypes[11] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -980,7 +980,7 @@ func (x *PingResponse) String() string { func (*PingResponse) ProtoMessage() {} func (x *PingResponse) ProtoReflect() protoreflect.Message { - mi := &file_example2_proto_msgTypes[11] + mi := &file_idl_example2_proto_msgTypes[11] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -993,7 +993,7 @@ func (x *PingResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use PingResponse.ProtoReflect.Descriptor instead. func (*PingResponse) Descriptor() ([]byte, []int) { - return file_example2_proto_rawDescGZIP(), []int{11} + return file_idl_example2_proto_rawDescGZIP(), []int{11} } func (x *PingResponse) GetMessage() string { @@ -1014,7 +1014,7 @@ type OnewayRequest struct { func (x *OnewayRequest) Reset() { *x = OnewayRequest{} if protoimpl.UnsafeEnabled { - mi := &file_example2_proto_msgTypes[12] + mi := &file_idl_example2_proto_msgTypes[12] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1027,7 +1027,7 @@ func (x *OnewayRequest) String() string { func (*OnewayRequest) ProtoMessage() {} func (x *OnewayRequest) ProtoReflect() protoreflect.Message { - mi := &file_example2_proto_msgTypes[12] + mi := &file_idl_example2_proto_msgTypes[12] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1040,7 +1040,7 @@ func (x *OnewayRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use OnewayRequest.ProtoReflect.Descriptor instead. func (*OnewayRequest) Descriptor() ([]byte, []int) { - return file_example2_proto_rawDescGZIP(), []int{12} + return file_idl_example2_proto_rawDescGZIP(), []int{12} } func (x *OnewayRequest) GetMsg() string { @@ -1061,7 +1061,7 @@ type VoidRequest struct { func (x *VoidRequest) Reset() { *x = VoidRequest{} if protoimpl.UnsafeEnabled { - mi := &file_example2_proto_msgTypes[13] + mi := &file_idl_example2_proto_msgTypes[13] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1074,7 +1074,7 @@ func (x *VoidRequest) String() string { func (*VoidRequest) ProtoMessage() {} func (x *VoidRequest) ProtoReflect() protoreflect.Message { - mi := &file_example2_proto_msgTypes[13] + mi := &file_idl_example2_proto_msgTypes[13] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1087,7 +1087,7 @@ func (x *VoidRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use VoidRequest.ProtoReflect.Descriptor instead. func (*VoidRequest) Descriptor() ([]byte, []int) { - return file_example2_proto_rawDescGZIP(), []int{13} + return file_idl_example2_proto_rawDescGZIP(), []int{13} } func (x *VoidRequest) GetMsg() string { @@ -1106,7 +1106,7 @@ type VoidResponse struct { func (x *VoidResponse) Reset() { *x = VoidResponse{} if protoimpl.UnsafeEnabled { - mi := &file_example2_proto_msgTypes[14] + mi := &file_idl_example2_proto_msgTypes[14] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1119,7 +1119,7 @@ func (x *VoidResponse) String() string { func (*VoidResponse) ProtoMessage() {} func (x *VoidResponse) ProtoReflect() protoreflect.Message { - mi := &file_example2_proto_msgTypes[14] + mi := &file_idl_example2_proto_msgTypes[14] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1132,7 +1132,7 @@ func (x *VoidResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use VoidResponse.ProtoReflect.Descriptor instead. func (*VoidResponse) Descriptor() ([]byte, []int) { - return file_example2_proto_rawDescGZIP(), []int{14} + return file_idl_example2_proto_rawDescGZIP(), []int{14} } type ExampleInt2Float struct { @@ -1150,7 +1150,7 @@ type ExampleInt2Float struct { func (x *ExampleInt2Float) Reset() { *x = ExampleInt2Float{} if protoimpl.UnsafeEnabled { - mi := &file_example2_proto_msgTypes[15] + mi := &file_idl_example2_proto_msgTypes[15] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1163,7 +1163,7 @@ func (x *ExampleInt2Float) String() string { func (*ExampleInt2Float) ProtoMessage() {} func (x *ExampleInt2Float) ProtoReflect() protoreflect.Message { - mi := &file_example2_proto_msgTypes[15] + mi := &file_idl_example2_proto_msgTypes[15] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1176,7 +1176,7 @@ func (x *ExampleInt2Float) ProtoReflect() protoreflect.Message { // Deprecated: Use ExampleInt2Float.ProtoReflect.Descriptor instead. func (*ExampleInt2Float) Descriptor() ([]byte, []int) { - return file_example2_proto_rawDescGZIP(), []int{15} + return file_idl_example2_proto_rawDescGZIP(), []int{15} } func (x *ExampleInt2Float) GetInt32() int32 { @@ -1214,274 +1214,274 @@ func (x *ExampleInt2Float) GetSubfix() float64 { return 0 } -var File_example2_proto protoreflect.FileDescriptor - -var file_example2_proto_rawDesc = []byte{ - 0x0a, 0x0e, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x32, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, - 0x12, 0x03, 0x70, 0x62, 0x33, 0x1a, 0x0a, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x22, 0xbe, 0x0b, 0x0a, 0x0a, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, 0x32, - 0x12, 0x12, 0x0a, 0x04, 0x42, 0x6f, 0x6f, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x04, - 0x42, 0x6f, 0x6f, 0x6c, 0x12, 0x16, 0x0a, 0x06, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x02, - 0x20, 0x01, 0x28, 0x0d, 0x52, 0x06, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x16, 0x0a, 0x06, - 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x55, 0x69, - 0x6e, 0x74, 0x36, 0x34, 0x12, 0x14, 0x0a, 0x05, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x04, 0x20, - 0x01, 0x28, 0x05, 0x52, 0x05, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x14, 0x0a, 0x05, 0x49, 0x6e, - 0x74, 0x36, 0x34, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x49, 0x6e, 0x74, 0x36, 0x34, - 0x12, 0x16, 0x0a, 0x06, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x01, - 0x52, 0x06, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x53, 0x74, 0x72, 0x69, - 0x6e, 0x67, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, - 0x12, 0x1c, 0x0a, 0x09, 0x4c, 0x69, 0x73, 0x74, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x08, 0x20, - 0x03, 0x28, 0x05, 0x52, 0x09, 0x4c, 0x69, 0x73, 0x74, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x4e, - 0x0a, 0x0f, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x72, 0x69, 0x6e, - 0x67, 0x18, 0x09, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x49, 0x6e, - 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, 0x32, 0x2e, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, - 0x6e, 0x67, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0f, 0x4d, - 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x1a, - 0x0a, 0x08, 0x53, 0x65, 0x74, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x0a, 0x20, 0x03, 0x28, 0x05, - 0x52, 0x08, 0x53, 0x65, 0x74, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x1a, 0x0a, 0x03, 0x46, 0x6f, - 0x6f, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x08, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x46, 0x4f, - 0x4f, 0x52, 0x03, 0x46, 0x6f, 0x6f, 0x12, 0x4b, 0x0a, 0x0e, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, - 0x33, 0x32, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x0c, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x23, - 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, 0x32, 0x2e, - 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x45, 0x6e, - 0x74, 0x72, 0x79, 0x52, 0x0e, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x53, 0x74, 0x72, - 0x69, 0x6e, 0x67, 0x12, 0x16, 0x0a, 0x06, 0x42, 0x69, 0x6e, 0x61, 0x72, 0x79, 0x18, 0x0d, 0x20, - 0x01, 0x28, 0x0c, 0x52, 0x06, 0x42, 0x69, 0x6e, 0x61, 0x72, 0x79, 0x12, 0x4e, 0x0a, 0x0f, 0x4d, - 0x61, 0x70, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x0e, - 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, - 0x42, 0x61, 0x73, 0x65, 0x32, 0x2e, 0x4d, 0x61, 0x70, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x53, - 0x74, 0x72, 0x69, 0x6e, 0x67, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0f, 0x4d, 0x61, 0x70, 0x55, - 0x69, 0x6e, 0x74, 0x33, 0x32, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x4e, 0x0a, 0x0f, 0x4d, - 0x61, 0x70, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x0f, - 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, - 0x42, 0x61, 0x73, 0x65, 0x32, 0x2e, 0x4d, 0x61, 0x70, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x53, - 0x74, 0x72, 0x69, 0x6e, 0x67, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0f, 0x4d, 0x61, 0x70, 0x55, - 0x69, 0x6e, 0x74, 0x36, 0x34, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x4b, 0x0a, 0x0e, 0x4d, - 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x10, 0x20, - 0x03, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, - 0x61, 0x73, 0x65, 0x32, 0x2e, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x53, 0x74, 0x72, - 0x69, 0x6e, 0x67, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0e, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, - 0x36, 0x34, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x45, 0x0a, 0x0c, 0x4d, 0x61, 0x70, 0x49, - 0x6e, 0x74, 0x36, 0x34, 0x42, 0x61, 0x73, 0x65, 0x18, 0x11, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x21, - 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, 0x32, 0x2e, - 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x42, 0x61, 0x73, 0x65, 0x45, 0x6e, 0x74, 0x72, - 0x79, 0x52, 0x0c, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x42, 0x61, 0x73, 0x65, 0x12, - 0x48, 0x0a, 0x0d, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x42, 0x61, 0x73, 0x65, - 0x18, 0x14, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x49, 0x6e, 0x6e, - 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, 0x32, 0x2e, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, - 0x67, 0x42, 0x61, 0x73, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0d, 0x4d, 0x61, 0x70, 0x53, - 0x74, 0x72, 0x69, 0x6e, 0x67, 0x42, 0x61, 0x73, 0x65, 0x12, 0x25, 0x0a, 0x08, 0x4c, 0x69, 0x73, - 0x74, 0x42, 0x61, 0x73, 0x65, 0x18, 0x13, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x09, 0x2e, 0x70, 0x62, - 0x33, 0x2e, 0x42, 0x61, 0x73, 0x65, 0x52, 0x08, 0x4c, 0x69, 0x73, 0x74, 0x42, 0x61, 0x73, 0x65, - 0x12, 0x35, 0x0a, 0x0d, 0x4c, 0x69, 0x73, 0x74, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, - 0x65, 0x18, 0x12, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x49, 0x6e, - 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, 0x32, 0x52, 0x0d, 0x4c, 0x69, 0x73, 0x74, 0x49, 0x6e, - 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, 0x12, 0x1e, 0x0a, 0x0a, 0x4c, 0x69, 0x73, 0x74, 0x53, - 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x15, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x4c, 0x69, 0x73, - 0x74, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x1e, 0x0a, 0x04, 0x42, 0x61, 0x73, 0x65, 0x18, - 0xff, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x09, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x42, 0x61, 0x73, - 0x65, 0x52, 0x04, 0x42, 0x61, 0x73, 0x65, 0x1a, 0x42, 0x0a, 0x14, 0x4d, 0x61, 0x70, 0x53, 0x74, - 0x72, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, - 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, - 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x41, 0x0a, 0x13, 0x4d, - 0x61, 0x70, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x45, 0x6e, 0x74, - 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, - 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x42, - 0x0a, 0x14, 0x4d, 0x61, 0x70, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x53, 0x74, 0x72, 0x69, 0x6e, - 0x67, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x0d, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, - 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, - 0x38, 0x01, 0x1a, 0x42, 0x0a, 0x14, 0x4d, 0x61, 0x70, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x53, - 0x74, 0x72, 0x69, 0x6e, 0x67, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, - 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, - 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, - 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x41, 0x0a, 0x13, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, - 0x36, 0x34, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, - 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, - 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, - 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x4a, 0x0a, 0x11, 0x4d, 0x61, 0x70, - 0x49, 0x6e, 0x74, 0x36, 0x34, 0x42, 0x61, 0x73, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, - 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, 0x79, - 0x12, 0x1f, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x09, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x42, 0x61, 0x73, 0x65, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, - 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x4b, 0x0a, 0x12, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, - 0x6e, 0x67, 0x42, 0x61, 0x73, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, - 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x1f, 0x0a, - 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x09, 0x2e, 0x70, - 0x62, 0x33, 0x2e, 0x42, 0x61, 0x73, 0x65, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, - 0x38, 0x01, 0x22, 0x8b, 0x05, 0x0a, 0x10, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, - 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x12, 0x12, 0x0a, 0x04, 0x42, 0x6f, 0x6f, 0x6c, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x04, 0x42, 0x6f, 0x6f, 0x6c, 0x12, 0x1c, 0x0a, 0x09, 0x4c, - 0x69, 0x73, 0x74, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x08, 0x20, 0x03, 0x28, 0x05, 0x52, 0x09, - 0x4c, 0x69, 0x73, 0x74, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x54, 0x0a, 0x0f, 0x4d, 0x61, 0x70, - 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x09, 0x20, 0x03, - 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, 0x61, - 0x73, 0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x2e, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, - 0x69, 0x6e, 0x67, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0f, - 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, - 0x4e, 0x0a, 0x0d, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x42, 0x61, 0x73, 0x65, - 0x18, 0x14, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x49, 0x6e, 0x6e, - 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x2e, 0x4d, 0x61, - 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x42, 0x61, 0x73, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, - 0x52, 0x0d, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x42, 0x61, 0x73, 0x65, 0x12, - 0x3b, 0x0a, 0x0d, 0x4c, 0x69, 0x73, 0x74, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, - 0x18, 0x12, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x49, 0x6e, 0x6e, - 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x52, 0x0d, 0x4c, - 0x69, 0x73, 0x74, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, 0x12, 0x2c, 0x0a, 0x08, - 0x4c, 0x69, 0x73, 0x74, 0x42, 0x61, 0x73, 0x65, 0x18, 0x13, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x10, - 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x42, 0x61, 0x73, 0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, - 0x52, 0x08, 0x4c, 0x69, 0x73, 0x74, 0x42, 0x61, 0x73, 0x65, 0x12, 0x57, 0x0a, 0x10, 0x4d, 0x61, - 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x32, 0x18, 0x7f, - 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, - 0x42, 0x61, 0x73, 0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x2e, 0x4d, 0x61, 0x70, 0x53, - 0x74, 0x72, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x32, 0x45, 0x6e, 0x74, 0x72, - 0x79, 0x52, 0x10, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x72, 0x69, - 0x6e, 0x67, 0x32, 0x1a, 0x42, 0x0a, 0x14, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, - 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, - 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, - 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, - 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x52, 0x0a, 0x12, 0x4d, 0x61, 0x70, 0x53, 0x74, - 0x72, 0x69, 0x6e, 0x67, 0x42, 0x61, 0x73, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, +var File_idl_example2_proto protoreflect.FileDescriptor + +var file_idl_example2_proto_rawDesc = []byte{ + 0x0a, 0x12, 0x69, 0x64, 0x6c, 0x2f, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x32, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x03, 0x70, 0x62, 0x33, 0x1a, 0x0e, 0x69, 0x64, 0x6c, 0x2f, 0x62, + 0x61, 0x73, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xc4, 0x0b, 0x0a, 0x0a, 0x49, 0x6e, + 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, 0x32, 0x12, 0x12, 0x0a, 0x04, 0x42, 0x6f, 0x6f, 0x6c, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x04, 0x42, 0x6f, 0x6f, 0x6c, 0x12, 0x16, 0x0a, 0x06, + 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x06, 0x55, 0x69, + 0x6e, 0x74, 0x33, 0x32, 0x12, 0x16, 0x0a, 0x06, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x14, 0x0a, 0x05, + 0x49, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x49, 0x6e, 0x74, + 0x33, 0x32, 0x12, 0x16, 0x0a, 0x06, 0x53, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x05, 0x20, 0x01, + 0x28, 0x12, 0x52, 0x06, 0x53, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x16, 0x0a, 0x06, 0x44, 0x6f, + 0x75, 0x62, 0x6c, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x01, 0x52, 0x06, 0x44, 0x6f, 0x75, 0x62, + 0x6c, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x07, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x06, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x1c, 0x0a, 0x09, 0x4c, 0x69, + 0x73, 0x74, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x08, 0x20, 0x03, 0x28, 0x05, 0x52, 0x09, 0x4c, + 0x69, 0x73, 0x74, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x4e, 0x0a, 0x0f, 0x4d, 0x61, 0x70, 0x53, + 0x74, 0x72, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x09, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x24, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, + 0x65, 0x32, 0x2e, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x72, 0x69, + 0x6e, 0x67, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0f, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, + 0x6e, 0x67, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x1e, 0x0a, 0x0a, 0x4c, 0x69, 0x73, 0x74, + 0x53, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x0a, 0x20, 0x03, 0x28, 0x12, 0x52, 0x0a, 0x4c, 0x69, + 0x73, 0x74, 0x53, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x1a, 0x0a, 0x03, 0x46, 0x6f, 0x6f, 0x18, + 0x0b, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x08, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x46, 0x4f, 0x4f, 0x52, + 0x03, 0x46, 0x6f, 0x6f, 0x12, 0x4b, 0x0a, 0x0e, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x33, 0x32, + 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x0c, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x70, + 0x62, 0x33, 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, 0x32, 0x2e, 0x4d, 0x61, + 0x70, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x45, 0x6e, 0x74, 0x72, + 0x79, 0x52, 0x0e, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x53, 0x74, 0x72, 0x69, 0x6e, + 0x67, 0x12, 0x16, 0x0a, 0x06, 0x42, 0x69, 0x6e, 0x61, 0x72, 0x79, 0x18, 0x0d, 0x20, 0x01, 0x28, + 0x0c, 0x52, 0x06, 0x42, 0x69, 0x6e, 0x61, 0x72, 0x79, 0x12, 0x4e, 0x0a, 0x0f, 0x4d, 0x61, 0x70, + 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x0e, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, 0x61, + 0x73, 0x65, 0x32, 0x2e, 0x4d, 0x61, 0x70, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x53, 0x74, 0x72, + 0x69, 0x6e, 0x67, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0f, 0x4d, 0x61, 0x70, 0x55, 0x69, 0x6e, + 0x74, 0x33, 0x32, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x4e, 0x0a, 0x0f, 0x4d, 0x61, 0x70, + 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x0f, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, 0x61, + 0x73, 0x65, 0x32, 0x2e, 0x4d, 0x61, 0x70, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x53, 0x74, 0x72, + 0x69, 0x6e, 0x67, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0f, 0x4d, 0x61, 0x70, 0x55, 0x69, 0x6e, + 0x74, 0x36, 0x34, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x4b, 0x0a, 0x0e, 0x4d, 0x61, 0x70, + 0x49, 0x6e, 0x74, 0x36, 0x34, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x10, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x23, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, + 0x65, 0x32, 0x2e, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x53, 0x74, 0x72, 0x69, 0x6e, + 0x67, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0e, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, + 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x45, 0x0a, 0x0c, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, + 0x36, 0x34, 0x42, 0x61, 0x73, 0x65, 0x18, 0x11, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x70, + 0x62, 0x33, 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, 0x32, 0x2e, 0x4d, 0x61, + 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x42, 0x61, 0x73, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, + 0x0c, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x42, 0x61, 0x73, 0x65, 0x12, 0x48, 0x0a, + 0x0d, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x42, 0x61, 0x73, 0x65, 0x18, 0x14, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, + 0x42, 0x61, 0x73, 0x65, 0x32, 0x2e, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x42, + 0x61, 0x73, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0d, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, + 0x69, 0x6e, 0x67, 0x42, 0x61, 0x73, 0x65, 0x12, 0x25, 0x0a, 0x08, 0x4c, 0x69, 0x73, 0x74, 0x42, + 0x61, 0x73, 0x65, 0x18, 0x13, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x09, 0x2e, 0x70, 0x62, 0x33, 0x2e, + 0x42, 0x61, 0x73, 0x65, 0x52, 0x08, 0x4c, 0x69, 0x73, 0x74, 0x42, 0x61, 0x73, 0x65, 0x12, 0x35, + 0x0a, 0x0d, 0x4c, 0x69, 0x73, 0x74, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, 0x18, + 0x12, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x49, 0x6e, 0x6e, 0x65, + 0x72, 0x42, 0x61, 0x73, 0x65, 0x32, 0x52, 0x0d, 0x4c, 0x69, 0x73, 0x74, 0x49, 0x6e, 0x6e, 0x65, + 0x72, 0x42, 0x61, 0x73, 0x65, 0x12, 0x1e, 0x0a, 0x0a, 0x4c, 0x69, 0x73, 0x74, 0x53, 0x74, 0x72, + 0x69, 0x6e, 0x67, 0x18, 0x15, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x4c, 0x69, 0x73, 0x74, 0x53, + 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x1e, 0x0a, 0x04, 0x42, 0x61, 0x73, 0x65, 0x18, 0xff, 0x01, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x09, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x42, 0x61, 0x73, 0x65, 0x52, + 0x04, 0x42, 0x61, 0x73, 0x65, 0x1a, 0x42, 0x0a, 0x14, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, + 0x6e, 0x67, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, - 0x26, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, - 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x42, 0x61, 0x73, 0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, - 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x43, 0x0a, 0x15, 0x4d, - 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x32, 0x45, + 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x41, 0x0a, 0x13, 0x4d, 0x61, 0x70, + 0x49, 0x6e, 0x74, 0x33, 0x32, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x45, 0x6e, 0x74, 0x72, 0x79, + 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x6b, + 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x42, 0x0a, 0x14, + 0x4d, 0x61, 0x70, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, + 0x0d, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, - 0x22, 0x3e, 0x0a, 0x0b, 0x42, 0x61, 0x73, 0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x12, - 0x2f, 0x0a, 0x0a, 0x54, 0x72, 0x61, 0x66, 0x66, 0x69, 0x63, 0x45, 0x6e, 0x76, 0x18, 0x05, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x54, 0x72, 0x61, 0x66, 0x66, 0x69, - 0x63, 0x45, 0x6e, 0x76, 0x52, 0x0a, 0x54, 0x72, 0x61, 0x66, 0x66, 0x69, 0x63, 0x45, 0x6e, 0x76, - 0x22, 0x97, 0x01, 0x0a, 0x0a, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x12, - 0x10, 0x0a, 0x03, 0x4d, 0x73, 0x67, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x4d, 0x73, - 0x67, 0x12, 0x0c, 0x0a, 0x01, 0x41, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x01, 0x41, 0x12, - 0x2f, 0x0a, 0x0a, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, 0x32, 0x18, 0x03, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, - 0x61, 0x73, 0x65, 0x32, 0x52, 0x0a, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, 0x32, - 0x12, 0x1e, 0x0a, 0x04, 0x42, 0x61, 0x73, 0x65, 0x18, 0xff, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x09, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x42, 0x61, 0x73, 0x65, 0x52, 0x04, 0x42, 0x61, 0x73, 0x65, - 0x12, 0x18, 0x0a, 0x06, 0x53, 0x75, 0x62, 0x66, 0x69, 0x78, 0x18, 0xff, 0xff, 0x01, 0x20, 0x01, - 0x28, 0x01, 0x52, 0x06, 0x53, 0x75, 0x62, 0x66, 0x69, 0x78, 0x22, 0x89, 0x02, 0x0a, 0x0c, 0x45, - 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x53, 0x75, 0x70, 0x65, 0x72, 0x12, 0x10, 0x0a, 0x03, 0x4d, - 0x73, 0x67, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x4d, 0x73, 0x67, 0x12, 0x0c, 0x0a, - 0x01, 0x41, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x01, 0x41, 0x12, 0x2f, 0x0a, 0x0a, 0x49, - 0x6e, 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, 0x32, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x0f, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, 0x32, - 0x52, 0x0a, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, 0x32, 0x12, 0x10, 0x0a, 0x03, - 0x45, 0x78, 0x31, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x45, 0x78, 0x31, 0x12, 0x10, - 0x0a, 0x03, 0x45, 0x78, 0x32, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x45, 0x78, 0x32, - 0x12, 0x10, 0x0a, 0x03, 0x45, 0x78, 0x33, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x45, - 0x78, 0x33, 0x12, 0x10, 0x0a, 0x03, 0x45, 0x78, 0x34, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x03, 0x45, 0x78, 0x34, 0x12, 0x26, 0x0a, 0x07, 0x53, 0x65, 0x6c, 0x66, 0x52, 0x65, 0x66, 0x18, - 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x53, 0x65, 0x6c, 0x66, - 0x52, 0x65, 0x66, 0x52, 0x07, 0x53, 0x65, 0x6c, 0x66, 0x52, 0x65, 0x66, 0x12, 0x1e, 0x0a, 0x04, - 0x42, 0x61, 0x73, 0x65, 0x18, 0xff, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x09, 0x2e, 0x70, 0x62, - 0x33, 0x2e, 0x42, 0x61, 0x73, 0x65, 0x52, 0x04, 0x42, 0x61, 0x73, 0x65, 0x12, 0x18, 0x0a, 0x06, - 0x53, 0x75, 0x62, 0x66, 0x69, 0x78, 0x18, 0xff, 0xff, 0x01, 0x20, 0x01, 0x28, 0x01, 0x52, 0x06, - 0x53, 0x75, 0x62, 0x66, 0x69, 0x78, 0x22, 0x2b, 0x0a, 0x07, 0x53, 0x65, 0x6c, 0x66, 0x52, 0x65, - 0x66, 0x12, 0x20, 0x0a, 0x04, 0x73, 0x65, 0x6c, 0x66, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x0c, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x53, 0x65, 0x6c, 0x66, 0x52, 0x65, 0x66, 0x52, 0x04, 0x73, - 0x65, 0x6c, 0x66, 0x22, 0x83, 0x01, 0x0a, 0x11, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x52, - 0x65, 0x71, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x12, 0x10, 0x0a, 0x03, 0x4d, 0x73, 0x67, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x4d, 0x73, 0x67, 0x12, 0x35, 0x0a, 0x0a, 0x49, - 0x6e, 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, 0x32, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x15, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, 0x50, - 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x52, 0x0a, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, - 0x65, 0x32, 0x12, 0x25, 0x0a, 0x04, 0x42, 0x61, 0x73, 0x65, 0x18, 0xff, 0x01, 0x20, 0x01, 0x28, - 0x0b, 0x32, 0x10, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x42, 0x61, 0x73, 0x65, 0x50, 0x61, 0x72, 0x74, - 0x69, 0x61, 0x6c, 0x52, 0x04, 0x42, 0x61, 0x73, 0x65, 0x22, 0x72, 0x0a, 0x0b, 0x45, 0x78, 0x61, - 0x6d, 0x70, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x12, 0x10, 0x0a, 0x03, 0x4d, 0x73, 0x67, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x4d, 0x73, 0x67, 0x12, 0x25, 0x0a, 0x0e, 0x72, 0x65, - 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x02, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x0d, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x46, 0x69, 0x65, 0x6c, - 0x64, 0x12, 0x2a, 0x0a, 0x08, 0x42, 0x61, 0x73, 0x65, 0x52, 0x65, 0x73, 0x70, 0x18, 0xff, 0x01, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0d, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x42, 0x61, 0x73, 0x65, 0x52, - 0x65, 0x73, 0x70, 0x52, 0x08, 0x42, 0x61, 0x73, 0x65, 0x52, 0x65, 0x73, 0x70, 0x22, 0x67, 0x0a, - 0x12, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x50, 0x61, 0x72, 0x74, - 0x69, 0x61, 0x6c, 0x12, 0x25, 0x0a, 0x0e, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x5f, - 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x72, 0x65, 0x71, - 0x75, 0x69, 0x72, 0x65, 0x64, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x2a, 0x0a, 0x08, 0x42, 0x61, - 0x73, 0x65, 0x52, 0x65, 0x73, 0x70, 0x18, 0xff, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0d, 0x2e, - 0x70, 0x62, 0x33, 0x2e, 0x42, 0x61, 0x73, 0x65, 0x52, 0x65, 0x73, 0x70, 0x52, 0x08, 0x42, 0x61, - 0x73, 0x65, 0x52, 0x65, 0x73, 0x70, 0x22, 0x32, 0x0a, 0x09, 0x45, 0x78, 0x63, 0x65, 0x70, 0x74, - 0x69, 0x6f, 0x6e, 0x12, 0x12, 0x0a, 0x04, 0x63, 0x6f, 0x64, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x05, 0x52, 0x04, 0x63, 0x6f, 0x64, 0x65, 0x12, 0x11, 0x0a, 0x03, 0x6d, 0x73, 0x67, 0x18, 0xff, - 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6d, 0x73, 0x67, 0x22, 0x1f, 0x0a, 0x01, 0x41, 0x12, - 0x1a, 0x0a, 0x04, 0x73, 0x65, 0x6c, 0x66, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x06, 0x2e, - 0x70, 0x62, 0x33, 0x2e, 0x41, 0x52, 0x04, 0x73, 0x65, 0x6c, 0x66, 0x22, 0x28, 0x0a, 0x0c, 0x50, - 0x69, 0x6e, 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x6d, - 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, - 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x21, 0x0a, 0x0d, 0x4f, 0x6e, 0x65, 0x77, 0x61, 0x79, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6d, 0x73, 0x67, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x03, 0x6d, 0x73, 0x67, 0x22, 0x1f, 0x0a, 0x0b, 0x56, 0x6f, 0x69, 0x64, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6d, 0x73, 0x67, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6d, 0x73, 0x67, 0x22, 0x0e, 0x0a, 0x0c, 0x56, 0x6f, 0x69, - 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x8a, 0x01, 0x0a, 0x10, 0x45, 0x78, - 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x49, 0x6e, 0x74, 0x32, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x12, 0x14, - 0x0a, 0x05, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x49, - 0x6e, 0x74, 0x33, 0x32, 0x12, 0x18, 0x0a, 0x07, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x36, 0x34, 0x18, - 0x02, 0x20, 0x01, 0x28, 0x01, 0x52, 0x07, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x36, 0x34, 0x12, 0x16, - 0x0a, 0x06, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, - 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x14, 0x0a, 0x05, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x18, - 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x18, 0x0a, 0x06, - 0x53, 0x75, 0x62, 0x66, 0x69, 0x78, 0x18, 0xff, 0xff, 0x01, 0x20, 0x01, 0x28, 0x01, 0x52, 0x06, - 0x53, 0x75, 0x62, 0x66, 0x69, 0x78, 0x2a, 0x10, 0x0a, 0x03, 0x46, 0x4f, 0x4f, 0x12, 0x09, 0x0a, - 0x05, 0x46, 0x4f, 0x4f, 0x5f, 0x41, 0x10, 0x00, 0x32, 0xce, 0x03, 0x0a, 0x0c, 0x54, 0x65, 0x73, - 0x74, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x32, 0x12, 0x32, 0x0a, 0x0d, 0x45, 0x78, 0x61, - 0x6d, 0x70, 0x6c, 0x65, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x12, 0x0f, 0x2e, 0x70, 0x62, 0x33, - 0x2e, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x1a, 0x10, 0x2e, 0x70, 0x62, - 0x33, 0x2e, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x12, 0x36, 0x0a, - 0x14, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x4d, - 0x65, 0x74, 0x68, 0x6f, 0x64, 0x12, 0x16, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x45, 0x78, 0x61, 0x6d, - 0x70, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x1a, 0x06, 0x2e, - 0x70, 0x62, 0x33, 0x2e, 0x41, 0x12, 0x48, 0x0a, 0x15, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, - 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x32, 0x12, 0x16, - 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x50, - 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x1a, 0x17, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x45, 0x78, 0x61, - 0x6d, 0x70, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x12, - 0x2f, 0x0a, 0x12, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x53, 0x75, 0x70, 0x65, 0x72, 0x4d, - 0x65, 0x74, 0x68, 0x6f, 0x64, 0x12, 0x11, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x45, 0x78, 0x61, 0x6d, - 0x70, 0x6c, 0x65, 0x53, 0x75, 0x70, 0x65, 0x72, 0x1a, 0x06, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x41, - 0x12, 0x3f, 0x0a, 0x0f, 0x49, 0x6e, 0x74, 0x32, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x4d, 0x65, 0x74, - 0x68, 0x6f, 0x64, 0x12, 0x15, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, - 0x65, 0x49, 0x6e, 0x74, 0x32, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x1a, 0x15, 0x2e, 0x70, 0x62, 0x33, - 0x2e, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x49, 0x6e, 0x74, 0x32, 0x46, 0x6c, 0x6f, 0x61, - 0x74, 0x12, 0x15, 0x0a, 0x03, 0x46, 0x6f, 0x6f, 0x12, 0x06, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x41, - 0x1a, 0x06, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x41, 0x12, 0x21, 0x0a, 0x04, 0x50, 0x69, 0x6e, 0x67, - 0x12, 0x06, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x41, 0x1a, 0x11, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x50, - 0x69, 0x6e, 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2f, 0x0a, 0x06, 0x4f, - 0x6e, 0x65, 0x77, 0x61, 0x79, 0x12, 0x12, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x4f, 0x6e, 0x65, 0x77, - 0x61, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x11, 0x2e, 0x70, 0x62, 0x33, 0x2e, - 0x56, 0x6f, 0x69, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2b, 0x0a, 0x04, - 0x56, 0x6f, 0x69, 0x64, 0x12, 0x10, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x56, 0x6f, 0x69, 0x64, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x11, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x56, 0x6f, 0x69, - 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x42, 0x3f, 0x5a, 0x3d, 0x67, 0x69, 0x74, - 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x63, 0x6c, 0x6f, 0x75, 0x64, 0x77, 0x65, 0x67, - 0x6f, 0x2f, 0x64, 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, - 0x64, 0x61, 0x74, 0x61, 0x2f, 0x6b, 0x69, 0x74, 0x65, 0x78, 0x5f, 0x67, 0x65, 0x6e, 0x2f, 0x70, - 0x62, 0x2f, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x32, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x33, + 0x1a, 0x42, 0x0a, 0x14, 0x4d, 0x61, 0x70, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x53, 0x74, 0x72, + 0x69, 0x6e, 0x67, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x41, 0x0a, 0x13, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, + 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, + 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, + 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x4a, 0x0a, 0x11, 0x4d, 0x61, 0x70, 0x49, 0x6e, + 0x74, 0x36, 0x34, 0x42, 0x61, 0x73, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, + 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x1f, + 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x09, 0x2e, + 0x70, 0x62, 0x33, 0x2e, 0x42, 0x61, 0x73, 0x65, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, + 0x02, 0x38, 0x01, 0x1a, 0x4b, 0x0a, 0x12, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, + 0x42, 0x61, 0x73, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x1f, 0x0a, 0x05, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x09, 0x2e, 0x70, 0x62, 0x33, + 0x2e, 0x42, 0x61, 0x73, 0x65, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, + 0x22, 0x8b, 0x05, 0x0a, 0x10, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, 0x50, 0x61, + 0x72, 0x74, 0x69, 0x61, 0x6c, 0x12, 0x12, 0x0a, 0x04, 0x42, 0x6f, 0x6f, 0x6c, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x08, 0x52, 0x04, 0x42, 0x6f, 0x6f, 0x6c, 0x12, 0x1c, 0x0a, 0x09, 0x4c, 0x69, 0x73, + 0x74, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x08, 0x20, 0x03, 0x28, 0x05, 0x52, 0x09, 0x4c, 0x69, + 0x73, 0x74, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x54, 0x0a, 0x0f, 0x4d, 0x61, 0x70, 0x53, 0x74, + 0x72, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x09, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x2a, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, + 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x2e, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, + 0x67, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0f, 0x4d, 0x61, + 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x4e, 0x0a, + 0x0d, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x42, 0x61, 0x73, 0x65, 0x18, 0x14, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, + 0x42, 0x61, 0x73, 0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x2e, 0x4d, 0x61, 0x70, 0x53, + 0x74, 0x72, 0x69, 0x6e, 0x67, 0x42, 0x61, 0x73, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0d, + 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x42, 0x61, 0x73, 0x65, 0x12, 0x3b, 0x0a, + 0x0d, 0x4c, 0x69, 0x73, 0x74, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, 0x18, 0x12, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, + 0x42, 0x61, 0x73, 0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x52, 0x0d, 0x4c, 0x69, 0x73, + 0x74, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, 0x12, 0x2c, 0x0a, 0x08, 0x4c, 0x69, + 0x73, 0x74, 0x42, 0x61, 0x73, 0x65, 0x18, 0x13, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x70, + 0x62, 0x33, 0x2e, 0x42, 0x61, 0x73, 0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x52, 0x08, + 0x4c, 0x69, 0x73, 0x74, 0x42, 0x61, 0x73, 0x65, 0x12, 0x57, 0x0a, 0x10, 0x4d, 0x61, 0x70, 0x53, + 0x74, 0x72, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x32, 0x18, 0x7f, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, 0x61, + 0x73, 0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x2e, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, + 0x69, 0x6e, 0x67, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x32, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, + 0x10, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, + 0x32, 0x1a, 0x42, 0x0a, 0x14, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x53, 0x74, + 0x72, 0x69, 0x6e, 0x67, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x52, 0x0a, 0x12, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, + 0x6e, 0x67, 0x42, 0x61, 0x73, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, + 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x26, 0x0a, + 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x70, + 0x62, 0x33, 0x2e, 0x42, 0x61, 0x73, 0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x52, 0x05, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x43, 0x0a, 0x15, 0x4d, 0x61, 0x70, + 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x32, 0x45, 0x6e, 0x74, + 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x3e, + 0x0a, 0x0b, 0x42, 0x61, 0x73, 0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x12, 0x2f, 0x0a, + 0x0a, 0x54, 0x72, 0x61, 0x66, 0x66, 0x69, 0x63, 0x45, 0x6e, 0x76, 0x18, 0x05, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x0f, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x54, 0x72, 0x61, 0x66, 0x66, 0x69, 0x63, 0x45, + 0x6e, 0x76, 0x52, 0x0a, 0x54, 0x72, 0x61, 0x66, 0x66, 0x69, 0x63, 0x45, 0x6e, 0x76, 0x22, 0x97, + 0x01, 0x0a, 0x0a, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x12, 0x10, 0x0a, + 0x03, 0x4d, 0x73, 0x67, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x4d, 0x73, 0x67, 0x12, + 0x0c, 0x0a, 0x01, 0x41, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x01, 0x41, 0x12, 0x2f, 0x0a, + 0x0a, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, 0x32, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x0f, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, + 0x65, 0x32, 0x52, 0x0a, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, 0x32, 0x12, 0x1e, + 0x0a, 0x04, 0x42, 0x61, 0x73, 0x65, 0x18, 0xff, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x09, 0x2e, + 0x70, 0x62, 0x33, 0x2e, 0x42, 0x61, 0x73, 0x65, 0x52, 0x04, 0x42, 0x61, 0x73, 0x65, 0x12, 0x18, + 0x0a, 0x06, 0x53, 0x75, 0x62, 0x66, 0x69, 0x78, 0x18, 0xff, 0xff, 0x01, 0x20, 0x01, 0x28, 0x01, + 0x52, 0x06, 0x53, 0x75, 0x62, 0x66, 0x69, 0x78, 0x22, 0x89, 0x02, 0x0a, 0x0c, 0x45, 0x78, 0x61, + 0x6d, 0x70, 0x6c, 0x65, 0x53, 0x75, 0x70, 0x65, 0x72, 0x12, 0x10, 0x0a, 0x03, 0x4d, 0x73, 0x67, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x4d, 0x73, 0x67, 0x12, 0x0c, 0x0a, 0x01, 0x41, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x01, 0x41, 0x12, 0x2f, 0x0a, 0x0a, 0x49, 0x6e, 0x6e, + 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, 0x32, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, + 0x70, 0x62, 0x33, 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, 0x32, 0x52, 0x0a, + 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, 0x32, 0x12, 0x10, 0x0a, 0x03, 0x45, 0x78, + 0x31, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x45, 0x78, 0x31, 0x12, 0x10, 0x0a, 0x03, + 0x45, 0x78, 0x32, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x45, 0x78, 0x32, 0x12, 0x10, + 0x0a, 0x03, 0x45, 0x78, 0x33, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x45, 0x78, 0x33, + 0x12, 0x10, 0x0a, 0x03, 0x45, 0x78, 0x34, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x45, + 0x78, 0x34, 0x12, 0x26, 0x0a, 0x07, 0x53, 0x65, 0x6c, 0x66, 0x52, 0x65, 0x66, 0x18, 0x09, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x53, 0x65, 0x6c, 0x66, 0x52, 0x65, + 0x66, 0x52, 0x07, 0x53, 0x65, 0x6c, 0x66, 0x52, 0x65, 0x66, 0x12, 0x1e, 0x0a, 0x04, 0x42, 0x61, + 0x73, 0x65, 0x18, 0xff, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x09, 0x2e, 0x70, 0x62, 0x33, 0x2e, + 0x42, 0x61, 0x73, 0x65, 0x52, 0x04, 0x42, 0x61, 0x73, 0x65, 0x12, 0x18, 0x0a, 0x06, 0x53, 0x75, + 0x62, 0x66, 0x69, 0x78, 0x18, 0xff, 0xff, 0x01, 0x20, 0x01, 0x28, 0x01, 0x52, 0x06, 0x53, 0x75, + 0x62, 0x66, 0x69, 0x78, 0x22, 0x2b, 0x0a, 0x07, 0x53, 0x65, 0x6c, 0x66, 0x52, 0x65, 0x66, 0x12, + 0x20, 0x0a, 0x04, 0x73, 0x65, 0x6c, 0x66, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, + 0x70, 0x62, 0x33, 0x2e, 0x53, 0x65, 0x6c, 0x66, 0x52, 0x65, 0x66, 0x52, 0x04, 0x73, 0x65, 0x6c, + 0x66, 0x22, 0x83, 0x01, 0x0a, 0x11, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x52, 0x65, 0x71, + 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x12, 0x10, 0x0a, 0x03, 0x4d, 0x73, 0x67, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x4d, 0x73, 0x67, 0x12, 0x35, 0x0a, 0x0a, 0x49, 0x6e, 0x6e, + 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, 0x32, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, + 0x70, 0x62, 0x33, 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, 0x50, 0x61, 0x72, + 0x74, 0x69, 0x61, 0x6c, 0x52, 0x0a, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, 0x32, + 0x12, 0x25, 0x0a, 0x04, 0x42, 0x61, 0x73, 0x65, 0x18, 0xff, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x10, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x42, 0x61, 0x73, 0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, + 0x6c, 0x52, 0x04, 0x42, 0x61, 0x73, 0x65, 0x22, 0x72, 0x0a, 0x0b, 0x45, 0x78, 0x61, 0x6d, 0x70, + 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x12, 0x10, 0x0a, 0x03, 0x4d, 0x73, 0x67, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x03, 0x4d, 0x73, 0x67, 0x12, 0x25, 0x0a, 0x0e, 0x72, 0x65, 0x71, 0x75, + 0x69, 0x72, 0x65, 0x64, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x0d, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x12, + 0x2a, 0x0a, 0x08, 0x42, 0x61, 0x73, 0x65, 0x52, 0x65, 0x73, 0x70, 0x18, 0xff, 0x01, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x0d, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x42, 0x61, 0x73, 0x65, 0x52, 0x65, 0x73, + 0x70, 0x52, 0x08, 0x42, 0x61, 0x73, 0x65, 0x52, 0x65, 0x73, 0x70, 0x22, 0x67, 0x0a, 0x12, 0x45, + 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, + 0x6c, 0x12, 0x25, 0x0a, 0x0e, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x5f, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x72, 0x65, 0x71, 0x75, 0x69, + 0x72, 0x65, 0x64, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x2a, 0x0a, 0x08, 0x42, 0x61, 0x73, 0x65, + 0x52, 0x65, 0x73, 0x70, 0x18, 0xff, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0d, 0x2e, 0x70, 0x62, + 0x33, 0x2e, 0x42, 0x61, 0x73, 0x65, 0x52, 0x65, 0x73, 0x70, 0x52, 0x08, 0x42, 0x61, 0x73, 0x65, + 0x52, 0x65, 0x73, 0x70, 0x22, 0x32, 0x0a, 0x09, 0x45, 0x78, 0x63, 0x65, 0x70, 0x74, 0x69, 0x6f, + 0x6e, 0x12, 0x12, 0x0a, 0x04, 0x63, 0x6f, 0x64, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, + 0x04, 0x63, 0x6f, 0x64, 0x65, 0x12, 0x11, 0x0a, 0x03, 0x6d, 0x73, 0x67, 0x18, 0xff, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x03, 0x6d, 0x73, 0x67, 0x22, 0x1f, 0x0a, 0x01, 0x41, 0x12, 0x1a, 0x0a, + 0x04, 0x73, 0x65, 0x6c, 0x66, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x06, 0x2e, 0x70, 0x62, + 0x33, 0x2e, 0x41, 0x52, 0x04, 0x73, 0x65, 0x6c, 0x66, 0x22, 0x28, 0x0a, 0x0c, 0x50, 0x69, 0x6e, + 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x22, 0x21, 0x0a, 0x0d, 0x4f, 0x6e, 0x65, 0x77, 0x61, 0x79, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6d, 0x73, 0x67, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x03, 0x6d, 0x73, 0x67, 0x22, 0x1f, 0x0a, 0x0b, 0x56, 0x6f, 0x69, 0x64, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6d, 0x73, 0x67, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x03, 0x6d, 0x73, 0x67, 0x22, 0x0e, 0x0a, 0x0c, 0x56, 0x6f, 0x69, 0x64, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x8a, 0x01, 0x0a, 0x10, 0x45, 0x78, 0x61, 0x6d, + 0x70, 0x6c, 0x65, 0x49, 0x6e, 0x74, 0x32, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x12, 0x14, 0x0a, 0x05, + 0x49, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x49, 0x6e, 0x74, + 0x33, 0x32, 0x12, 0x18, 0x0a, 0x07, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x36, 0x34, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x01, 0x52, 0x07, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x36, 0x34, 0x12, 0x16, 0x0a, 0x06, + 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x53, 0x74, + 0x72, 0x69, 0x6e, 0x67, 0x12, 0x14, 0x0a, 0x05, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x04, 0x20, + 0x01, 0x28, 0x03, 0x52, 0x05, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x18, 0x0a, 0x06, 0x53, 0x75, + 0x62, 0x66, 0x69, 0x78, 0x18, 0xff, 0xff, 0x01, 0x20, 0x01, 0x28, 0x01, 0x52, 0x06, 0x53, 0x75, + 0x62, 0x66, 0x69, 0x78, 0x2a, 0x10, 0x0a, 0x03, 0x46, 0x4f, 0x4f, 0x12, 0x09, 0x0a, 0x05, 0x46, + 0x4f, 0x4f, 0x5f, 0x41, 0x10, 0x00, 0x32, 0xce, 0x03, 0x0a, 0x0c, 0x54, 0x65, 0x73, 0x74, 0x53, + 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x32, 0x12, 0x32, 0x0a, 0x0d, 0x45, 0x78, 0x61, 0x6d, 0x70, + 0x6c, 0x65, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x12, 0x0f, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x45, + 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x1a, 0x10, 0x2e, 0x70, 0x62, 0x33, 0x2e, + 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x12, 0x36, 0x0a, 0x14, 0x45, + 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x4d, 0x65, 0x74, + 0x68, 0x6f, 0x64, 0x12, 0x16, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, + 0x65, 0x52, 0x65, 0x71, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x1a, 0x06, 0x2e, 0x70, 0x62, + 0x33, 0x2e, 0x41, 0x12, 0x48, 0x0a, 0x15, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x50, 0x61, + 0x72, 0x74, 0x69, 0x61, 0x6c, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x32, 0x12, 0x16, 0x2e, 0x70, + 0x62, 0x33, 0x2e, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x50, 0x61, 0x72, + 0x74, 0x69, 0x61, 0x6c, 0x1a, 0x17, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x45, 0x78, 0x61, 0x6d, 0x70, + 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x12, 0x2f, 0x0a, + 0x12, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x53, 0x75, 0x70, 0x65, 0x72, 0x4d, 0x65, 0x74, + 0x68, 0x6f, 0x64, 0x12, 0x11, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, + 0x65, 0x53, 0x75, 0x70, 0x65, 0x72, 0x1a, 0x06, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x41, 0x12, 0x3f, + 0x0a, 0x0f, 0x49, 0x6e, 0x74, 0x32, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x4d, 0x65, 0x74, 0x68, 0x6f, + 0x64, 0x12, 0x15, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x49, + 0x6e, 0x74, 0x32, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x1a, 0x15, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x45, + 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x49, 0x6e, 0x74, 0x32, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x12, + 0x15, 0x0a, 0x03, 0x46, 0x6f, 0x6f, 0x12, 0x06, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x41, 0x1a, 0x06, + 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x41, 0x12, 0x21, 0x0a, 0x04, 0x50, 0x69, 0x6e, 0x67, 0x12, 0x06, + 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x41, 0x1a, 0x11, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x50, 0x69, 0x6e, + 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2f, 0x0a, 0x06, 0x4f, 0x6e, 0x65, + 0x77, 0x61, 0x79, 0x12, 0x12, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x4f, 0x6e, 0x65, 0x77, 0x61, 0x79, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x11, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x56, 0x6f, + 0x69, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2b, 0x0a, 0x04, 0x56, 0x6f, + 0x69, 0x64, 0x12, 0x10, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x56, 0x6f, 0x69, 0x64, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x1a, 0x11, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x56, 0x6f, 0x69, 0x64, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x42, 0x3f, 0x5a, 0x3d, 0x67, 0x69, 0x74, 0x68, 0x75, + 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x63, 0x6c, 0x6f, 0x75, 0x64, 0x77, 0x65, 0x67, 0x6f, 0x2f, + 0x64, 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, + 0x74, 0x61, 0x2f, 0x6b, 0x69, 0x74, 0x65, 0x78, 0x5f, 0x67, 0x65, 0x6e, 0x2f, 0x70, 0x62, 0x2f, + 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x32, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, } var ( - file_example2_proto_rawDescOnce sync.Once - file_example2_proto_rawDescData = file_example2_proto_rawDesc + file_idl_example2_proto_rawDescOnce sync.Once + file_idl_example2_proto_rawDescData = file_idl_example2_proto_rawDesc ) -func file_example2_proto_rawDescGZIP() []byte { - file_example2_proto_rawDescOnce.Do(func() { - file_example2_proto_rawDescData = protoimpl.X.CompressGZIP(file_example2_proto_rawDescData) +func file_idl_example2_proto_rawDescGZIP() []byte { + file_idl_example2_proto_rawDescOnce.Do(func() { + file_idl_example2_proto_rawDescData = protoimpl.X.CompressGZIP(file_idl_example2_proto_rawDescData) }) - return file_example2_proto_rawDescData + return file_idl_example2_proto_rawDescData } -var file_example2_proto_enumTypes = make([]protoimpl.EnumInfo, 1) -var file_example2_proto_msgTypes = make([]protoimpl.MessageInfo, 26) -var file_example2_proto_goTypes = []interface{}{ +var file_idl_example2_proto_enumTypes = make([]protoimpl.EnumInfo, 1) +var file_idl_example2_proto_msgTypes = make([]protoimpl.MessageInfo, 26) +var file_idl_example2_proto_goTypes = []interface{}{ (FOO)(0), // 0: pb3.FOO (*InnerBase2)(nil), // 1: pb3.InnerBase2 (*InnerBasePartial)(nil), // 2: pb3.InnerBasePartial @@ -1513,7 +1513,7 @@ var file_example2_proto_goTypes = []interface{}{ (*base.TrafficEnv)(nil), // 28: pb3.TrafficEnv (*base.BaseResp)(nil), // 29: pb3.BaseResp } -var file_example2_proto_depIdxs = []int32{ +var file_idl_example2_proto_depIdxs = []int32{ 17, // 0: pb3.InnerBase2.MapStringString:type_name -> pb3.InnerBase2.MapStringStringEntry 0, // 1: pb3.InnerBase2.Foo:type_name -> pb3.FOO 18, // 2: pb3.InnerBase2.MapInt32String:type_name -> pb3.InnerBase2.MapInt32StringEntry @@ -1570,13 +1570,13 @@ var file_example2_proto_depIdxs = []int32{ 0, // [0:31] is the sub-list for field type_name } -func init() { file_example2_proto_init() } -func file_example2_proto_init() { - if File_example2_proto != nil { +func init() { file_idl_example2_proto_init() } +func file_idl_example2_proto_init() { + if File_idl_example2_proto != nil { return } if !protoimpl.UnsafeEnabled { - file_example2_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + file_idl_example2_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*InnerBase2); i { case 0: return &v.state @@ -1588,7 +1588,7 @@ func file_example2_proto_init() { return nil } } - file_example2_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + file_idl_example2_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*InnerBasePartial); i { case 0: return &v.state @@ -1600,7 +1600,7 @@ func file_example2_proto_init() { return nil } } - file_example2_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + file_idl_example2_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*BasePartial); i { case 0: return &v.state @@ -1612,7 +1612,7 @@ func file_example2_proto_init() { return nil } } - file_example2_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + file_idl_example2_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ExampleReq); i { case 0: return &v.state @@ -1624,7 +1624,7 @@ func file_example2_proto_init() { return nil } } - file_example2_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + file_idl_example2_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ExampleSuper); i { case 0: return &v.state @@ -1636,7 +1636,7 @@ func file_example2_proto_init() { return nil } } - file_example2_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + file_idl_example2_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*SelfRef); i { case 0: return &v.state @@ -1648,7 +1648,7 @@ func file_example2_proto_init() { return nil } } - file_example2_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + file_idl_example2_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ExampleReqPartial); i { case 0: return &v.state @@ -1660,7 +1660,7 @@ func file_example2_proto_init() { return nil } } - file_example2_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + file_idl_example2_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ExampleResp); i { case 0: return &v.state @@ -1672,7 +1672,7 @@ func file_example2_proto_init() { return nil } } - file_example2_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + file_idl_example2_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ExampleRespPartial); i { case 0: return &v.state @@ -1684,7 +1684,7 @@ func file_example2_proto_init() { return nil } } - file_example2_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { + file_idl_example2_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*Exception); i { case 0: return &v.state @@ -1696,7 +1696,7 @@ func file_example2_proto_init() { return nil } } - file_example2_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { + file_idl_example2_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*A); i { case 0: return &v.state @@ -1708,7 +1708,7 @@ func file_example2_proto_init() { return nil } } - file_example2_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} { + file_idl_example2_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*PingResponse); i { case 0: return &v.state @@ -1720,7 +1720,7 @@ func file_example2_proto_init() { return nil } } - file_example2_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} { + file_idl_example2_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*OnewayRequest); i { case 0: return &v.state @@ -1732,7 +1732,7 @@ func file_example2_proto_init() { return nil } } - file_example2_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} { + file_idl_example2_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*VoidRequest); i { case 0: return &v.state @@ -1744,7 +1744,7 @@ func file_example2_proto_init() { return nil } } - file_example2_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} { + file_idl_example2_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*VoidResponse); i { case 0: return &v.state @@ -1756,7 +1756,7 @@ func file_example2_proto_init() { return nil } } - file_example2_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} { + file_idl_example2_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ExampleInt2Float); i { case 0: return &v.state @@ -1773,26 +1773,26 @@ func file_example2_proto_init() { out := protoimpl.TypeBuilder{ File: protoimpl.DescBuilder{ GoPackagePath: reflect.TypeOf(x{}).PkgPath(), - RawDescriptor: file_example2_proto_rawDesc, + RawDescriptor: file_idl_example2_proto_rawDesc, NumEnums: 1, NumMessages: 26, NumExtensions: 0, NumServices: 1, }, - GoTypes: file_example2_proto_goTypes, - DependencyIndexes: file_example2_proto_depIdxs, - EnumInfos: file_example2_proto_enumTypes, - MessageInfos: file_example2_proto_msgTypes, + GoTypes: file_idl_example2_proto_goTypes, + DependencyIndexes: file_idl_example2_proto_depIdxs, + EnumInfos: file_idl_example2_proto_enumTypes, + MessageInfos: file_idl_example2_proto_msgTypes, }.Build() - File_example2_proto = out.File - file_example2_proto_rawDesc = nil - file_example2_proto_goTypes = nil - file_example2_proto_depIdxs = nil + File_idl_example2_proto = out.File + file_idl_example2_proto_rawDesc = nil + file_idl_example2_proto_goTypes = nil + file_idl_example2_proto_depIdxs = nil } var _ context.Context -// Code generated by Kitex v0.7.2. DO NOT EDIT. +// Code generated by Kitex v0.9.1. DO NOT EDIT. type TestService2 interface { ExampleMethod(ctx context.Context, req *ExampleReq) (res *ExampleResp, err error) diff --git a/testdata/kitex_gen/pb/example2/testservice2/client.go b/testdata/kitex_gen/pb/example2/testservice2/client.go deleted file mode 100644 index 61c31f40..00000000 --- a/testdata/kitex_gen/pb/example2/testservice2/client.go +++ /dev/null @@ -1,97 +0,0 @@ -// Code generated by Kitex v0.7.2. DO NOT EDIT. - -package testservice2 - -import ( - "context" - example2 "github.com/cloudwego/dynamicgo/testdata/kitex_gen/pb/example2" - client "github.com/cloudwego/kitex/client" - callopt "github.com/cloudwego/kitex/client/callopt" -) - -// Client is designed to provide IDL-compatible methods with call-option parameter for kitex framework. -type Client interface { - ExampleMethod(ctx context.Context, Req *example2.ExampleReq, callOptions ...callopt.Option) (r *example2.ExampleResp, err error) - ExamplePartialMethod(ctx context.Context, Req *example2.ExampleReqPartial, callOptions ...callopt.Option) (r *example2.A, err error) - ExamplePartialMethod2(ctx context.Context, Req *example2.ExampleReqPartial, callOptions ...callopt.Option) (r *example2.ExampleRespPartial, err error) - ExampleSuperMethod(ctx context.Context, Req *example2.ExampleSuper, callOptions ...callopt.Option) (r *example2.A, err error) - Int2FloatMethod(ctx context.Context, Req *example2.ExampleInt2Float, callOptions ...callopt.Option) (r *example2.ExampleInt2Float, err error) - Foo(ctx context.Context, Req *example2.A, callOptions ...callopt.Option) (r *example2.A, err error) - Ping(ctx context.Context, Req *example2.A, callOptions ...callopt.Option) (r *example2.PingResponse, err error) - Oneway(ctx context.Context, Req *example2.OnewayRequest, callOptions ...callopt.Option) (r *example2.VoidResponse, err error) - Void(ctx context.Context, Req *example2.VoidRequest, callOptions ...callopt.Option) (r *example2.VoidResponse, err error) -} - -// NewClient creates a client for the service defined in IDL. -func NewClient(destService string, opts ...client.Option) (Client, error) { - var options []client.Option - options = append(options, client.WithDestService(destService)) - - options = append(options, opts...) - - kc, err := client.NewClient(serviceInfo(), options...) - if err != nil { - return nil, err - } - return &kTestService2Client{ - kClient: newServiceClient(kc), - }, nil -} - -// MustNewClient creates a client for the service defined in IDL. It panics if any error occurs. -func MustNewClient(destService string, opts ...client.Option) Client { - kc, err := NewClient(destService, opts...) - if err != nil { - panic(err) - } - return kc -} - -type kTestService2Client struct { - *kClient -} - -func (p *kTestService2Client) ExampleMethod(ctx context.Context, Req *example2.ExampleReq, callOptions ...callopt.Option) (r *example2.ExampleResp, err error) { - ctx = client.NewCtxWithCallOptions(ctx, callOptions) - return p.kClient.ExampleMethod(ctx, Req) -} - -func (p *kTestService2Client) ExamplePartialMethod(ctx context.Context, Req *example2.ExampleReqPartial, callOptions ...callopt.Option) (r *example2.A, err error) { - ctx = client.NewCtxWithCallOptions(ctx, callOptions) - return p.kClient.ExamplePartialMethod(ctx, Req) -} - -func (p *kTestService2Client) ExamplePartialMethod2(ctx context.Context, Req *example2.ExampleReqPartial, callOptions ...callopt.Option) (r *example2.ExampleRespPartial, err error) { - ctx = client.NewCtxWithCallOptions(ctx, callOptions) - return p.kClient.ExamplePartialMethod2(ctx, Req) -} - -func (p *kTestService2Client) ExampleSuperMethod(ctx context.Context, Req *example2.ExampleSuper, callOptions ...callopt.Option) (r *example2.A, err error) { - ctx = client.NewCtxWithCallOptions(ctx, callOptions) - return p.kClient.ExampleSuperMethod(ctx, Req) -} - -func (p *kTestService2Client) Int2FloatMethod(ctx context.Context, Req *example2.ExampleInt2Float, callOptions ...callopt.Option) (r *example2.ExampleInt2Float, err error) { - ctx = client.NewCtxWithCallOptions(ctx, callOptions) - return p.kClient.Int2FloatMethod(ctx, Req) -} - -func (p *kTestService2Client) Foo(ctx context.Context, Req *example2.A, callOptions ...callopt.Option) (r *example2.A, err error) { - ctx = client.NewCtxWithCallOptions(ctx, callOptions) - return p.kClient.Foo(ctx, Req) -} - -func (p *kTestService2Client) Ping(ctx context.Context, Req *example2.A, callOptions ...callopt.Option) (r *example2.PingResponse, err error) { - ctx = client.NewCtxWithCallOptions(ctx, callOptions) - return p.kClient.Ping(ctx, Req) -} - -func (p *kTestService2Client) Oneway(ctx context.Context, Req *example2.OnewayRequest, callOptions ...callopt.Option) (r *example2.VoidResponse, err error) { - ctx = client.NewCtxWithCallOptions(ctx, callOptions) - return p.kClient.Oneway(ctx, Req) -} - -func (p *kTestService2Client) Void(ctx context.Context, Req *example2.VoidRequest, callOptions ...callopt.Option) (r *example2.VoidResponse, err error) { - ctx = client.NewCtxWithCallOptions(ctx, callOptions) - return p.kClient.Void(ctx, Req) -} diff --git a/testdata/kitex_gen/pb/example2/testservice2/invoker.go b/testdata/kitex_gen/pb/example2/testservice2/invoker.go deleted file mode 100644 index ea6276b4..00000000 --- a/testdata/kitex_gen/pb/example2/testservice2/invoker.go +++ /dev/null @@ -1,24 +0,0 @@ -// Code generated by Kitex v0.7.2. DO NOT EDIT. - -package testservice2 - -import ( - example2 "github.com/cloudwego/dynamicgo/testdata/kitex_gen/pb/example2" - server "github.com/cloudwego/kitex/server" -) - -// NewInvoker creates a server.Invoker with the given handler and options. -func NewInvoker(handler example2.TestService2, opts ...server.Option) server.Invoker { - var options []server.Option - - options = append(options, opts...) - - s := server.NewInvoker(options...) - if err := s.RegisterService(serviceInfo(), handler); err != nil { - panic(err) - } - if err := s.Init(); err != nil { - panic(err) - } - return s -} diff --git a/testdata/kitex_gen/pb/example2/testservice2/server.go b/testdata/kitex_gen/pb/example2/testservice2/server.go deleted file mode 100644 index 3619f4ad..00000000 --- a/testdata/kitex_gen/pb/example2/testservice2/server.go +++ /dev/null @@ -1,20 +0,0 @@ -// Code generated by Kitex v0.7.2. DO NOT EDIT. -package testservice2 - -import ( - example2 "github.com/cloudwego/dynamicgo/testdata/kitex_gen/pb/example2" - server "github.com/cloudwego/kitex/server" -) - -// NewServer creates a server.Server with the given handler and options. -func NewServer(handler example2.TestService2, opts ...server.Option) server.Server { - var options []server.Option - - options = append(options, opts...) - - svr := server.NewServer(options...) - if err := svr.RegisterService(serviceInfo(), handler); err != nil { - panic(err) - } - return svr -} diff --git a/testdata/kitex_gen/pb/example2/testservice2/testservice2.go b/testdata/kitex_gen/pb/example2/testservice2/testservice2.go deleted file mode 100644 index ae7c76a2..00000000 --- a/testdata/kitex_gen/pb/example2/testservice2/testservice2.go +++ /dev/null @@ -1,1524 +0,0 @@ -// Code generated by Kitex v0.7.2. DO NOT EDIT. - -package testservice2 - -import ( - "context" - example2 "github.com/cloudwego/dynamicgo/testdata/kitex_gen/pb/example2" - client "github.com/cloudwego/kitex/client" - kitex "github.com/cloudwego/kitex/pkg/serviceinfo" - streaming "github.com/cloudwego/kitex/pkg/streaming" - proto "google.golang.org/protobuf/proto" -) - -func serviceInfo() *kitex.ServiceInfo { - return testService2ServiceInfo -} - -var testService2ServiceInfo = NewServiceInfo() - -func NewServiceInfo() *kitex.ServiceInfo { - serviceName := "TestService2" - handlerType := (*example2.TestService2)(nil) - methods := map[string]kitex.MethodInfo{ - "ExampleMethod": kitex.NewMethodInfo(exampleMethodHandler, newExampleMethodArgs, newExampleMethodResult, false), - "ExamplePartialMethod": kitex.NewMethodInfo(examplePartialMethodHandler, newExamplePartialMethodArgs, newExamplePartialMethodResult, false), - "ExamplePartialMethod2": kitex.NewMethodInfo(examplePartialMethod2Handler, newExamplePartialMethod2Args, newExamplePartialMethod2Result, false), - "ExampleSuperMethod": kitex.NewMethodInfo(exampleSuperMethodHandler, newExampleSuperMethodArgs, newExampleSuperMethodResult, false), - "Int2FloatMethod": kitex.NewMethodInfo(int2FloatMethodHandler, newInt2FloatMethodArgs, newInt2FloatMethodResult, false), - "Foo": kitex.NewMethodInfo(fooHandler, newFooArgs, newFooResult, false), - "Ping": kitex.NewMethodInfo(pingHandler, newPingArgs, newPingResult, false), - "Oneway": kitex.NewMethodInfo(onewayHandler, newOnewayArgs, newOnewayResult, false), - "Void": kitex.NewMethodInfo(voidHandler, newVoidArgs, newVoidResult, false), - } - extra := map[string]interface{}{ - "PackageName": "pb3", - "ServiceFilePath": ``, - } - svcInfo := &kitex.ServiceInfo{ - ServiceName: serviceName, - HandlerType: handlerType, - Methods: methods, - PayloadCodec: kitex.Protobuf, - KiteXGenVersion: "v0.7.2", - Extra: extra, - } - return svcInfo -} - -func exampleMethodHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { - switch s := arg.(type) { - case *streaming.Args: - st := s.Stream - req := new(example2.ExampleReq) - if err := st.RecvMsg(req); err != nil { - return err - } - resp, err := handler.(example2.TestService2).ExampleMethod(ctx, req) - if err != nil { - return err - } - if err := st.SendMsg(resp); err != nil { - return err - } - case *ExampleMethodArgs: - success, err := handler.(example2.TestService2).ExampleMethod(ctx, s.Req) - if err != nil { - return err - } - realResult := result.(*ExampleMethodResult) - realResult.Success = success - } - return nil -} -func newExampleMethodArgs() interface{} { - return &ExampleMethodArgs{} -} - -func newExampleMethodResult() interface{} { - return &ExampleMethodResult{} -} - -type ExampleMethodArgs struct { - Req *example2.ExampleReq -} - -func (p *ExampleMethodArgs) FastRead(buf []byte, _type int8, number int32) (n int, err error) { - if !p.IsSetReq() { - p.Req = new(example2.ExampleReq) - } - return p.Req.FastRead(buf, _type, number) -} - -func (p *ExampleMethodArgs) FastWrite(buf []byte) (n int) { - if !p.IsSetReq() { - return 0 - } - return p.Req.FastWrite(buf) -} - -func (p *ExampleMethodArgs) Size() (n int) { - if !p.IsSetReq() { - return 0 - } - return p.Req.Size() -} - -func (p *ExampleMethodArgs) Marshal(out []byte) ([]byte, error) { - if !p.IsSetReq() { - return out, nil - } - return proto.Marshal(p.Req) -} - -func (p *ExampleMethodArgs) Unmarshal(in []byte) error { - msg := new(example2.ExampleReq) - if err := proto.Unmarshal(in, msg); err != nil { - return err - } - p.Req = msg - return nil -} - -var ExampleMethodArgs_Req_DEFAULT *example2.ExampleReq - -func (p *ExampleMethodArgs) GetReq() *example2.ExampleReq { - if !p.IsSetReq() { - return ExampleMethodArgs_Req_DEFAULT - } - return p.Req -} - -func (p *ExampleMethodArgs) IsSetReq() bool { - return p.Req != nil -} - -func (p *ExampleMethodArgs) GetFirstArgument() interface{} { - return p.Req -} - -type ExampleMethodResult struct { - Success *example2.ExampleResp -} - -var ExampleMethodResult_Success_DEFAULT *example2.ExampleResp - -func (p *ExampleMethodResult) FastRead(buf []byte, _type int8, number int32) (n int, err error) { - if !p.IsSetSuccess() { - p.Success = new(example2.ExampleResp) - } - return p.Success.FastRead(buf, _type, number) -} - -func (p *ExampleMethodResult) FastWrite(buf []byte) (n int) { - if !p.IsSetSuccess() { - return 0 - } - return p.Success.FastWrite(buf) -} - -func (p *ExampleMethodResult) Size() (n int) { - if !p.IsSetSuccess() { - return 0 - } - return p.Success.Size() -} - -func (p *ExampleMethodResult) Marshal(out []byte) ([]byte, error) { - if !p.IsSetSuccess() { - return out, nil - } - return proto.Marshal(p.Success) -} - -func (p *ExampleMethodResult) Unmarshal(in []byte) error { - msg := new(example2.ExampleResp) - if err := proto.Unmarshal(in, msg); err != nil { - return err - } - p.Success = msg - return nil -} - -func (p *ExampleMethodResult) GetSuccess() *example2.ExampleResp { - if !p.IsSetSuccess() { - return ExampleMethodResult_Success_DEFAULT - } - return p.Success -} - -func (p *ExampleMethodResult) SetSuccess(x interface{}) { - p.Success = x.(*example2.ExampleResp) -} - -func (p *ExampleMethodResult) IsSetSuccess() bool { - return p.Success != nil -} - -func (p *ExampleMethodResult) GetResult() interface{} { - return p.Success -} - -func examplePartialMethodHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { - switch s := arg.(type) { - case *streaming.Args: - st := s.Stream - req := new(example2.ExampleReqPartial) - if err := st.RecvMsg(req); err != nil { - return err - } - resp, err := handler.(example2.TestService2).ExamplePartialMethod(ctx, req) - if err != nil { - return err - } - if err := st.SendMsg(resp); err != nil { - return err - } - case *ExamplePartialMethodArgs: - success, err := handler.(example2.TestService2).ExamplePartialMethod(ctx, s.Req) - if err != nil { - return err - } - realResult := result.(*ExamplePartialMethodResult) - realResult.Success = success - } - return nil -} -func newExamplePartialMethodArgs() interface{} { - return &ExamplePartialMethodArgs{} -} - -func newExamplePartialMethodResult() interface{} { - return &ExamplePartialMethodResult{} -} - -type ExamplePartialMethodArgs struct { - Req *example2.ExampleReqPartial -} - -func (p *ExamplePartialMethodArgs) FastRead(buf []byte, _type int8, number int32) (n int, err error) { - if !p.IsSetReq() { - p.Req = new(example2.ExampleReqPartial) - } - return p.Req.FastRead(buf, _type, number) -} - -func (p *ExamplePartialMethodArgs) FastWrite(buf []byte) (n int) { - if !p.IsSetReq() { - return 0 - } - return p.Req.FastWrite(buf) -} - -func (p *ExamplePartialMethodArgs) Size() (n int) { - if !p.IsSetReq() { - return 0 - } - return p.Req.Size() -} - -func (p *ExamplePartialMethodArgs) Marshal(out []byte) ([]byte, error) { - if !p.IsSetReq() { - return out, nil - } - return proto.Marshal(p.Req) -} - -func (p *ExamplePartialMethodArgs) Unmarshal(in []byte) error { - msg := new(example2.ExampleReqPartial) - if err := proto.Unmarshal(in, msg); err != nil { - return err - } - p.Req = msg - return nil -} - -var ExamplePartialMethodArgs_Req_DEFAULT *example2.ExampleReqPartial - -func (p *ExamplePartialMethodArgs) GetReq() *example2.ExampleReqPartial { - if !p.IsSetReq() { - return ExamplePartialMethodArgs_Req_DEFAULT - } - return p.Req -} - -func (p *ExamplePartialMethodArgs) IsSetReq() bool { - return p.Req != nil -} - -func (p *ExamplePartialMethodArgs) GetFirstArgument() interface{} { - return p.Req -} - -type ExamplePartialMethodResult struct { - Success *example2.A -} - -var ExamplePartialMethodResult_Success_DEFAULT *example2.A - -func (p *ExamplePartialMethodResult) FastRead(buf []byte, _type int8, number int32) (n int, err error) { - if !p.IsSetSuccess() { - p.Success = new(example2.A) - } - return p.Success.FastRead(buf, _type, number) -} - -func (p *ExamplePartialMethodResult) FastWrite(buf []byte) (n int) { - if !p.IsSetSuccess() { - return 0 - } - return p.Success.FastWrite(buf) -} - -func (p *ExamplePartialMethodResult) Size() (n int) { - if !p.IsSetSuccess() { - return 0 - } - return p.Success.Size() -} - -func (p *ExamplePartialMethodResult) Marshal(out []byte) ([]byte, error) { - if !p.IsSetSuccess() { - return out, nil - } - return proto.Marshal(p.Success) -} - -func (p *ExamplePartialMethodResult) Unmarshal(in []byte) error { - msg := new(example2.A) - if err := proto.Unmarshal(in, msg); err != nil { - return err - } - p.Success = msg - return nil -} - -func (p *ExamplePartialMethodResult) GetSuccess() *example2.A { - if !p.IsSetSuccess() { - return ExamplePartialMethodResult_Success_DEFAULT - } - return p.Success -} - -func (p *ExamplePartialMethodResult) SetSuccess(x interface{}) { - p.Success = x.(*example2.A) -} - -func (p *ExamplePartialMethodResult) IsSetSuccess() bool { - return p.Success != nil -} - -func (p *ExamplePartialMethodResult) GetResult() interface{} { - return p.Success -} - -func examplePartialMethod2Handler(ctx context.Context, handler interface{}, arg, result interface{}) error { - switch s := arg.(type) { - case *streaming.Args: - st := s.Stream - req := new(example2.ExampleReqPartial) - if err := st.RecvMsg(req); err != nil { - return err - } - resp, err := handler.(example2.TestService2).ExamplePartialMethod2(ctx, req) - if err != nil { - return err - } - if err := st.SendMsg(resp); err != nil { - return err - } - case *ExamplePartialMethod2Args: - success, err := handler.(example2.TestService2).ExamplePartialMethod2(ctx, s.Req) - if err != nil { - return err - } - realResult := result.(*ExamplePartialMethod2Result) - realResult.Success = success - } - return nil -} -func newExamplePartialMethod2Args() interface{} { - return &ExamplePartialMethod2Args{} -} - -func newExamplePartialMethod2Result() interface{} { - return &ExamplePartialMethod2Result{} -} - -type ExamplePartialMethod2Args struct { - Req *example2.ExampleReqPartial -} - -func (p *ExamplePartialMethod2Args) FastRead(buf []byte, _type int8, number int32) (n int, err error) { - if !p.IsSetReq() { - p.Req = new(example2.ExampleReqPartial) - } - return p.Req.FastRead(buf, _type, number) -} - -func (p *ExamplePartialMethod2Args) FastWrite(buf []byte) (n int) { - if !p.IsSetReq() { - return 0 - } - return p.Req.FastWrite(buf) -} - -func (p *ExamplePartialMethod2Args) Size() (n int) { - if !p.IsSetReq() { - return 0 - } - return p.Req.Size() -} - -func (p *ExamplePartialMethod2Args) Marshal(out []byte) ([]byte, error) { - if !p.IsSetReq() { - return out, nil - } - return proto.Marshal(p.Req) -} - -func (p *ExamplePartialMethod2Args) Unmarshal(in []byte) error { - msg := new(example2.ExampleReqPartial) - if err := proto.Unmarshal(in, msg); err != nil { - return err - } - p.Req = msg - return nil -} - -var ExamplePartialMethod2Args_Req_DEFAULT *example2.ExampleReqPartial - -func (p *ExamplePartialMethod2Args) GetReq() *example2.ExampleReqPartial { - if !p.IsSetReq() { - return ExamplePartialMethod2Args_Req_DEFAULT - } - return p.Req -} - -func (p *ExamplePartialMethod2Args) IsSetReq() bool { - return p.Req != nil -} - -func (p *ExamplePartialMethod2Args) GetFirstArgument() interface{} { - return p.Req -} - -type ExamplePartialMethod2Result struct { - Success *example2.ExampleRespPartial -} - -var ExamplePartialMethod2Result_Success_DEFAULT *example2.ExampleRespPartial - -func (p *ExamplePartialMethod2Result) FastRead(buf []byte, _type int8, number int32) (n int, err error) { - if !p.IsSetSuccess() { - p.Success = new(example2.ExampleRespPartial) - } - return p.Success.FastRead(buf, _type, number) -} - -func (p *ExamplePartialMethod2Result) FastWrite(buf []byte) (n int) { - if !p.IsSetSuccess() { - return 0 - } - return p.Success.FastWrite(buf) -} - -func (p *ExamplePartialMethod2Result) Size() (n int) { - if !p.IsSetSuccess() { - return 0 - } - return p.Success.Size() -} - -func (p *ExamplePartialMethod2Result) Marshal(out []byte) ([]byte, error) { - if !p.IsSetSuccess() { - return out, nil - } - return proto.Marshal(p.Success) -} - -func (p *ExamplePartialMethod2Result) Unmarshal(in []byte) error { - msg := new(example2.ExampleRespPartial) - if err := proto.Unmarshal(in, msg); err != nil { - return err - } - p.Success = msg - return nil -} - -func (p *ExamplePartialMethod2Result) GetSuccess() *example2.ExampleRespPartial { - if !p.IsSetSuccess() { - return ExamplePartialMethod2Result_Success_DEFAULT - } - return p.Success -} - -func (p *ExamplePartialMethod2Result) SetSuccess(x interface{}) { - p.Success = x.(*example2.ExampleRespPartial) -} - -func (p *ExamplePartialMethod2Result) IsSetSuccess() bool { - return p.Success != nil -} - -func (p *ExamplePartialMethod2Result) GetResult() interface{} { - return p.Success -} - -func exampleSuperMethodHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { - switch s := arg.(type) { - case *streaming.Args: - st := s.Stream - req := new(example2.ExampleSuper) - if err := st.RecvMsg(req); err != nil { - return err - } - resp, err := handler.(example2.TestService2).ExampleSuperMethod(ctx, req) - if err != nil { - return err - } - if err := st.SendMsg(resp); err != nil { - return err - } - case *ExampleSuperMethodArgs: - success, err := handler.(example2.TestService2).ExampleSuperMethod(ctx, s.Req) - if err != nil { - return err - } - realResult := result.(*ExampleSuperMethodResult) - realResult.Success = success - } - return nil -} -func newExampleSuperMethodArgs() interface{} { - return &ExampleSuperMethodArgs{} -} - -func newExampleSuperMethodResult() interface{} { - return &ExampleSuperMethodResult{} -} - -type ExampleSuperMethodArgs struct { - Req *example2.ExampleSuper -} - -func (p *ExampleSuperMethodArgs) FastRead(buf []byte, _type int8, number int32) (n int, err error) { - if !p.IsSetReq() { - p.Req = new(example2.ExampleSuper) - } - return p.Req.FastRead(buf, _type, number) -} - -func (p *ExampleSuperMethodArgs) FastWrite(buf []byte) (n int) { - if !p.IsSetReq() { - return 0 - } - return p.Req.FastWrite(buf) -} - -func (p *ExampleSuperMethodArgs) Size() (n int) { - if !p.IsSetReq() { - return 0 - } - return p.Req.Size() -} - -func (p *ExampleSuperMethodArgs) Marshal(out []byte) ([]byte, error) { - if !p.IsSetReq() { - return out, nil - } - return proto.Marshal(p.Req) -} - -func (p *ExampleSuperMethodArgs) Unmarshal(in []byte) error { - msg := new(example2.ExampleSuper) - if err := proto.Unmarshal(in, msg); err != nil { - return err - } - p.Req = msg - return nil -} - -var ExampleSuperMethodArgs_Req_DEFAULT *example2.ExampleSuper - -func (p *ExampleSuperMethodArgs) GetReq() *example2.ExampleSuper { - if !p.IsSetReq() { - return ExampleSuperMethodArgs_Req_DEFAULT - } - return p.Req -} - -func (p *ExampleSuperMethodArgs) IsSetReq() bool { - return p.Req != nil -} - -func (p *ExampleSuperMethodArgs) GetFirstArgument() interface{} { - return p.Req -} - -type ExampleSuperMethodResult struct { - Success *example2.A -} - -var ExampleSuperMethodResult_Success_DEFAULT *example2.A - -func (p *ExampleSuperMethodResult) FastRead(buf []byte, _type int8, number int32) (n int, err error) { - if !p.IsSetSuccess() { - p.Success = new(example2.A) - } - return p.Success.FastRead(buf, _type, number) -} - -func (p *ExampleSuperMethodResult) FastWrite(buf []byte) (n int) { - if !p.IsSetSuccess() { - return 0 - } - return p.Success.FastWrite(buf) -} - -func (p *ExampleSuperMethodResult) Size() (n int) { - if !p.IsSetSuccess() { - return 0 - } - return p.Success.Size() -} - -func (p *ExampleSuperMethodResult) Marshal(out []byte) ([]byte, error) { - if !p.IsSetSuccess() { - return out, nil - } - return proto.Marshal(p.Success) -} - -func (p *ExampleSuperMethodResult) Unmarshal(in []byte) error { - msg := new(example2.A) - if err := proto.Unmarshal(in, msg); err != nil { - return err - } - p.Success = msg - return nil -} - -func (p *ExampleSuperMethodResult) GetSuccess() *example2.A { - if !p.IsSetSuccess() { - return ExampleSuperMethodResult_Success_DEFAULT - } - return p.Success -} - -func (p *ExampleSuperMethodResult) SetSuccess(x interface{}) { - p.Success = x.(*example2.A) -} - -func (p *ExampleSuperMethodResult) IsSetSuccess() bool { - return p.Success != nil -} - -func (p *ExampleSuperMethodResult) GetResult() interface{} { - return p.Success -} - -func int2FloatMethodHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { - switch s := arg.(type) { - case *streaming.Args: - st := s.Stream - req := new(example2.ExampleInt2Float) - if err := st.RecvMsg(req); err != nil { - return err - } - resp, err := handler.(example2.TestService2).Int2FloatMethod(ctx, req) - if err != nil { - return err - } - if err := st.SendMsg(resp); err != nil { - return err - } - case *Int2FloatMethodArgs: - success, err := handler.(example2.TestService2).Int2FloatMethod(ctx, s.Req) - if err != nil { - return err - } - realResult := result.(*Int2FloatMethodResult) - realResult.Success = success - } - return nil -} -func newInt2FloatMethodArgs() interface{} { - return &Int2FloatMethodArgs{} -} - -func newInt2FloatMethodResult() interface{} { - return &Int2FloatMethodResult{} -} - -type Int2FloatMethodArgs struct { - Req *example2.ExampleInt2Float -} - -func (p *Int2FloatMethodArgs) FastRead(buf []byte, _type int8, number int32) (n int, err error) { - if !p.IsSetReq() { - p.Req = new(example2.ExampleInt2Float) - } - return p.Req.FastRead(buf, _type, number) -} - -func (p *Int2FloatMethodArgs) FastWrite(buf []byte) (n int) { - if !p.IsSetReq() { - return 0 - } - return p.Req.FastWrite(buf) -} - -func (p *Int2FloatMethodArgs) Size() (n int) { - if !p.IsSetReq() { - return 0 - } - return p.Req.Size() -} - -func (p *Int2FloatMethodArgs) Marshal(out []byte) ([]byte, error) { - if !p.IsSetReq() { - return out, nil - } - return proto.Marshal(p.Req) -} - -func (p *Int2FloatMethodArgs) Unmarshal(in []byte) error { - msg := new(example2.ExampleInt2Float) - if err := proto.Unmarshal(in, msg); err != nil { - return err - } - p.Req = msg - return nil -} - -var Int2FloatMethodArgs_Req_DEFAULT *example2.ExampleInt2Float - -func (p *Int2FloatMethodArgs) GetReq() *example2.ExampleInt2Float { - if !p.IsSetReq() { - return Int2FloatMethodArgs_Req_DEFAULT - } - return p.Req -} - -func (p *Int2FloatMethodArgs) IsSetReq() bool { - return p.Req != nil -} - -func (p *Int2FloatMethodArgs) GetFirstArgument() interface{} { - return p.Req -} - -type Int2FloatMethodResult struct { - Success *example2.ExampleInt2Float -} - -var Int2FloatMethodResult_Success_DEFAULT *example2.ExampleInt2Float - -func (p *Int2FloatMethodResult) FastRead(buf []byte, _type int8, number int32) (n int, err error) { - if !p.IsSetSuccess() { - p.Success = new(example2.ExampleInt2Float) - } - return p.Success.FastRead(buf, _type, number) -} - -func (p *Int2FloatMethodResult) FastWrite(buf []byte) (n int) { - if !p.IsSetSuccess() { - return 0 - } - return p.Success.FastWrite(buf) -} - -func (p *Int2FloatMethodResult) Size() (n int) { - if !p.IsSetSuccess() { - return 0 - } - return p.Success.Size() -} - -func (p *Int2FloatMethodResult) Marshal(out []byte) ([]byte, error) { - if !p.IsSetSuccess() { - return out, nil - } - return proto.Marshal(p.Success) -} - -func (p *Int2FloatMethodResult) Unmarshal(in []byte) error { - msg := new(example2.ExampleInt2Float) - if err := proto.Unmarshal(in, msg); err != nil { - return err - } - p.Success = msg - return nil -} - -func (p *Int2FloatMethodResult) GetSuccess() *example2.ExampleInt2Float { - if !p.IsSetSuccess() { - return Int2FloatMethodResult_Success_DEFAULT - } - return p.Success -} - -func (p *Int2FloatMethodResult) SetSuccess(x interface{}) { - p.Success = x.(*example2.ExampleInt2Float) -} - -func (p *Int2FloatMethodResult) IsSetSuccess() bool { - return p.Success != nil -} - -func (p *Int2FloatMethodResult) GetResult() interface{} { - return p.Success -} - -func fooHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { - switch s := arg.(type) { - case *streaming.Args: - st := s.Stream - req := new(example2.A) - if err := st.RecvMsg(req); err != nil { - return err - } - resp, err := handler.(example2.TestService2).Foo(ctx, req) - if err != nil { - return err - } - if err := st.SendMsg(resp); err != nil { - return err - } - case *FooArgs: - success, err := handler.(example2.TestService2).Foo(ctx, s.Req) - if err != nil { - return err - } - realResult := result.(*FooResult) - realResult.Success = success - } - return nil -} -func newFooArgs() interface{} { - return &FooArgs{} -} - -func newFooResult() interface{} { - return &FooResult{} -} - -type FooArgs struct { - Req *example2.A -} - -func (p *FooArgs) FastRead(buf []byte, _type int8, number int32) (n int, err error) { - if !p.IsSetReq() { - p.Req = new(example2.A) - } - return p.Req.FastRead(buf, _type, number) -} - -func (p *FooArgs) FastWrite(buf []byte) (n int) { - if !p.IsSetReq() { - return 0 - } - return p.Req.FastWrite(buf) -} - -func (p *FooArgs) Size() (n int) { - if !p.IsSetReq() { - return 0 - } - return p.Req.Size() -} - -func (p *FooArgs) Marshal(out []byte) ([]byte, error) { - if !p.IsSetReq() { - return out, nil - } - return proto.Marshal(p.Req) -} - -func (p *FooArgs) Unmarshal(in []byte) error { - msg := new(example2.A) - if err := proto.Unmarshal(in, msg); err != nil { - return err - } - p.Req = msg - return nil -} - -var FooArgs_Req_DEFAULT *example2.A - -func (p *FooArgs) GetReq() *example2.A { - if !p.IsSetReq() { - return FooArgs_Req_DEFAULT - } - return p.Req -} - -func (p *FooArgs) IsSetReq() bool { - return p.Req != nil -} - -func (p *FooArgs) GetFirstArgument() interface{} { - return p.Req -} - -type FooResult struct { - Success *example2.A -} - -var FooResult_Success_DEFAULT *example2.A - -func (p *FooResult) FastRead(buf []byte, _type int8, number int32) (n int, err error) { - if !p.IsSetSuccess() { - p.Success = new(example2.A) - } - return p.Success.FastRead(buf, _type, number) -} - -func (p *FooResult) FastWrite(buf []byte) (n int) { - if !p.IsSetSuccess() { - return 0 - } - return p.Success.FastWrite(buf) -} - -func (p *FooResult) Size() (n int) { - if !p.IsSetSuccess() { - return 0 - } - return p.Success.Size() -} - -func (p *FooResult) Marshal(out []byte) ([]byte, error) { - if !p.IsSetSuccess() { - return out, nil - } - return proto.Marshal(p.Success) -} - -func (p *FooResult) Unmarshal(in []byte) error { - msg := new(example2.A) - if err := proto.Unmarshal(in, msg); err != nil { - return err - } - p.Success = msg - return nil -} - -func (p *FooResult) GetSuccess() *example2.A { - if !p.IsSetSuccess() { - return FooResult_Success_DEFAULT - } - return p.Success -} - -func (p *FooResult) SetSuccess(x interface{}) { - p.Success = x.(*example2.A) -} - -func (p *FooResult) IsSetSuccess() bool { - return p.Success != nil -} - -func (p *FooResult) GetResult() interface{} { - return p.Success -} - -func pingHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { - switch s := arg.(type) { - case *streaming.Args: - st := s.Stream - req := new(example2.A) - if err := st.RecvMsg(req); err != nil { - return err - } - resp, err := handler.(example2.TestService2).Ping(ctx, req) - if err != nil { - return err - } - if err := st.SendMsg(resp); err != nil { - return err - } - case *PingArgs: - success, err := handler.(example2.TestService2).Ping(ctx, s.Req) - if err != nil { - return err - } - realResult := result.(*PingResult) - realResult.Success = success - } - return nil -} -func newPingArgs() interface{} { - return &PingArgs{} -} - -func newPingResult() interface{} { - return &PingResult{} -} - -type PingArgs struct { - Req *example2.A -} - -func (p *PingArgs) FastRead(buf []byte, _type int8, number int32) (n int, err error) { - if !p.IsSetReq() { - p.Req = new(example2.A) - } - return p.Req.FastRead(buf, _type, number) -} - -func (p *PingArgs) FastWrite(buf []byte) (n int) { - if !p.IsSetReq() { - return 0 - } - return p.Req.FastWrite(buf) -} - -func (p *PingArgs) Size() (n int) { - if !p.IsSetReq() { - return 0 - } - return p.Req.Size() -} - -func (p *PingArgs) Marshal(out []byte) ([]byte, error) { - if !p.IsSetReq() { - return out, nil - } - return proto.Marshal(p.Req) -} - -func (p *PingArgs) Unmarshal(in []byte) error { - msg := new(example2.A) - if err := proto.Unmarshal(in, msg); err != nil { - return err - } - p.Req = msg - return nil -} - -var PingArgs_Req_DEFAULT *example2.A - -func (p *PingArgs) GetReq() *example2.A { - if !p.IsSetReq() { - return PingArgs_Req_DEFAULT - } - return p.Req -} - -func (p *PingArgs) IsSetReq() bool { - return p.Req != nil -} - -func (p *PingArgs) GetFirstArgument() interface{} { - return p.Req -} - -type PingResult struct { - Success *example2.PingResponse -} - -var PingResult_Success_DEFAULT *example2.PingResponse - -func (p *PingResult) FastRead(buf []byte, _type int8, number int32) (n int, err error) { - if !p.IsSetSuccess() { - p.Success = new(example2.PingResponse) - } - return p.Success.FastRead(buf, _type, number) -} - -func (p *PingResult) FastWrite(buf []byte) (n int) { - if !p.IsSetSuccess() { - return 0 - } - return p.Success.FastWrite(buf) -} - -func (p *PingResult) Size() (n int) { - if !p.IsSetSuccess() { - return 0 - } - return p.Success.Size() -} - -func (p *PingResult) Marshal(out []byte) ([]byte, error) { - if !p.IsSetSuccess() { - return out, nil - } - return proto.Marshal(p.Success) -} - -func (p *PingResult) Unmarshal(in []byte) error { - msg := new(example2.PingResponse) - if err := proto.Unmarshal(in, msg); err != nil { - return err - } - p.Success = msg - return nil -} - -func (p *PingResult) GetSuccess() *example2.PingResponse { - if !p.IsSetSuccess() { - return PingResult_Success_DEFAULT - } - return p.Success -} - -func (p *PingResult) SetSuccess(x interface{}) { - p.Success = x.(*example2.PingResponse) -} - -func (p *PingResult) IsSetSuccess() bool { - return p.Success != nil -} - -func (p *PingResult) GetResult() interface{} { - return p.Success -} - -func onewayHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { - switch s := arg.(type) { - case *streaming.Args: - st := s.Stream - req := new(example2.OnewayRequest) - if err := st.RecvMsg(req); err != nil { - return err - } - resp, err := handler.(example2.TestService2).Oneway(ctx, req) - if err != nil { - return err - } - if err := st.SendMsg(resp); err != nil { - return err - } - case *OnewayArgs: - success, err := handler.(example2.TestService2).Oneway(ctx, s.Req) - if err != nil { - return err - } - realResult := result.(*OnewayResult) - realResult.Success = success - } - return nil -} -func newOnewayArgs() interface{} { - return &OnewayArgs{} -} - -func newOnewayResult() interface{} { - return &OnewayResult{} -} - -type OnewayArgs struct { - Req *example2.OnewayRequest -} - -func (p *OnewayArgs) FastRead(buf []byte, _type int8, number int32) (n int, err error) { - if !p.IsSetReq() { - p.Req = new(example2.OnewayRequest) - } - return p.Req.FastRead(buf, _type, number) -} - -func (p *OnewayArgs) FastWrite(buf []byte) (n int) { - if !p.IsSetReq() { - return 0 - } - return p.Req.FastWrite(buf) -} - -func (p *OnewayArgs) Size() (n int) { - if !p.IsSetReq() { - return 0 - } - return p.Req.Size() -} - -func (p *OnewayArgs) Marshal(out []byte) ([]byte, error) { - if !p.IsSetReq() { - return out, nil - } - return proto.Marshal(p.Req) -} - -func (p *OnewayArgs) Unmarshal(in []byte) error { - msg := new(example2.OnewayRequest) - if err := proto.Unmarshal(in, msg); err != nil { - return err - } - p.Req = msg - return nil -} - -var OnewayArgs_Req_DEFAULT *example2.OnewayRequest - -func (p *OnewayArgs) GetReq() *example2.OnewayRequest { - if !p.IsSetReq() { - return OnewayArgs_Req_DEFAULT - } - return p.Req -} - -func (p *OnewayArgs) IsSetReq() bool { - return p.Req != nil -} - -func (p *OnewayArgs) GetFirstArgument() interface{} { - return p.Req -} - -type OnewayResult struct { - Success *example2.VoidResponse -} - -var OnewayResult_Success_DEFAULT *example2.VoidResponse - -func (p *OnewayResult) FastRead(buf []byte, _type int8, number int32) (n int, err error) { - if !p.IsSetSuccess() { - p.Success = new(example2.VoidResponse) - } - return p.Success.FastRead(buf, _type, number) -} - -func (p *OnewayResult) FastWrite(buf []byte) (n int) { - if !p.IsSetSuccess() { - return 0 - } - return p.Success.FastWrite(buf) -} - -func (p *OnewayResult) Size() (n int) { - if !p.IsSetSuccess() { - return 0 - } - return p.Success.Size() -} - -func (p *OnewayResult) Marshal(out []byte) ([]byte, error) { - if !p.IsSetSuccess() { - return out, nil - } - return proto.Marshal(p.Success) -} - -func (p *OnewayResult) Unmarshal(in []byte) error { - msg := new(example2.VoidResponse) - if err := proto.Unmarshal(in, msg); err != nil { - return err - } - p.Success = msg - return nil -} - -func (p *OnewayResult) GetSuccess() *example2.VoidResponse { - if !p.IsSetSuccess() { - return OnewayResult_Success_DEFAULT - } - return p.Success -} - -func (p *OnewayResult) SetSuccess(x interface{}) { - p.Success = x.(*example2.VoidResponse) -} - -func (p *OnewayResult) IsSetSuccess() bool { - return p.Success != nil -} - -func (p *OnewayResult) GetResult() interface{} { - return p.Success -} - -func voidHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { - switch s := arg.(type) { - case *streaming.Args: - st := s.Stream - req := new(example2.VoidRequest) - if err := st.RecvMsg(req); err != nil { - return err - } - resp, err := handler.(example2.TestService2).Void(ctx, req) - if err != nil { - return err - } - if err := st.SendMsg(resp); err != nil { - return err - } - case *VoidArgs: - success, err := handler.(example2.TestService2).Void(ctx, s.Req) - if err != nil { - return err - } - realResult := result.(*VoidResult) - realResult.Success = success - } - return nil -} -func newVoidArgs() interface{} { - return &VoidArgs{} -} - -func newVoidResult() interface{} { - return &VoidResult{} -} - -type VoidArgs struct { - Req *example2.VoidRequest -} - -func (p *VoidArgs) FastRead(buf []byte, _type int8, number int32) (n int, err error) { - if !p.IsSetReq() { - p.Req = new(example2.VoidRequest) - } - return p.Req.FastRead(buf, _type, number) -} - -func (p *VoidArgs) FastWrite(buf []byte) (n int) { - if !p.IsSetReq() { - return 0 - } - return p.Req.FastWrite(buf) -} - -func (p *VoidArgs) Size() (n int) { - if !p.IsSetReq() { - return 0 - } - return p.Req.Size() -} - -func (p *VoidArgs) Marshal(out []byte) ([]byte, error) { - if !p.IsSetReq() { - return out, nil - } - return proto.Marshal(p.Req) -} - -func (p *VoidArgs) Unmarshal(in []byte) error { - msg := new(example2.VoidRequest) - if err := proto.Unmarshal(in, msg); err != nil { - return err - } - p.Req = msg - return nil -} - -var VoidArgs_Req_DEFAULT *example2.VoidRequest - -func (p *VoidArgs) GetReq() *example2.VoidRequest { - if !p.IsSetReq() { - return VoidArgs_Req_DEFAULT - } - return p.Req -} - -func (p *VoidArgs) IsSetReq() bool { - return p.Req != nil -} - -func (p *VoidArgs) GetFirstArgument() interface{} { - return p.Req -} - -type VoidResult struct { - Success *example2.VoidResponse -} - -var VoidResult_Success_DEFAULT *example2.VoidResponse - -func (p *VoidResult) FastRead(buf []byte, _type int8, number int32) (n int, err error) { - if !p.IsSetSuccess() { - p.Success = new(example2.VoidResponse) - } - return p.Success.FastRead(buf, _type, number) -} - -func (p *VoidResult) FastWrite(buf []byte) (n int) { - if !p.IsSetSuccess() { - return 0 - } - return p.Success.FastWrite(buf) -} - -func (p *VoidResult) Size() (n int) { - if !p.IsSetSuccess() { - return 0 - } - return p.Success.Size() -} - -func (p *VoidResult) Marshal(out []byte) ([]byte, error) { - if !p.IsSetSuccess() { - return out, nil - } - return proto.Marshal(p.Success) -} - -func (p *VoidResult) Unmarshal(in []byte) error { - msg := new(example2.VoidResponse) - if err := proto.Unmarshal(in, msg); err != nil { - return err - } - p.Success = msg - return nil -} - -func (p *VoidResult) GetSuccess() *example2.VoidResponse { - if !p.IsSetSuccess() { - return VoidResult_Success_DEFAULT - } - return p.Success -} - -func (p *VoidResult) SetSuccess(x interface{}) { - p.Success = x.(*example2.VoidResponse) -} - -func (p *VoidResult) IsSetSuccess() bool { - return p.Success != nil -} - -func (p *VoidResult) GetResult() interface{} { - return p.Success -} - -type kClient struct { - c client.Client -} - -func newServiceClient(c client.Client) *kClient { - return &kClient{ - c: c, - } -} - -func (p *kClient) ExampleMethod(ctx context.Context, Req *example2.ExampleReq) (r *example2.ExampleResp, err error) { - var _args ExampleMethodArgs - _args.Req = Req - var _result ExampleMethodResult - if err = p.c.Call(ctx, "ExampleMethod", &_args, &_result); err != nil { - return - } - return _result.GetSuccess(), nil -} - -func (p *kClient) ExamplePartialMethod(ctx context.Context, Req *example2.ExampleReqPartial) (r *example2.A, err error) { - var _args ExamplePartialMethodArgs - _args.Req = Req - var _result ExamplePartialMethodResult - if err = p.c.Call(ctx, "ExamplePartialMethod", &_args, &_result); err != nil { - return - } - return _result.GetSuccess(), nil -} - -func (p *kClient) ExamplePartialMethod2(ctx context.Context, Req *example2.ExampleReqPartial) (r *example2.ExampleRespPartial, err error) { - var _args ExamplePartialMethod2Args - _args.Req = Req - var _result ExamplePartialMethod2Result - if err = p.c.Call(ctx, "ExamplePartialMethod2", &_args, &_result); err != nil { - return - } - return _result.GetSuccess(), nil -} - -func (p *kClient) ExampleSuperMethod(ctx context.Context, Req *example2.ExampleSuper) (r *example2.A, err error) { - var _args ExampleSuperMethodArgs - _args.Req = Req - var _result ExampleSuperMethodResult - if err = p.c.Call(ctx, "ExampleSuperMethod", &_args, &_result); err != nil { - return - } - return _result.GetSuccess(), nil -} - -func (p *kClient) Int2FloatMethod(ctx context.Context, Req *example2.ExampleInt2Float) (r *example2.ExampleInt2Float, err error) { - var _args Int2FloatMethodArgs - _args.Req = Req - var _result Int2FloatMethodResult - if err = p.c.Call(ctx, "Int2FloatMethod", &_args, &_result); err != nil { - return - } - return _result.GetSuccess(), nil -} - -func (p *kClient) Foo(ctx context.Context, Req *example2.A) (r *example2.A, err error) { - var _args FooArgs - _args.Req = Req - var _result FooResult - if err = p.c.Call(ctx, "Foo", &_args, &_result); err != nil { - return - } - return _result.GetSuccess(), nil -} - -func (p *kClient) Ping(ctx context.Context, Req *example2.A) (r *example2.PingResponse, err error) { - var _args PingArgs - _args.Req = Req - var _result PingResult - if err = p.c.Call(ctx, "Ping", &_args, &_result); err != nil { - return - } - return _result.GetSuccess(), nil -} - -func (p *kClient) Oneway(ctx context.Context, Req *example2.OnewayRequest) (r *example2.VoidResponse, err error) { - var _args OnewayArgs - _args.Req = Req - var _result OnewayResult - if err = p.c.Call(ctx, "Oneway", &_args, &_result); err != nil { - return - } - return _result.GetSuccess(), nil -} - -func (p *kClient) Void(ctx context.Context, Req *example2.VoidRequest) (r *example2.VoidResponse, err error) { - var _args VoidArgs - _args.Req = Req - var _result VoidResult - if err = p.c.Call(ctx, "Void", &_args, &_result); err != nil { - return - } - return _result.GetSuccess(), nil -} diff --git a/testdata/kitex_gen/pb/example3/example3.pb.fast.go b/testdata/kitex_gen/pb/example3/example3.pb.fast.go new file mode 100644 index 00000000..6b4ec847 --- /dev/null +++ b/testdata/kitex_gen/pb/example3/example3.pb.fast.go @@ -0,0 +1,3359 @@ +// Code generated by Fastpb v0.0.2. DO NOT EDIT. + +package example3 + +import ( + fmt "fmt" + base "github.com/cloudwego/dynamicgo/testdata/kitex_gen/pb/base" + fastpb "github.com/cloudwego/fastpb" +) + +var ( + _ = fmt.Errorf + _ = fastpb.Skip +) + +func (x *InnerBase2) FastRead(buf []byte, _type int8, number int32) (offset int, err error) { + switch number { + case 1: + offset, err = x.fastReadField1(buf, _type) + if err != nil { + goto ReadFieldError + } + case 2: + offset, err = x.fastReadField2(buf, _type) + if err != nil { + goto ReadFieldError + } + case 3: + offset, err = x.fastReadField3(buf, _type) + if err != nil { + goto ReadFieldError + } + case 4: + offset, err = x.fastReadField4(buf, _type) + if err != nil { + goto ReadFieldError + } + case 5: + offset, err = x.fastReadField5(buf, _type) + if err != nil { + goto ReadFieldError + } + case 6: + offset, err = x.fastReadField6(buf, _type) + if err != nil { + goto ReadFieldError + } + case 7: + offset, err = x.fastReadField7(buf, _type) + if err != nil { + goto ReadFieldError + } + case 8: + offset, err = x.fastReadField8(buf, _type) + if err != nil { + goto ReadFieldError + } + case 9: + offset, err = x.fastReadField9(buf, _type) + if err != nil { + goto ReadFieldError + } + case 10: + offset, err = x.fastReadField10(buf, _type) + if err != nil { + goto ReadFieldError + } + case 11: + offset, err = x.fastReadField11(buf, _type) + if err != nil { + goto ReadFieldError + } + case 12: + offset, err = x.fastReadField12(buf, _type) + if err != nil { + goto ReadFieldError + } + case 13: + offset, err = x.fastReadField13(buf, _type) + if err != nil { + goto ReadFieldError + } + case 14: + offset, err = x.fastReadField14(buf, _type) + if err != nil { + goto ReadFieldError + } + case 15: + offset, err = x.fastReadField15(buf, _type) + if err != nil { + goto ReadFieldError + } + case 16: + offset, err = x.fastReadField16(buf, _type) + if err != nil { + goto ReadFieldError + } + case 17: + offset, err = x.fastReadField17(buf, _type) + if err != nil { + goto ReadFieldError + } + case 18: + offset, err = x.fastReadField18(buf, _type) + if err != nil { + goto ReadFieldError + } + case 19: + offset, err = x.fastReadField19(buf, _type) + if err != nil { + goto ReadFieldError + } + case 20: + offset, err = x.fastReadField20(buf, _type) + if err != nil { + goto ReadFieldError + } + case 21: + offset, err = x.fastReadField21(buf, _type) + if err != nil { + goto ReadFieldError + } + case 22: + offset, err = x.fastReadField22(buf, _type) + if err != nil { + goto ReadFieldError + } + case 23: + offset, err = x.fastReadField23(buf, _type) + if err != nil { + goto ReadFieldError + } + case 24: + offset, err = x.fastReadField24(buf, _type) + if err != nil { + goto ReadFieldError + } + case 25: + offset, err = x.fastReadField25(buf, _type) + if err != nil { + goto ReadFieldError + } + case 26: + offset, err = x.fastReadField26(buf, _type) + if err != nil { + goto ReadFieldError + } + case 27: + offset, err = x.fastReadField27(buf, _type) + if err != nil { + goto ReadFieldError + } + case 28: + offset, err = x.fastReadField28(buf, _type) + if err != nil { + goto ReadFieldError + } + case 29: + offset, err = x.fastReadField29(buf, _type) + if err != nil { + goto ReadFieldError + } + case 30: + offset, err = x.fastReadField30(buf, _type) + if err != nil { + goto ReadFieldError + } + case 31: + offset, err = x.fastReadField31(buf, _type) + if err != nil { + goto ReadFieldError + } + case 255: + offset, err = x.fastReadField255(buf, _type) + if err != nil { + goto ReadFieldError + } + default: + offset, err = fastpb.Skip(buf, _type, number) + if err != nil { + goto SkipFieldError + } + } + return offset, nil +SkipFieldError: + return offset, fmt.Errorf("%T cannot parse invalid wire-format data, error: %s", x, err) +ReadFieldError: + return offset, fmt.Errorf("%T read field %d '%s' error: %s", x, number, fieldIDToName_InnerBase2[number], err) +} + +func (x *InnerBase2) fastReadField1(buf []byte, _type int8) (offset int, err error) { + x.Bool, offset, err = fastpb.ReadBool(buf, _type) + return offset, err +} + +func (x *InnerBase2) fastReadField2(buf []byte, _type int8) (offset int, err error) { + x.Uint32, offset, err = fastpb.ReadUint32(buf, _type) + return offset, err +} + +func (x *InnerBase2) fastReadField3(buf []byte, _type int8) (offset int, err error) { + x.Uint64, offset, err = fastpb.ReadUint64(buf, _type) + return offset, err +} + +func (x *InnerBase2) fastReadField4(buf []byte, _type int8) (offset int, err error) { + x.Int32, offset, err = fastpb.ReadInt32(buf, _type) + return offset, err +} + +func (x *InnerBase2) fastReadField5(buf []byte, _type int8) (offset int, err error) { + x.Int64, offset, err = fastpb.ReadInt64(buf, _type) + return offset, err +} + +func (x *InnerBase2) fastReadField6(buf []byte, _type int8) (offset int, err error) { + x.Double, offset, err = fastpb.ReadDouble(buf, _type) + return offset, err +} + +func (x *InnerBase2) fastReadField7(buf []byte, _type int8) (offset int, err error) { + x.String_, offset, err = fastpb.ReadString(buf, _type) + return offset, err +} + +func (x *InnerBase2) fastReadField8(buf []byte, _type int8) (offset int, err error) { + offset, err = fastpb.ReadList(buf, _type, + func(buf []byte, _type int8) (n int, err error) { + var v int32 + v, offset, err = fastpb.ReadInt32(buf, _type) + if err != nil { + return offset, err + } + x.ListInt32 = append(x.ListInt32, v) + return offset, err + }) + return offset, err +} + +func (x *InnerBase2) fastReadField9(buf []byte, _type int8) (offset int, err error) { + if x.MapStringString == nil { + x.MapStringString = make(map[string]string) + } + var key string + var value string + offset, err = fastpb.ReadMapEntry(buf, _type, + func(buf []byte, _type int8) (offset int, err error) { + key, offset, err = fastpb.ReadString(buf, _type) + return offset, err + }, + func(buf []byte, _type int8) (offset int, err error) { + value, offset, err = fastpb.ReadString(buf, _type) + return offset, err + }) + if err != nil { + return offset, err + } + x.MapStringString[key] = value + return offset, nil +} + +func (x *InnerBase2) fastReadField10(buf []byte, _type int8) (offset int, err error) { + offset, err = fastpb.ReadList(buf, _type, + func(buf []byte, _type int8) (n int, err error) { + var v int32 + v, offset, err = fastpb.ReadInt32(buf, _type) + if err != nil { + return offset, err + } + x.SetInt32 = append(x.SetInt32, v) + return offset, err + }) + return offset, err +} + +func (x *InnerBase2) fastReadField11(buf []byte, _type int8) (offset int, err error) { + var v int32 + v, offset, err = fastpb.ReadInt32(buf, _type) + if err != nil { + return offset, err + } + x.Foo = FOO(v) + return offset, nil +} + +func (x *InnerBase2) fastReadField12(buf []byte, _type int8) (offset int, err error) { + if x.MapInt32String == nil { + x.MapInt32String = make(map[int32]string) + } + var key int32 + var value string + offset, err = fastpb.ReadMapEntry(buf, _type, + func(buf []byte, _type int8) (offset int, err error) { + key, offset, err = fastpb.ReadInt32(buf, _type) + return offset, err + }, + func(buf []byte, _type int8) (offset int, err error) { + value, offset, err = fastpb.ReadString(buf, _type) + return offset, err + }) + if err != nil { + return offset, err + } + x.MapInt32String[key] = value + return offset, nil +} + +func (x *InnerBase2) fastReadField13(buf []byte, _type int8) (offset int, err error) { + x.Binary, offset, err = fastpb.ReadBytes(buf, _type) + return offset, err +} + +func (x *InnerBase2) fastReadField14(buf []byte, _type int8) (offset int, err error) { + if x.MapUint32String == nil { + x.MapUint32String = make(map[uint32]string) + } + var key uint32 + var value string + offset, err = fastpb.ReadMapEntry(buf, _type, + func(buf []byte, _type int8) (offset int, err error) { + key, offset, err = fastpb.ReadUint32(buf, _type) + return offset, err + }, + func(buf []byte, _type int8) (offset int, err error) { + value, offset, err = fastpb.ReadString(buf, _type) + return offset, err + }) + if err != nil { + return offset, err + } + x.MapUint32String[key] = value + return offset, nil +} + +func (x *InnerBase2) fastReadField15(buf []byte, _type int8) (offset int, err error) { + if x.MapUint64String == nil { + x.MapUint64String = make(map[uint64]string) + } + var key uint64 + var value string + offset, err = fastpb.ReadMapEntry(buf, _type, + func(buf []byte, _type int8) (offset int, err error) { + key, offset, err = fastpb.ReadUint64(buf, _type) + return offset, err + }, + func(buf []byte, _type int8) (offset int, err error) { + value, offset, err = fastpb.ReadString(buf, _type) + return offset, err + }) + if err != nil { + return offset, err + } + x.MapUint64String[key] = value + return offset, nil +} + +func (x *InnerBase2) fastReadField16(buf []byte, _type int8) (offset int, err error) { + if x.MapInt64String == nil { + x.MapInt64String = make(map[int64]string) + } + var key int64 + var value string + offset, err = fastpb.ReadMapEntry(buf, _type, + func(buf []byte, _type int8) (offset int, err error) { + key, offset, err = fastpb.ReadInt64(buf, _type) + return offset, err + }, + func(buf []byte, _type int8) (offset int, err error) { + value, offset, err = fastpb.ReadString(buf, _type) + return offset, err + }) + if err != nil { + return offset, err + } + x.MapInt64String[key] = value + return offset, nil +} + +func (x *InnerBase2) fastReadField17(buf []byte, _type int8) (offset int, err error) { + if x.MapInt64Base == nil { + x.MapInt64Base = make(map[int64]*base.Base) + } + var key int64 + var value *base.Base + offset, err = fastpb.ReadMapEntry(buf, _type, + func(buf []byte, _type int8) (offset int, err error) { + key, offset, err = fastpb.ReadInt64(buf, _type) + return offset, err + }, + func(buf []byte, _type int8) (offset int, err error) { + var v base.Base + offset, err = fastpb.ReadMessage(buf, _type, &v) + if err != nil { + return offset, err + } + value = &v + return offset, nil + }) + if err != nil { + return offset, err + } + x.MapInt64Base[key] = value + return offset, nil +} + +func (x *InnerBase2) fastReadField18(buf []byte, _type int8) (offset int, err error) { + var v InnerBase2 + offset, err = fastpb.ReadMessage(buf, _type, &v) + if err != nil { + return offset, err + } + x.ListInnerBase = append(x.ListInnerBase, &v) + return offset, nil +} + +func (x *InnerBase2) fastReadField19(buf []byte, _type int8) (offset int, err error) { + var v base.Base + offset, err = fastpb.ReadMessage(buf, _type, &v) + if err != nil { + return offset, err + } + x.ListBase = append(x.ListBase, &v) + return offset, nil +} + +func (x *InnerBase2) fastReadField20(buf []byte, _type int8) (offset int, err error) { + if x.MapStringBase == nil { + x.MapStringBase = make(map[string]*base.Base) + } + var key string + var value *base.Base + offset, err = fastpb.ReadMapEntry(buf, _type, + func(buf []byte, _type int8) (offset int, err error) { + key, offset, err = fastpb.ReadString(buf, _type) + return offset, err + }, + func(buf []byte, _type int8) (offset int, err error) { + var v base.Base + offset, err = fastpb.ReadMessage(buf, _type, &v) + if err != nil { + return offset, err + } + value = &v + return offset, nil + }) + if err != nil { + return offset, err + } + x.MapStringBase[key] = value + return offset, nil +} + +func (x *InnerBase2) fastReadField21(buf []byte, _type int8) (offset int, err error) { + var v string + v, offset, err = fastpb.ReadString(buf, _type) + if err != nil { + return offset, err + } + x.ListString = append(x.ListString, v) + return offset, err +} + +func (x *InnerBase2) fastReadField22(buf []byte, _type int8) (offset int, err error) { + x.Sfixed32, offset, err = fastpb.ReadSfixed32(buf, _type) + return offset, err +} + +func (x *InnerBase2) fastReadField23(buf []byte, _type int8) (offset int, err error) { + x.Fixed64, offset, err = fastpb.ReadFixed64(buf, _type) + return offset, err +} + +func (x *InnerBase2) fastReadField24(buf []byte, _type int8) (offset int, err error) { + x.Sint32, offset, err = fastpb.ReadSint32(buf, _type) + return offset, err +} + +func (x *InnerBase2) fastReadField25(buf []byte, _type int8) (offset int, err error) { + x.Sint64, offset, err = fastpb.ReadSint64(buf, _type) + return offset, err +} + +func (x *InnerBase2) fastReadField26(buf []byte, _type int8) (offset int, err error) { + offset, err = fastpb.ReadList(buf, _type, + func(buf []byte, _type int8) (n int, err error) { + var v int64 + v, offset, err = fastpb.ReadSint64(buf, _type) + if err != nil { + return offset, err + } + x.ListSInt64 = append(x.ListSInt64, v) + return offset, err + }) + return offset, err +} + +func (x *InnerBase2) fastReadField27(buf []byte, _type int8) (offset int, err error) { + offset, err = fastpb.ReadList(buf, _type, + func(buf []byte, _type int8) (n int, err error) { + var v int32 + v, offset, err = fastpb.ReadSint32(buf, _type) + if err != nil { + return offset, err + } + x.ListSInt32 = append(x.ListSInt32, v) + return offset, err + }) + return offset, err +} + +func (x *InnerBase2) fastReadField28(buf []byte, _type int8) (offset int, err error) { + offset, err = fastpb.ReadList(buf, _type, + func(buf []byte, _type int8) (n int, err error) { + var v int32 + v, offset, err = fastpb.ReadSfixed32(buf, _type) + if err != nil { + return offset, err + } + x.ListSfixed32 = append(x.ListSfixed32, v) + return offset, err + }) + return offset, err +} + +func (x *InnerBase2) fastReadField29(buf []byte, _type int8) (offset int, err error) { + offset, err = fastpb.ReadList(buf, _type, + func(buf []byte, _type int8) (n int, err error) { + var v uint64 + v, offset, err = fastpb.ReadFixed64(buf, _type) + if err != nil { + return offset, err + } + x.ListFixed64 = append(x.ListFixed64, v) + return offset, err + }) + return offset, err +} + +func (x *InnerBase2) fastReadField30(buf []byte, _type int8) (offset int, err error) { + if x.MapInt64Sfixed64 == nil { + x.MapInt64Sfixed64 = make(map[int64]int64) + } + var key int64 + var value int64 + offset, err = fastpb.ReadMapEntry(buf, _type, + func(buf []byte, _type int8) (offset int, err error) { + key, offset, err = fastpb.ReadInt64(buf, _type) + return offset, err + }, + func(buf []byte, _type int8) (offset int, err error) { + value, offset, err = fastpb.ReadSfixed64(buf, _type) + return offset, err + }) + if err != nil { + return offset, err + } + x.MapInt64Sfixed64[key] = value + return offset, nil +} + +func (x *InnerBase2) fastReadField31(buf []byte, _type int8) (offset int, err error) { + if x.MapStringFixed32 == nil { + x.MapStringFixed32 = make(map[string]uint32) + } + var key string + var value uint32 + offset, err = fastpb.ReadMapEntry(buf, _type, + func(buf []byte, _type int8) (offset int, err error) { + key, offset, err = fastpb.ReadString(buf, _type) + return offset, err + }, + func(buf []byte, _type int8) (offset int, err error) { + value, offset, err = fastpb.ReadFixed32(buf, _type) + return offset, err + }) + if err != nil { + return offset, err + } + x.MapStringFixed32[key] = value + return offset, nil +} + +func (x *InnerBase2) fastReadField255(buf []byte, _type int8) (offset int, err error) { + var v base.Base + offset, err = fastpb.ReadMessage(buf, _type, &v) + if err != nil { + return offset, err + } + x.Base = &v + return offset, nil +} + +func (x *InnerBasePartial) FastRead(buf []byte, _type int8, number int32) (offset int, err error) { + switch number { + case 1: + offset, err = x.fastReadField1(buf, _type) + if err != nil { + goto ReadFieldError + } + case 8: + offset, err = x.fastReadField8(buf, _type) + if err != nil { + goto ReadFieldError + } + case 9: + offset, err = x.fastReadField9(buf, _type) + if err != nil { + goto ReadFieldError + } + case 18: + offset, err = x.fastReadField18(buf, _type) + if err != nil { + goto ReadFieldError + } + case 19: + offset, err = x.fastReadField19(buf, _type) + if err != nil { + goto ReadFieldError + } + case 20: + offset, err = x.fastReadField20(buf, _type) + if err != nil { + goto ReadFieldError + } + case 127: + offset, err = x.fastReadField127(buf, _type) + if err != nil { + goto ReadFieldError + } + default: + offset, err = fastpb.Skip(buf, _type, number) + if err != nil { + goto SkipFieldError + } + } + return offset, nil +SkipFieldError: + return offset, fmt.Errorf("%T cannot parse invalid wire-format data, error: %s", x, err) +ReadFieldError: + return offset, fmt.Errorf("%T read field %d '%s' error: %s", x, number, fieldIDToName_InnerBasePartial[number], err) +} + +func (x *InnerBasePartial) fastReadField1(buf []byte, _type int8) (offset int, err error) { + x.Bool, offset, err = fastpb.ReadBool(buf, _type) + return offset, err +} + +func (x *InnerBasePartial) fastReadField8(buf []byte, _type int8) (offset int, err error) { + offset, err = fastpb.ReadList(buf, _type, + func(buf []byte, _type int8) (n int, err error) { + var v int32 + v, offset, err = fastpb.ReadInt32(buf, _type) + if err != nil { + return offset, err + } + x.ListInt32 = append(x.ListInt32, v) + return offset, err + }) + return offset, err +} + +func (x *InnerBasePartial) fastReadField9(buf []byte, _type int8) (offset int, err error) { + if x.MapStringString == nil { + x.MapStringString = make(map[string]string) + } + var key string + var value string + offset, err = fastpb.ReadMapEntry(buf, _type, + func(buf []byte, _type int8) (offset int, err error) { + key, offset, err = fastpb.ReadString(buf, _type) + return offset, err + }, + func(buf []byte, _type int8) (offset int, err error) { + value, offset, err = fastpb.ReadString(buf, _type) + return offset, err + }) + if err != nil { + return offset, err + } + x.MapStringString[key] = value + return offset, nil +} + +func (x *InnerBasePartial) fastReadField18(buf []byte, _type int8) (offset int, err error) { + var v InnerBasePartial + offset, err = fastpb.ReadMessage(buf, _type, &v) + if err != nil { + return offset, err + } + x.ListInnerBase = append(x.ListInnerBase, &v) + return offset, nil +} + +func (x *InnerBasePartial) fastReadField19(buf []byte, _type int8) (offset int, err error) { + var v BasePartial + offset, err = fastpb.ReadMessage(buf, _type, &v) + if err != nil { + return offset, err + } + x.ListBase = append(x.ListBase, &v) + return offset, nil +} + +func (x *InnerBasePartial) fastReadField20(buf []byte, _type int8) (offset int, err error) { + if x.MapStringBase == nil { + x.MapStringBase = make(map[string]*BasePartial) + } + var key string + var value *BasePartial + offset, err = fastpb.ReadMapEntry(buf, _type, + func(buf []byte, _type int8) (offset int, err error) { + key, offset, err = fastpb.ReadString(buf, _type) + return offset, err + }, + func(buf []byte, _type int8) (offset int, err error) { + var v BasePartial + offset, err = fastpb.ReadMessage(buf, _type, &v) + if err != nil { + return offset, err + } + value = &v + return offset, nil + }) + if err != nil { + return offset, err + } + x.MapStringBase[key] = value + return offset, nil +} + +func (x *InnerBasePartial) fastReadField127(buf []byte, _type int8) (offset int, err error) { + if x.MapStringString2 == nil { + x.MapStringString2 = make(map[string]string) + } + var key string + var value string + offset, err = fastpb.ReadMapEntry(buf, _type, + func(buf []byte, _type int8) (offset int, err error) { + key, offset, err = fastpb.ReadString(buf, _type) + return offset, err + }, + func(buf []byte, _type int8) (offset int, err error) { + value, offset, err = fastpb.ReadString(buf, _type) + return offset, err + }) + if err != nil { + return offset, err + } + x.MapStringString2[key] = value + return offset, nil +} + +func (x *BasePartial) FastRead(buf []byte, _type int8, number int32) (offset int, err error) { + switch number { + case 5: + offset, err = x.fastReadField5(buf, _type) + if err != nil { + goto ReadFieldError + } + default: + offset, err = fastpb.Skip(buf, _type, number) + if err != nil { + goto SkipFieldError + } + } + return offset, nil +SkipFieldError: + return offset, fmt.Errorf("%T cannot parse invalid wire-format data, error: %s", x, err) +ReadFieldError: + return offset, fmt.Errorf("%T read field %d '%s' error: %s", x, number, fieldIDToName_BasePartial[number], err) +} + +func (x *BasePartial) fastReadField5(buf []byte, _type int8) (offset int, err error) { + var v base.TrafficEnv + offset, err = fastpb.ReadMessage(buf, _type, &v) + if err != nil { + return offset, err + } + x.TrafficEnv = &v + return offset, nil +} + +func (x *ExampleReq) FastRead(buf []byte, _type int8, number int32) (offset int, err error) { + switch number { + case 1: + offset, err = x.fastReadField1(buf, _type) + if err != nil { + goto ReadFieldError + } + case 2: + offset, err = x.fastReadField2(buf, _type) + if err != nil { + goto ReadFieldError + } + case 3: + offset, err = x.fastReadField3(buf, _type) + if err != nil { + goto ReadFieldError + } + case 255: + offset, err = x.fastReadField255(buf, _type) + if err != nil { + goto ReadFieldError + } + case 32767: + offset, err = x.fastReadField32767(buf, _type) + if err != nil { + goto ReadFieldError + } + default: + offset, err = fastpb.Skip(buf, _type, number) + if err != nil { + goto SkipFieldError + } + } + return offset, nil +SkipFieldError: + return offset, fmt.Errorf("%T cannot parse invalid wire-format data, error: %s", x, err) +ReadFieldError: + return offset, fmt.Errorf("%T read field %d '%s' error: %s", x, number, fieldIDToName_ExampleReq[number], err) +} + +func (x *ExampleReq) fastReadField1(buf []byte, _type int8) (offset int, err error) { + x.Msg, offset, err = fastpb.ReadString(buf, _type) + return offset, err +} + +func (x *ExampleReq) fastReadField2(buf []byte, _type int8) (offset int, err error) { + x.A, offset, err = fastpb.ReadInt32(buf, _type) + return offset, err +} + +func (x *ExampleReq) fastReadField3(buf []byte, _type int8) (offset int, err error) { + var v InnerBase2 + offset, err = fastpb.ReadMessage(buf, _type, &v) + if err != nil { + return offset, err + } + x.InnerBase2 = &v + return offset, nil +} + +func (x *ExampleReq) fastReadField255(buf []byte, _type int8) (offset int, err error) { + var v base.Base + offset, err = fastpb.ReadMessage(buf, _type, &v) + if err != nil { + return offset, err + } + x.Base = &v + return offset, nil +} + +func (x *ExampleReq) fastReadField32767(buf []byte, _type int8) (offset int, err error) { + x.Subfix, offset, err = fastpb.ReadDouble(buf, _type) + return offset, err +} + +func (x *ExampleSuper) FastRead(buf []byte, _type int8, number int32) (offset int, err error) { + switch number { + case 1: + offset, err = x.fastReadField1(buf, _type) + if err != nil { + goto ReadFieldError + } + case 2: + offset, err = x.fastReadField2(buf, _type) + if err != nil { + goto ReadFieldError + } + case 3: + offset, err = x.fastReadField3(buf, _type) + if err != nil { + goto ReadFieldError + } + case 4: + offset, err = x.fastReadField4(buf, _type) + if err != nil { + goto ReadFieldError + } + case 5: + offset, err = x.fastReadField5(buf, _type) + if err != nil { + goto ReadFieldError + } + case 6: + offset, err = x.fastReadField6(buf, _type) + if err != nil { + goto ReadFieldError + } + case 7: + offset, err = x.fastReadField7(buf, _type) + if err != nil { + goto ReadFieldError + } + case 9: + offset, err = x.fastReadField9(buf, _type) + if err != nil { + goto ReadFieldError + } + case 255: + offset, err = x.fastReadField255(buf, _type) + if err != nil { + goto ReadFieldError + } + case 32767: + offset, err = x.fastReadField32767(buf, _type) + if err != nil { + goto ReadFieldError + } + default: + offset, err = fastpb.Skip(buf, _type, number) + if err != nil { + goto SkipFieldError + } + } + return offset, nil +SkipFieldError: + return offset, fmt.Errorf("%T cannot parse invalid wire-format data, error: %s", x, err) +ReadFieldError: + return offset, fmt.Errorf("%T read field %d '%s' error: %s", x, number, fieldIDToName_ExampleSuper[number], err) +} + +func (x *ExampleSuper) fastReadField1(buf []byte, _type int8) (offset int, err error) { + x.Msg, offset, err = fastpb.ReadString(buf, _type) + return offset, err +} + +func (x *ExampleSuper) fastReadField2(buf []byte, _type int8) (offset int, err error) { + x.A, offset, err = fastpb.ReadInt32(buf, _type) + return offset, err +} + +func (x *ExampleSuper) fastReadField3(buf []byte, _type int8) (offset int, err error) { + var v InnerBase2 + offset, err = fastpb.ReadMessage(buf, _type, &v) + if err != nil { + return offset, err + } + x.InnerBase2 = &v + return offset, nil +} + +func (x *ExampleSuper) fastReadField4(buf []byte, _type int8) (offset int, err error) { + x.Ex1, offset, err = fastpb.ReadString(buf, _type) + return offset, err +} + +func (x *ExampleSuper) fastReadField5(buf []byte, _type int8) (offset int, err error) { + x.Ex2, offset, err = fastpb.ReadString(buf, _type) + return offset, err +} + +func (x *ExampleSuper) fastReadField6(buf []byte, _type int8) (offset int, err error) { + x.Ex3, offset, err = fastpb.ReadString(buf, _type) + return offset, err +} + +func (x *ExampleSuper) fastReadField7(buf []byte, _type int8) (offset int, err error) { + x.Ex4, offset, err = fastpb.ReadString(buf, _type) + return offset, err +} + +func (x *ExampleSuper) fastReadField9(buf []byte, _type int8) (offset int, err error) { + var v SelfRef + offset, err = fastpb.ReadMessage(buf, _type, &v) + if err != nil { + return offset, err + } + x.SelfRef = &v + return offset, nil +} + +func (x *ExampleSuper) fastReadField255(buf []byte, _type int8) (offset int, err error) { + var v base.Base + offset, err = fastpb.ReadMessage(buf, _type, &v) + if err != nil { + return offset, err + } + x.Base = &v + return offset, nil +} + +func (x *ExampleSuper) fastReadField32767(buf []byte, _type int8) (offset int, err error) { + x.Subfix, offset, err = fastpb.ReadDouble(buf, _type) + return offset, err +} + +func (x *SelfRef) FastRead(buf []byte, _type int8, number int32) (offset int, err error) { + switch number { + case 1: + offset, err = x.fastReadField1(buf, _type) + if err != nil { + goto ReadFieldError + } + default: + offset, err = fastpb.Skip(buf, _type, number) + if err != nil { + goto SkipFieldError + } + } + return offset, nil +SkipFieldError: + return offset, fmt.Errorf("%T cannot parse invalid wire-format data, error: %s", x, err) +ReadFieldError: + return offset, fmt.Errorf("%T read field %d '%s' error: %s", x, number, fieldIDToName_SelfRef[number], err) +} + +func (x *SelfRef) fastReadField1(buf []byte, _type int8) (offset int, err error) { + var v SelfRef + offset, err = fastpb.ReadMessage(buf, _type, &v) + if err != nil { + return offset, err + } + x.Self = &v + return offset, nil +} + +func (x *ExampleReqPartial) FastRead(buf []byte, _type int8, number int32) (offset int, err error) { + switch number { + case 1: + offset, err = x.fastReadField1(buf, _type) + if err != nil { + goto ReadFieldError + } + case 3: + offset, err = x.fastReadField3(buf, _type) + if err != nil { + goto ReadFieldError + } + case 255: + offset, err = x.fastReadField255(buf, _type) + if err != nil { + goto ReadFieldError + } + default: + offset, err = fastpb.Skip(buf, _type, number) + if err != nil { + goto SkipFieldError + } + } + return offset, nil +SkipFieldError: + return offset, fmt.Errorf("%T cannot parse invalid wire-format data, error: %s", x, err) +ReadFieldError: + return offset, fmt.Errorf("%T read field %d '%s' error: %s", x, number, fieldIDToName_ExampleReqPartial[number], err) +} + +func (x *ExampleReqPartial) fastReadField1(buf []byte, _type int8) (offset int, err error) { + x.Msg, offset, err = fastpb.ReadString(buf, _type) + return offset, err +} + +func (x *ExampleReqPartial) fastReadField3(buf []byte, _type int8) (offset int, err error) { + var v InnerBasePartial + offset, err = fastpb.ReadMessage(buf, _type, &v) + if err != nil { + return offset, err + } + x.InnerBase2 = &v + return offset, nil +} + +func (x *ExampleReqPartial) fastReadField255(buf []byte, _type int8) (offset int, err error) { + var v BasePartial + offset, err = fastpb.ReadMessage(buf, _type, &v) + if err != nil { + return offset, err + } + x.Base = &v + return offset, nil +} + +func (x *ExampleResp) FastRead(buf []byte, _type int8, number int32) (offset int, err error) { + switch number { + case 1: + offset, err = x.fastReadField1(buf, _type) + if err != nil { + goto ReadFieldError + } + case 2: + offset, err = x.fastReadField2(buf, _type) + if err != nil { + goto ReadFieldError + } + case 255: + offset, err = x.fastReadField255(buf, _type) + if err != nil { + goto ReadFieldError + } + default: + offset, err = fastpb.Skip(buf, _type, number) + if err != nil { + goto SkipFieldError + } + } + return offset, nil +SkipFieldError: + return offset, fmt.Errorf("%T cannot parse invalid wire-format data, error: %s", x, err) +ReadFieldError: + return offset, fmt.Errorf("%T read field %d '%s' error: %s", x, number, fieldIDToName_ExampleResp[number], err) +} + +func (x *ExampleResp) fastReadField1(buf []byte, _type int8) (offset int, err error) { + x.Msg, offset, err = fastpb.ReadString(buf, _type) + return offset, err +} + +func (x *ExampleResp) fastReadField2(buf []byte, _type int8) (offset int, err error) { + x.RequiredField, offset, err = fastpb.ReadString(buf, _type) + return offset, err +} + +func (x *ExampleResp) fastReadField255(buf []byte, _type int8) (offset int, err error) { + var v base.BaseResp + offset, err = fastpb.ReadMessage(buf, _type, &v) + if err != nil { + return offset, err + } + x.BaseResp = &v + return offset, nil +} + +func (x *ExampleRespPartial) FastRead(buf []byte, _type int8, number int32) (offset int, err error) { + switch number { + case 2: + offset, err = x.fastReadField2(buf, _type) + if err != nil { + goto ReadFieldError + } + case 255: + offset, err = x.fastReadField255(buf, _type) + if err != nil { + goto ReadFieldError + } + default: + offset, err = fastpb.Skip(buf, _type, number) + if err != nil { + goto SkipFieldError + } + } + return offset, nil +SkipFieldError: + return offset, fmt.Errorf("%T cannot parse invalid wire-format data, error: %s", x, err) +ReadFieldError: + return offset, fmt.Errorf("%T read field %d '%s' error: %s", x, number, fieldIDToName_ExampleRespPartial[number], err) +} + +func (x *ExampleRespPartial) fastReadField2(buf []byte, _type int8) (offset int, err error) { + x.RequiredField, offset, err = fastpb.ReadString(buf, _type) + return offset, err +} + +func (x *ExampleRespPartial) fastReadField255(buf []byte, _type int8) (offset int, err error) { + var v base.BaseResp + offset, err = fastpb.ReadMessage(buf, _type, &v) + if err != nil { + return offset, err + } + x.BaseResp = &v + return offset, nil +} + +func (x *Exception) FastRead(buf []byte, _type int8, number int32) (offset int, err error) { + switch number { + case 1: + offset, err = x.fastReadField1(buf, _type) + if err != nil { + goto ReadFieldError + } + case 255: + offset, err = x.fastReadField255(buf, _type) + if err != nil { + goto ReadFieldError + } + default: + offset, err = fastpb.Skip(buf, _type, number) + if err != nil { + goto SkipFieldError + } + } + return offset, nil +SkipFieldError: + return offset, fmt.Errorf("%T cannot parse invalid wire-format data, error: %s", x, err) +ReadFieldError: + return offset, fmt.Errorf("%T read field %d '%s' error: %s", x, number, fieldIDToName_Exception[number], err) +} + +func (x *Exception) fastReadField1(buf []byte, _type int8) (offset int, err error) { + x.Code, offset, err = fastpb.ReadInt32(buf, _type) + return offset, err +} + +func (x *Exception) fastReadField255(buf []byte, _type int8) (offset int, err error) { + x.Msg, offset, err = fastpb.ReadString(buf, _type) + return offset, err +} + +func (x *A) FastRead(buf []byte, _type int8, number int32) (offset int, err error) { + switch number { + case 1: + offset, err = x.fastReadField1(buf, _type) + if err != nil { + goto ReadFieldError + } + default: + offset, err = fastpb.Skip(buf, _type, number) + if err != nil { + goto SkipFieldError + } + } + return offset, nil +SkipFieldError: + return offset, fmt.Errorf("%T cannot parse invalid wire-format data, error: %s", x, err) +ReadFieldError: + return offset, fmt.Errorf("%T read field %d '%s' error: %s", x, number, fieldIDToName_A[number], err) +} + +func (x *A) fastReadField1(buf []byte, _type int8) (offset int, err error) { + var v A + offset, err = fastpb.ReadMessage(buf, _type, &v) + if err != nil { + return offset, err + } + x.Self = &v + return offset, nil +} + +func (x *PingResponse) FastRead(buf []byte, _type int8, number int32) (offset int, err error) { + switch number { + case 1: + offset, err = x.fastReadField1(buf, _type) + if err != nil { + goto ReadFieldError + } + default: + offset, err = fastpb.Skip(buf, _type, number) + if err != nil { + goto SkipFieldError + } + } + return offset, nil +SkipFieldError: + return offset, fmt.Errorf("%T cannot parse invalid wire-format data, error: %s", x, err) +ReadFieldError: + return offset, fmt.Errorf("%T read field %d '%s' error: %s", x, number, fieldIDToName_PingResponse[number], err) +} + +func (x *PingResponse) fastReadField1(buf []byte, _type int8) (offset int, err error) { + x.Message, offset, err = fastpb.ReadString(buf, _type) + return offset, err +} + +func (x *OnewayRequest) FastRead(buf []byte, _type int8, number int32) (offset int, err error) { + switch number { + case 1: + offset, err = x.fastReadField1(buf, _type) + if err != nil { + goto ReadFieldError + } + default: + offset, err = fastpb.Skip(buf, _type, number) + if err != nil { + goto SkipFieldError + } + } + return offset, nil +SkipFieldError: + return offset, fmt.Errorf("%T cannot parse invalid wire-format data, error: %s", x, err) +ReadFieldError: + return offset, fmt.Errorf("%T read field %d '%s' error: %s", x, number, fieldIDToName_OnewayRequest[number], err) +} + +func (x *OnewayRequest) fastReadField1(buf []byte, _type int8) (offset int, err error) { + x.Msg, offset, err = fastpb.ReadString(buf, _type) + return offset, err +} + +func (x *VoidRequest) FastRead(buf []byte, _type int8, number int32) (offset int, err error) { + switch number { + case 1: + offset, err = x.fastReadField1(buf, _type) + if err != nil { + goto ReadFieldError + } + default: + offset, err = fastpb.Skip(buf, _type, number) + if err != nil { + goto SkipFieldError + } + } + return offset, nil +SkipFieldError: + return offset, fmt.Errorf("%T cannot parse invalid wire-format data, error: %s", x, err) +ReadFieldError: + return offset, fmt.Errorf("%T read field %d '%s' error: %s", x, number, fieldIDToName_VoidRequest[number], err) +} + +func (x *VoidRequest) fastReadField1(buf []byte, _type int8) (offset int, err error) { + x.Msg, offset, err = fastpb.ReadString(buf, _type) + return offset, err +} + +func (x *VoidResponse) FastRead(buf []byte, _type int8, number int32) (offset int, err error) { + switch number { + default: + offset, err = fastpb.Skip(buf, _type, number) + if err != nil { + goto SkipFieldError + } + } + return offset, nil +SkipFieldError: + return offset, fmt.Errorf("%T cannot parse invalid wire-format data, error: %s", x, err) +} + +func (x *ExampleInt2Float) FastRead(buf []byte, _type int8, number int32) (offset int, err error) { + switch number { + case 1: + offset, err = x.fastReadField1(buf, _type) + if err != nil { + goto ReadFieldError + } + case 2: + offset, err = x.fastReadField2(buf, _type) + if err != nil { + goto ReadFieldError + } + case 3: + offset, err = x.fastReadField3(buf, _type) + if err != nil { + goto ReadFieldError + } + case 4: + offset, err = x.fastReadField4(buf, _type) + if err != nil { + goto ReadFieldError + } + case 32767: + offset, err = x.fastReadField32767(buf, _type) + if err != nil { + goto ReadFieldError + } + default: + offset, err = fastpb.Skip(buf, _type, number) + if err != nil { + goto SkipFieldError + } + } + return offset, nil +SkipFieldError: + return offset, fmt.Errorf("%T cannot parse invalid wire-format data, error: %s", x, err) +ReadFieldError: + return offset, fmt.Errorf("%T read field %d '%s' error: %s", x, number, fieldIDToName_ExampleInt2Float[number], err) +} + +func (x *ExampleInt2Float) fastReadField1(buf []byte, _type int8) (offset int, err error) { + x.Int32, offset, err = fastpb.ReadInt32(buf, _type) + return offset, err +} + +func (x *ExampleInt2Float) fastReadField2(buf []byte, _type int8) (offset int, err error) { + x.Float64, offset, err = fastpb.ReadDouble(buf, _type) + return offset, err +} + +func (x *ExampleInt2Float) fastReadField3(buf []byte, _type int8) (offset int, err error) { + x.String_, offset, err = fastpb.ReadString(buf, _type) + return offset, err +} + +func (x *ExampleInt2Float) fastReadField4(buf []byte, _type int8) (offset int, err error) { + x.Int64, offset, err = fastpb.ReadInt64(buf, _type) + return offset, err +} + +func (x *ExampleInt2Float) fastReadField32767(buf []byte, _type int8) (offset int, err error) { + x.Subfix, offset, err = fastpb.ReadDouble(buf, _type) + return offset, err +} + +func (x *InnerBase2) FastWrite(buf []byte) (offset int) { + if x == nil { + return offset + } + offset += x.fastWriteField1(buf[offset:]) + offset += x.fastWriteField2(buf[offset:]) + offset += x.fastWriteField3(buf[offset:]) + offset += x.fastWriteField4(buf[offset:]) + offset += x.fastWriteField5(buf[offset:]) + offset += x.fastWriteField6(buf[offset:]) + offset += x.fastWriteField7(buf[offset:]) + offset += x.fastWriteField8(buf[offset:]) + offset += x.fastWriteField9(buf[offset:]) + offset += x.fastWriteField10(buf[offset:]) + offset += x.fastWriteField11(buf[offset:]) + offset += x.fastWriteField12(buf[offset:]) + offset += x.fastWriteField13(buf[offset:]) + offset += x.fastWriteField14(buf[offset:]) + offset += x.fastWriteField15(buf[offset:]) + offset += x.fastWriteField16(buf[offset:]) + offset += x.fastWriteField17(buf[offset:]) + offset += x.fastWriteField18(buf[offset:]) + offset += x.fastWriteField19(buf[offset:]) + offset += x.fastWriteField20(buf[offset:]) + offset += x.fastWriteField21(buf[offset:]) + offset += x.fastWriteField22(buf[offset:]) + offset += x.fastWriteField23(buf[offset:]) + offset += x.fastWriteField24(buf[offset:]) + offset += x.fastWriteField25(buf[offset:]) + offset += x.fastWriteField26(buf[offset:]) + offset += x.fastWriteField27(buf[offset:]) + offset += x.fastWriteField28(buf[offset:]) + offset += x.fastWriteField29(buf[offset:]) + offset += x.fastWriteField30(buf[offset:]) + offset += x.fastWriteField31(buf[offset:]) + offset += x.fastWriteField255(buf[offset:]) + return offset +} + +func (x *InnerBase2) fastWriteField1(buf []byte) (offset int) { + if !x.Bool { + return offset + } + offset += fastpb.WriteBool(buf[offset:], 1, x.GetBool()) + return offset +} + +func (x *InnerBase2) fastWriteField2(buf []byte) (offset int) { + if x.Uint32 == 0 { + return offset + } + offset += fastpb.WriteUint32(buf[offset:], 2, x.GetUint32()) + return offset +} + +func (x *InnerBase2) fastWriteField3(buf []byte) (offset int) { + if x.Uint64 == 0 { + return offset + } + offset += fastpb.WriteUint64(buf[offset:], 3, x.GetUint64()) + return offset +} + +func (x *InnerBase2) fastWriteField4(buf []byte) (offset int) { + if x.Int32 == 0 { + return offset + } + offset += fastpb.WriteInt32(buf[offset:], 4, x.GetInt32()) + return offset +} + +func (x *InnerBase2) fastWriteField5(buf []byte) (offset int) { + if x.Int64 == 0 { + return offset + } + offset += fastpb.WriteInt64(buf[offset:], 5, x.GetInt64()) + return offset +} + +func (x *InnerBase2) fastWriteField6(buf []byte) (offset int) { + if x.Double == 0 { + return offset + } + offset += fastpb.WriteDouble(buf[offset:], 6, x.GetDouble()) + return offset +} + +func (x *InnerBase2) fastWriteField7(buf []byte) (offset int) { + if x.String_ == "" { + return offset + } + offset += fastpb.WriteString(buf[offset:], 7, x.GetString_()) + return offset +} + +func (x *InnerBase2) fastWriteField8(buf []byte) (offset int) { + if len(x.ListInt32) == 0 { + return offset + } + offset += fastpb.WriteListPacked(buf[offset:], 8, len(x.GetListInt32()), + func(buf []byte, numTagOrKey, numIdxOrVal int32) int { + offset := 0 + offset += fastpb.WriteInt32(buf[offset:], numTagOrKey, x.GetListInt32()[numIdxOrVal]) + return offset + }) + return offset +} + +func (x *InnerBase2) fastWriteField9(buf []byte) (offset int) { + if x.MapStringString == nil { + return offset + } + for k, v := range x.GetMapStringString() { + offset += fastpb.WriteMapEntry(buf[offset:], 9, + func(buf []byte, numTagOrKey, numIdxOrVal int32) int { + offset := 0 + offset += fastpb.WriteString(buf[offset:], numTagOrKey, k) + offset += fastpb.WriteString(buf[offset:], numIdxOrVal, v) + return offset + }) + } + return offset +} + +func (x *InnerBase2) fastWriteField10(buf []byte) (offset int) { + if len(x.SetInt32) == 0 { + return offset + } + offset += fastpb.WriteListPacked(buf[offset:], 10, len(x.GetSetInt32()), + func(buf []byte, numTagOrKey, numIdxOrVal int32) int { + offset := 0 + offset += fastpb.WriteInt32(buf[offset:], numTagOrKey, x.GetSetInt32()[numIdxOrVal]) + return offset + }) + return offset +} + +func (x *InnerBase2) fastWriteField11(buf []byte) (offset int) { + if x.Foo == 0 { + return offset + } + offset += fastpb.WriteInt32(buf[offset:], 11, int32(x.GetFoo())) + return offset +} + +func (x *InnerBase2) fastWriteField12(buf []byte) (offset int) { + if x.MapInt32String == nil { + return offset + } + for k, v := range x.GetMapInt32String() { + offset += fastpb.WriteMapEntry(buf[offset:], 12, + func(buf []byte, numTagOrKey, numIdxOrVal int32) int { + offset := 0 + offset += fastpb.WriteInt32(buf[offset:], numTagOrKey, k) + offset += fastpb.WriteString(buf[offset:], numIdxOrVal, v) + return offset + }) + } + return offset +} + +func (x *InnerBase2) fastWriteField13(buf []byte) (offset int) { + if len(x.Binary) == 0 { + return offset + } + offset += fastpb.WriteBytes(buf[offset:], 13, x.GetBinary()) + return offset +} + +func (x *InnerBase2) fastWriteField14(buf []byte) (offset int) { + if x.MapUint32String == nil { + return offset + } + for k, v := range x.GetMapUint32String() { + offset += fastpb.WriteMapEntry(buf[offset:], 14, + func(buf []byte, numTagOrKey, numIdxOrVal int32) int { + offset := 0 + offset += fastpb.WriteUint32(buf[offset:], numTagOrKey, k) + offset += fastpb.WriteString(buf[offset:], numIdxOrVal, v) + return offset + }) + } + return offset +} + +func (x *InnerBase2) fastWriteField15(buf []byte) (offset int) { + if x.MapUint64String == nil { + return offset + } + for k, v := range x.GetMapUint64String() { + offset += fastpb.WriteMapEntry(buf[offset:], 15, + func(buf []byte, numTagOrKey, numIdxOrVal int32) int { + offset := 0 + offset += fastpb.WriteUint64(buf[offset:], numTagOrKey, k) + offset += fastpb.WriteString(buf[offset:], numIdxOrVal, v) + return offset + }) + } + return offset +} + +func (x *InnerBase2) fastWriteField16(buf []byte) (offset int) { + if x.MapInt64String == nil { + return offset + } + for k, v := range x.GetMapInt64String() { + offset += fastpb.WriteMapEntry(buf[offset:], 16, + func(buf []byte, numTagOrKey, numIdxOrVal int32) int { + offset := 0 + offset += fastpb.WriteInt64(buf[offset:], numTagOrKey, k) + offset += fastpb.WriteString(buf[offset:], numIdxOrVal, v) + return offset + }) + } + return offset +} + +func (x *InnerBase2) fastWriteField17(buf []byte) (offset int) { + if x.MapInt64Base == nil { + return offset + } + for k, v := range x.GetMapInt64Base() { + offset += fastpb.WriteMapEntry(buf[offset:], 17, + func(buf []byte, numTagOrKey, numIdxOrVal int32) int { + offset := 0 + offset += fastpb.WriteInt64(buf[offset:], numTagOrKey, k) + offset += fastpb.WriteMessage(buf[offset:], numIdxOrVal, v) + return offset + }) + } + return offset +} + +func (x *InnerBase2) fastWriteField18(buf []byte) (offset int) { + if x.ListInnerBase == nil { + return offset + } + for i := range x.GetListInnerBase() { + offset += fastpb.WriteMessage(buf[offset:], 18, x.GetListInnerBase()[i]) + } + return offset +} + +func (x *InnerBase2) fastWriteField19(buf []byte) (offset int) { + if x.ListBase == nil { + return offset + } + for i := range x.GetListBase() { + offset += fastpb.WriteMessage(buf[offset:], 19, x.GetListBase()[i]) + } + return offset +} + +func (x *InnerBase2) fastWriteField20(buf []byte) (offset int) { + if x.MapStringBase == nil { + return offset + } + for k, v := range x.GetMapStringBase() { + offset += fastpb.WriteMapEntry(buf[offset:], 20, + func(buf []byte, numTagOrKey, numIdxOrVal int32) int { + offset := 0 + offset += fastpb.WriteString(buf[offset:], numTagOrKey, k) + offset += fastpb.WriteMessage(buf[offset:], numIdxOrVal, v) + return offset + }) + } + return offset +} + +func (x *InnerBase2) fastWriteField21(buf []byte) (offset int) { + if len(x.ListString) == 0 { + return offset + } + for i := range x.GetListString() { + offset += fastpb.WriteString(buf[offset:], 21, x.GetListString()[i]) + } + return offset +} + +func (x *InnerBase2) fastWriteField22(buf []byte) (offset int) { + if x.Sfixed32 == 0 { + return offset + } + offset += fastpb.WriteSfixed32(buf[offset:], 22, x.GetSfixed32()) + return offset +} + +func (x *InnerBase2) fastWriteField23(buf []byte) (offset int) { + if x.Fixed64 == 0 { + return offset + } + offset += fastpb.WriteFixed64(buf[offset:], 23, x.GetFixed64()) + return offset +} + +func (x *InnerBase2) fastWriteField24(buf []byte) (offset int) { + if x.Sint32 == 0 { + return offset + } + offset += fastpb.WriteSint32(buf[offset:], 24, x.GetSint32()) + return offset +} + +func (x *InnerBase2) fastWriteField25(buf []byte) (offset int) { + if x.Sint64 == 0 { + return offset + } + offset += fastpb.WriteSint64(buf[offset:], 25, x.GetSint64()) + return offset +} + +func (x *InnerBase2) fastWriteField26(buf []byte) (offset int) { + if len(x.ListSInt64) == 0 { + return offset + } + offset += fastpb.WriteListPacked(buf[offset:], 26, len(x.GetListSInt64()), + func(buf []byte, numTagOrKey, numIdxOrVal int32) int { + offset := 0 + offset += fastpb.WriteSint64(buf[offset:], numTagOrKey, x.GetListSInt64()[numIdxOrVal]) + return offset + }) + return offset +} + +func (x *InnerBase2) fastWriteField27(buf []byte) (offset int) { + if len(x.ListSInt32) == 0 { + return offset + } + offset += fastpb.WriteListPacked(buf[offset:], 27, len(x.GetListSInt32()), + func(buf []byte, numTagOrKey, numIdxOrVal int32) int { + offset := 0 + offset += fastpb.WriteSint32(buf[offset:], numTagOrKey, x.GetListSInt32()[numIdxOrVal]) + return offset + }) + return offset +} + +func (x *InnerBase2) fastWriteField28(buf []byte) (offset int) { + if len(x.ListSfixed32) == 0 { + return offset + } + offset += fastpb.WriteListPacked(buf[offset:], 28, len(x.GetListSfixed32()), + func(buf []byte, numTagOrKey, numIdxOrVal int32) int { + offset := 0 + offset += fastpb.WriteSfixed32(buf[offset:], numTagOrKey, x.GetListSfixed32()[numIdxOrVal]) + return offset + }) + return offset +} + +func (x *InnerBase2) fastWriteField29(buf []byte) (offset int) { + if len(x.ListFixed64) == 0 { + return offset + } + offset += fastpb.WriteListPacked(buf[offset:], 29, len(x.GetListFixed64()), + func(buf []byte, numTagOrKey, numIdxOrVal int32) int { + offset := 0 + offset += fastpb.WriteFixed64(buf[offset:], numTagOrKey, x.GetListFixed64()[numIdxOrVal]) + return offset + }) + return offset +} + +func (x *InnerBase2) fastWriteField30(buf []byte) (offset int) { + if x.MapInt64Sfixed64 == nil { + return offset + } + for k, v := range x.GetMapInt64Sfixed64() { + offset += fastpb.WriteMapEntry(buf[offset:], 30, + func(buf []byte, numTagOrKey, numIdxOrVal int32) int { + offset := 0 + offset += fastpb.WriteInt64(buf[offset:], numTagOrKey, k) + offset += fastpb.WriteSfixed64(buf[offset:], numIdxOrVal, v) + return offset + }) + } + return offset +} + +func (x *InnerBase2) fastWriteField31(buf []byte) (offset int) { + if x.MapStringFixed32 == nil { + return offset + } + for k, v := range x.GetMapStringFixed32() { + offset += fastpb.WriteMapEntry(buf[offset:], 31, + func(buf []byte, numTagOrKey, numIdxOrVal int32) int { + offset := 0 + offset += fastpb.WriteString(buf[offset:], numTagOrKey, k) + offset += fastpb.WriteFixed32(buf[offset:], numIdxOrVal, v) + return offset + }) + } + return offset +} + +func (x *InnerBase2) fastWriteField255(buf []byte) (offset int) { + if x.Base == nil { + return offset + } + offset += fastpb.WriteMessage(buf[offset:], 255, x.GetBase()) + return offset +} + +func (x *InnerBasePartial) FastWrite(buf []byte) (offset int) { + if x == nil { + return offset + } + offset += x.fastWriteField1(buf[offset:]) + offset += x.fastWriteField8(buf[offset:]) + offset += x.fastWriteField9(buf[offset:]) + offset += x.fastWriteField18(buf[offset:]) + offset += x.fastWriteField19(buf[offset:]) + offset += x.fastWriteField20(buf[offset:]) + offset += x.fastWriteField127(buf[offset:]) + return offset +} + +func (x *InnerBasePartial) fastWriteField1(buf []byte) (offset int) { + if !x.Bool { + return offset + } + offset += fastpb.WriteBool(buf[offset:], 1, x.GetBool()) + return offset +} + +func (x *InnerBasePartial) fastWriteField8(buf []byte) (offset int) { + if len(x.ListInt32) == 0 { + return offset + } + offset += fastpb.WriteListPacked(buf[offset:], 8, len(x.GetListInt32()), + func(buf []byte, numTagOrKey, numIdxOrVal int32) int { + offset := 0 + offset += fastpb.WriteInt32(buf[offset:], numTagOrKey, x.GetListInt32()[numIdxOrVal]) + return offset + }) + return offset +} + +func (x *InnerBasePartial) fastWriteField9(buf []byte) (offset int) { + if x.MapStringString == nil { + return offset + } + for k, v := range x.GetMapStringString() { + offset += fastpb.WriteMapEntry(buf[offset:], 9, + func(buf []byte, numTagOrKey, numIdxOrVal int32) int { + offset := 0 + offset += fastpb.WriteString(buf[offset:], numTagOrKey, k) + offset += fastpb.WriteString(buf[offset:], numIdxOrVal, v) + return offset + }) + } + return offset +} + +func (x *InnerBasePartial) fastWriteField18(buf []byte) (offset int) { + if x.ListInnerBase == nil { + return offset + } + for i := range x.GetListInnerBase() { + offset += fastpb.WriteMessage(buf[offset:], 18, x.GetListInnerBase()[i]) + } + return offset +} + +func (x *InnerBasePartial) fastWriteField19(buf []byte) (offset int) { + if x.ListBase == nil { + return offset + } + for i := range x.GetListBase() { + offset += fastpb.WriteMessage(buf[offset:], 19, x.GetListBase()[i]) + } + return offset +} + +func (x *InnerBasePartial) fastWriteField20(buf []byte) (offset int) { + if x.MapStringBase == nil { + return offset + } + for k, v := range x.GetMapStringBase() { + offset += fastpb.WriteMapEntry(buf[offset:], 20, + func(buf []byte, numTagOrKey, numIdxOrVal int32) int { + offset := 0 + offset += fastpb.WriteString(buf[offset:], numTagOrKey, k) + offset += fastpb.WriteMessage(buf[offset:], numIdxOrVal, v) + return offset + }) + } + return offset +} + +func (x *InnerBasePartial) fastWriteField127(buf []byte) (offset int) { + if x.MapStringString2 == nil { + return offset + } + for k, v := range x.GetMapStringString2() { + offset += fastpb.WriteMapEntry(buf[offset:], 127, + func(buf []byte, numTagOrKey, numIdxOrVal int32) int { + offset := 0 + offset += fastpb.WriteString(buf[offset:], numTagOrKey, k) + offset += fastpb.WriteString(buf[offset:], numIdxOrVal, v) + return offset + }) + } + return offset +} + +func (x *BasePartial) FastWrite(buf []byte) (offset int) { + if x == nil { + return offset + } + offset += x.fastWriteField5(buf[offset:]) + return offset +} + +func (x *BasePartial) fastWriteField5(buf []byte) (offset int) { + if x.TrafficEnv == nil { + return offset + } + offset += fastpb.WriteMessage(buf[offset:], 5, x.GetTrafficEnv()) + return offset +} + +func (x *ExampleReq) FastWrite(buf []byte) (offset int) { + if x == nil { + return offset + } + offset += x.fastWriteField1(buf[offset:]) + offset += x.fastWriteField2(buf[offset:]) + offset += x.fastWriteField3(buf[offset:]) + offset += x.fastWriteField255(buf[offset:]) + offset += x.fastWriteField32767(buf[offset:]) + return offset +} + +func (x *ExampleReq) fastWriteField1(buf []byte) (offset int) { + if x.Msg == "" { + return offset + } + offset += fastpb.WriteString(buf[offset:], 1, x.GetMsg()) + return offset +} + +func (x *ExampleReq) fastWriteField2(buf []byte) (offset int) { + if x.A == 0 { + return offset + } + offset += fastpb.WriteInt32(buf[offset:], 2, x.GetA()) + return offset +} + +func (x *ExampleReq) fastWriteField3(buf []byte) (offset int) { + if x.InnerBase2 == nil { + return offset + } + offset += fastpb.WriteMessage(buf[offset:], 3, x.GetInnerBase2()) + return offset +} + +func (x *ExampleReq) fastWriteField255(buf []byte) (offset int) { + if x.Base == nil { + return offset + } + offset += fastpb.WriteMessage(buf[offset:], 255, x.GetBase()) + return offset +} + +func (x *ExampleReq) fastWriteField32767(buf []byte) (offset int) { + if x.Subfix == 0 { + return offset + } + offset += fastpb.WriteDouble(buf[offset:], 32767, x.GetSubfix()) + return offset +} + +func (x *ExampleSuper) FastWrite(buf []byte) (offset int) { + if x == nil { + return offset + } + offset += x.fastWriteField1(buf[offset:]) + offset += x.fastWriteField2(buf[offset:]) + offset += x.fastWriteField3(buf[offset:]) + offset += x.fastWriteField4(buf[offset:]) + offset += x.fastWriteField5(buf[offset:]) + offset += x.fastWriteField6(buf[offset:]) + offset += x.fastWriteField7(buf[offset:]) + offset += x.fastWriteField9(buf[offset:]) + offset += x.fastWriteField255(buf[offset:]) + offset += x.fastWriteField32767(buf[offset:]) + return offset +} + +func (x *ExampleSuper) fastWriteField1(buf []byte) (offset int) { + if x.Msg == "" { + return offset + } + offset += fastpb.WriteString(buf[offset:], 1, x.GetMsg()) + return offset +} + +func (x *ExampleSuper) fastWriteField2(buf []byte) (offset int) { + if x.A == 0 { + return offset + } + offset += fastpb.WriteInt32(buf[offset:], 2, x.GetA()) + return offset +} + +func (x *ExampleSuper) fastWriteField3(buf []byte) (offset int) { + if x.InnerBase2 == nil { + return offset + } + offset += fastpb.WriteMessage(buf[offset:], 3, x.GetInnerBase2()) + return offset +} + +func (x *ExampleSuper) fastWriteField4(buf []byte) (offset int) { + if x.Ex1 == "" { + return offset + } + offset += fastpb.WriteString(buf[offset:], 4, x.GetEx1()) + return offset +} + +func (x *ExampleSuper) fastWriteField5(buf []byte) (offset int) { + if x.Ex2 == "" { + return offset + } + offset += fastpb.WriteString(buf[offset:], 5, x.GetEx2()) + return offset +} + +func (x *ExampleSuper) fastWriteField6(buf []byte) (offset int) { + if x.Ex3 == "" { + return offset + } + offset += fastpb.WriteString(buf[offset:], 6, x.GetEx3()) + return offset +} + +func (x *ExampleSuper) fastWriteField7(buf []byte) (offset int) { + if x.Ex4 == "" { + return offset + } + offset += fastpb.WriteString(buf[offset:], 7, x.GetEx4()) + return offset +} + +func (x *ExampleSuper) fastWriteField9(buf []byte) (offset int) { + if x.SelfRef == nil { + return offset + } + offset += fastpb.WriteMessage(buf[offset:], 9, x.GetSelfRef()) + return offset +} + +func (x *ExampleSuper) fastWriteField255(buf []byte) (offset int) { + if x.Base == nil { + return offset + } + offset += fastpb.WriteMessage(buf[offset:], 255, x.GetBase()) + return offset +} + +func (x *ExampleSuper) fastWriteField32767(buf []byte) (offset int) { + if x.Subfix == 0 { + return offset + } + offset += fastpb.WriteDouble(buf[offset:], 32767, x.GetSubfix()) + return offset +} + +func (x *SelfRef) FastWrite(buf []byte) (offset int) { + if x == nil { + return offset + } + offset += x.fastWriteField1(buf[offset:]) + return offset +} + +func (x *SelfRef) fastWriteField1(buf []byte) (offset int) { + if x.Self == nil { + return offset + } + offset += fastpb.WriteMessage(buf[offset:], 1, x.GetSelf()) + return offset +} + +func (x *ExampleReqPartial) FastWrite(buf []byte) (offset int) { + if x == nil { + return offset + } + offset += x.fastWriteField1(buf[offset:]) + offset += x.fastWriteField3(buf[offset:]) + offset += x.fastWriteField255(buf[offset:]) + return offset +} + +func (x *ExampleReqPartial) fastWriteField1(buf []byte) (offset int) { + if x.Msg == "" { + return offset + } + offset += fastpb.WriteString(buf[offset:], 1, x.GetMsg()) + return offset +} + +func (x *ExampleReqPartial) fastWriteField3(buf []byte) (offset int) { + if x.InnerBase2 == nil { + return offset + } + offset += fastpb.WriteMessage(buf[offset:], 3, x.GetInnerBase2()) + return offset +} + +func (x *ExampleReqPartial) fastWriteField255(buf []byte) (offset int) { + if x.Base == nil { + return offset + } + offset += fastpb.WriteMessage(buf[offset:], 255, x.GetBase()) + return offset +} + +func (x *ExampleResp) FastWrite(buf []byte) (offset int) { + if x == nil { + return offset + } + offset += x.fastWriteField1(buf[offset:]) + offset += x.fastWriteField2(buf[offset:]) + offset += x.fastWriteField255(buf[offset:]) + return offset +} + +func (x *ExampleResp) fastWriteField1(buf []byte) (offset int) { + if x.Msg == "" { + return offset + } + offset += fastpb.WriteString(buf[offset:], 1, x.GetMsg()) + return offset +} + +func (x *ExampleResp) fastWriteField2(buf []byte) (offset int) { + if x.RequiredField == "" { + return offset + } + offset += fastpb.WriteString(buf[offset:], 2, x.GetRequiredField()) + return offset +} + +func (x *ExampleResp) fastWriteField255(buf []byte) (offset int) { + if x.BaseResp == nil { + return offset + } + offset += fastpb.WriteMessage(buf[offset:], 255, x.GetBaseResp()) + return offset +} + +func (x *ExampleRespPartial) FastWrite(buf []byte) (offset int) { + if x == nil { + return offset + } + offset += x.fastWriteField2(buf[offset:]) + offset += x.fastWriteField255(buf[offset:]) + return offset +} + +func (x *ExampleRespPartial) fastWriteField2(buf []byte) (offset int) { + if x.RequiredField == "" { + return offset + } + offset += fastpb.WriteString(buf[offset:], 2, x.GetRequiredField()) + return offset +} + +func (x *ExampleRespPartial) fastWriteField255(buf []byte) (offset int) { + if x.BaseResp == nil { + return offset + } + offset += fastpb.WriteMessage(buf[offset:], 255, x.GetBaseResp()) + return offset +} + +func (x *Exception) FastWrite(buf []byte) (offset int) { + if x == nil { + return offset + } + offset += x.fastWriteField1(buf[offset:]) + offset += x.fastWriteField255(buf[offset:]) + return offset +} + +func (x *Exception) fastWriteField1(buf []byte) (offset int) { + if x.Code == 0 { + return offset + } + offset += fastpb.WriteInt32(buf[offset:], 1, x.GetCode()) + return offset +} + +func (x *Exception) fastWriteField255(buf []byte) (offset int) { + if x.Msg == "" { + return offset + } + offset += fastpb.WriteString(buf[offset:], 255, x.GetMsg()) + return offset +} + +func (x *A) FastWrite(buf []byte) (offset int) { + if x == nil { + return offset + } + offset += x.fastWriteField1(buf[offset:]) + return offset +} + +func (x *A) fastWriteField1(buf []byte) (offset int) { + if x.Self == nil { + return offset + } + offset += fastpb.WriteMessage(buf[offset:], 1, x.GetSelf()) + return offset +} + +func (x *PingResponse) FastWrite(buf []byte) (offset int) { + if x == nil { + return offset + } + offset += x.fastWriteField1(buf[offset:]) + return offset +} + +func (x *PingResponse) fastWriteField1(buf []byte) (offset int) { + if x.Message == "" { + return offset + } + offset += fastpb.WriteString(buf[offset:], 1, x.GetMessage()) + return offset +} + +func (x *OnewayRequest) FastWrite(buf []byte) (offset int) { + if x == nil { + return offset + } + offset += x.fastWriteField1(buf[offset:]) + return offset +} + +func (x *OnewayRequest) fastWriteField1(buf []byte) (offset int) { + if x.Msg == "" { + return offset + } + offset += fastpb.WriteString(buf[offset:], 1, x.GetMsg()) + return offset +} + +func (x *VoidRequest) FastWrite(buf []byte) (offset int) { + if x == nil { + return offset + } + offset += x.fastWriteField1(buf[offset:]) + return offset +} + +func (x *VoidRequest) fastWriteField1(buf []byte) (offset int) { + if x.Msg == "" { + return offset + } + offset += fastpb.WriteString(buf[offset:], 1, x.GetMsg()) + return offset +} + +func (x *VoidResponse) FastWrite(buf []byte) (offset int) { + if x == nil { + return offset + } + return offset +} + +func (x *ExampleInt2Float) FastWrite(buf []byte) (offset int) { + if x == nil { + return offset + } + offset += x.fastWriteField1(buf[offset:]) + offset += x.fastWriteField2(buf[offset:]) + offset += x.fastWriteField3(buf[offset:]) + offset += x.fastWriteField4(buf[offset:]) + offset += x.fastWriteField32767(buf[offset:]) + return offset +} + +func (x *ExampleInt2Float) fastWriteField1(buf []byte) (offset int) { + if x.Int32 == 0 { + return offset + } + offset += fastpb.WriteInt32(buf[offset:], 1, x.GetInt32()) + return offset +} + +func (x *ExampleInt2Float) fastWriteField2(buf []byte) (offset int) { + if x.Float64 == 0 { + return offset + } + offset += fastpb.WriteDouble(buf[offset:], 2, x.GetFloat64()) + return offset +} + +func (x *ExampleInt2Float) fastWriteField3(buf []byte) (offset int) { + if x.String_ == "" { + return offset + } + offset += fastpb.WriteString(buf[offset:], 3, x.GetString_()) + return offset +} + +func (x *ExampleInt2Float) fastWriteField4(buf []byte) (offset int) { + if x.Int64 == 0 { + return offset + } + offset += fastpb.WriteInt64(buf[offset:], 4, x.GetInt64()) + return offset +} + +func (x *ExampleInt2Float) fastWriteField32767(buf []byte) (offset int) { + if x.Subfix == 0 { + return offset + } + offset += fastpb.WriteDouble(buf[offset:], 32767, x.GetSubfix()) + return offset +} + +func (x *InnerBase2) Size() (n int) { + if x == nil { + return n + } + n += x.sizeField1() + n += x.sizeField2() + n += x.sizeField3() + n += x.sizeField4() + n += x.sizeField5() + n += x.sizeField6() + n += x.sizeField7() + n += x.sizeField8() + n += x.sizeField9() + n += x.sizeField10() + n += x.sizeField11() + n += x.sizeField12() + n += x.sizeField13() + n += x.sizeField14() + n += x.sizeField15() + n += x.sizeField16() + n += x.sizeField17() + n += x.sizeField18() + n += x.sizeField19() + n += x.sizeField20() + n += x.sizeField21() + n += x.sizeField22() + n += x.sizeField23() + n += x.sizeField24() + n += x.sizeField25() + n += x.sizeField26() + n += x.sizeField27() + n += x.sizeField28() + n += x.sizeField29() + n += x.sizeField30() + n += x.sizeField31() + n += x.sizeField255() + return n +} + +func (x *InnerBase2) sizeField1() (n int) { + if !x.Bool { + return n + } + n += fastpb.SizeBool(1, x.GetBool()) + return n +} + +func (x *InnerBase2) sizeField2() (n int) { + if x.Uint32 == 0 { + return n + } + n += fastpb.SizeUint32(2, x.GetUint32()) + return n +} + +func (x *InnerBase2) sizeField3() (n int) { + if x.Uint64 == 0 { + return n + } + n += fastpb.SizeUint64(3, x.GetUint64()) + return n +} + +func (x *InnerBase2) sizeField4() (n int) { + if x.Int32 == 0 { + return n + } + n += fastpb.SizeInt32(4, x.GetInt32()) + return n +} + +func (x *InnerBase2) sizeField5() (n int) { + if x.Int64 == 0 { + return n + } + n += fastpb.SizeInt64(5, x.GetInt64()) + return n +} + +func (x *InnerBase2) sizeField6() (n int) { + if x.Double == 0 { + return n + } + n += fastpb.SizeDouble(6, x.GetDouble()) + return n +} + +func (x *InnerBase2) sizeField7() (n int) { + if x.String_ == "" { + return n + } + n += fastpb.SizeString(7, x.GetString_()) + return n +} + +func (x *InnerBase2) sizeField8() (n int) { + if len(x.ListInt32) == 0 { + return n + } + n += fastpb.SizeListPacked(8, len(x.GetListInt32()), + func(numTagOrKey, numIdxOrVal int32) int { + n := 0 + n += fastpb.SizeInt32(numTagOrKey, x.GetListInt32()[numIdxOrVal]) + return n + }) + return n +} + +func (x *InnerBase2) sizeField9() (n int) { + if x.MapStringString == nil { + return n + } + for k, v := range x.GetMapStringString() { + n += fastpb.SizeMapEntry(9, + func(numTagOrKey, numIdxOrVal int32) int { + n := 0 + n += fastpb.SizeString(numTagOrKey, k) + n += fastpb.SizeString(numIdxOrVal, v) + return n + }) + } + return n +} + +func (x *InnerBase2) sizeField10() (n int) { + if len(x.SetInt32) == 0 { + return n + } + n += fastpb.SizeListPacked(10, len(x.GetSetInt32()), + func(numTagOrKey, numIdxOrVal int32) int { + n := 0 + n += fastpb.SizeInt32(numTagOrKey, x.GetSetInt32()[numIdxOrVal]) + return n + }) + return n +} + +func (x *InnerBase2) sizeField11() (n int) { + if x.Foo == 0 { + return n + } + n += fastpb.SizeInt32(11, int32(x.GetFoo())) + return n +} + +func (x *InnerBase2) sizeField12() (n int) { + if x.MapInt32String == nil { + return n + } + for k, v := range x.GetMapInt32String() { + n += fastpb.SizeMapEntry(12, + func(numTagOrKey, numIdxOrVal int32) int { + n := 0 + n += fastpb.SizeInt32(numTagOrKey, k) + n += fastpb.SizeString(numIdxOrVal, v) + return n + }) + } + return n +} + +func (x *InnerBase2) sizeField13() (n int) { + if len(x.Binary) == 0 { + return n + } + n += fastpb.SizeBytes(13, x.GetBinary()) + return n +} + +func (x *InnerBase2) sizeField14() (n int) { + if x.MapUint32String == nil { + return n + } + for k, v := range x.GetMapUint32String() { + n += fastpb.SizeMapEntry(14, + func(numTagOrKey, numIdxOrVal int32) int { + n := 0 + n += fastpb.SizeUint32(numTagOrKey, k) + n += fastpb.SizeString(numIdxOrVal, v) + return n + }) + } + return n +} + +func (x *InnerBase2) sizeField15() (n int) { + if x.MapUint64String == nil { + return n + } + for k, v := range x.GetMapUint64String() { + n += fastpb.SizeMapEntry(15, + func(numTagOrKey, numIdxOrVal int32) int { + n := 0 + n += fastpb.SizeUint64(numTagOrKey, k) + n += fastpb.SizeString(numIdxOrVal, v) + return n + }) + } + return n +} + +func (x *InnerBase2) sizeField16() (n int) { + if x.MapInt64String == nil { + return n + } + for k, v := range x.GetMapInt64String() { + n += fastpb.SizeMapEntry(16, + func(numTagOrKey, numIdxOrVal int32) int { + n := 0 + n += fastpb.SizeInt64(numTagOrKey, k) + n += fastpb.SizeString(numIdxOrVal, v) + return n + }) + } + return n +} + +func (x *InnerBase2) sizeField17() (n int) { + if x.MapInt64Base == nil { + return n + } + for k, v := range x.GetMapInt64Base() { + n += fastpb.SizeMapEntry(17, + func(numTagOrKey, numIdxOrVal int32) int { + n := 0 + n += fastpb.SizeInt64(numTagOrKey, k) + n += fastpb.SizeMessage(numIdxOrVal, v) + return n + }) + } + return n +} + +func (x *InnerBase2) sizeField18() (n int) { + if x.ListInnerBase == nil { + return n + } + for i := range x.GetListInnerBase() { + n += fastpb.SizeMessage(18, x.GetListInnerBase()[i]) + } + return n +} + +func (x *InnerBase2) sizeField19() (n int) { + if x.ListBase == nil { + return n + } + for i := range x.GetListBase() { + n += fastpb.SizeMessage(19, x.GetListBase()[i]) + } + return n +} + +func (x *InnerBase2) sizeField20() (n int) { + if x.MapStringBase == nil { + return n + } + for k, v := range x.GetMapStringBase() { + n += fastpb.SizeMapEntry(20, + func(numTagOrKey, numIdxOrVal int32) int { + n := 0 + n += fastpb.SizeString(numTagOrKey, k) + n += fastpb.SizeMessage(numIdxOrVal, v) + return n + }) + } + return n +} + +func (x *InnerBase2) sizeField21() (n int) { + if len(x.ListString) == 0 { + return n + } + for i := range x.GetListString() { + n += fastpb.SizeString(21, x.GetListString()[i]) + } + return n +} + +func (x *InnerBase2) sizeField22() (n int) { + if x.Sfixed32 == 0 { + return n + } + n += fastpb.SizeSfixed32(22, x.GetSfixed32()) + return n +} + +func (x *InnerBase2) sizeField23() (n int) { + if x.Fixed64 == 0 { + return n + } + n += fastpb.SizeFixed64(23, x.GetFixed64()) + return n +} + +func (x *InnerBase2) sizeField24() (n int) { + if x.Sint32 == 0 { + return n + } + n += fastpb.SizeSint32(24, x.GetSint32()) + return n +} + +func (x *InnerBase2) sizeField25() (n int) { + if x.Sint64 == 0 { + return n + } + n += fastpb.SizeSint64(25, x.GetSint64()) + return n +} + +func (x *InnerBase2) sizeField26() (n int) { + if len(x.ListSInt64) == 0 { + return n + } + n += fastpb.SizeListPacked(26, len(x.GetListSInt64()), + func(numTagOrKey, numIdxOrVal int32) int { + n := 0 + n += fastpb.SizeSint64(numTagOrKey, x.GetListSInt64()[numIdxOrVal]) + return n + }) + return n +} + +func (x *InnerBase2) sizeField27() (n int) { + if len(x.ListSInt32) == 0 { + return n + } + n += fastpb.SizeListPacked(27, len(x.GetListSInt32()), + func(numTagOrKey, numIdxOrVal int32) int { + n := 0 + n += fastpb.SizeSint32(numTagOrKey, x.GetListSInt32()[numIdxOrVal]) + return n + }) + return n +} + +func (x *InnerBase2) sizeField28() (n int) { + if len(x.ListSfixed32) == 0 { + return n + } + n += fastpb.SizeListPacked(28, len(x.GetListSfixed32()), + func(numTagOrKey, numIdxOrVal int32) int { + n := 0 + n += fastpb.SizeSfixed32(numTagOrKey, x.GetListSfixed32()[numIdxOrVal]) + return n + }) + return n +} + +func (x *InnerBase2) sizeField29() (n int) { + if len(x.ListFixed64) == 0 { + return n + } + n += fastpb.SizeListPacked(29, len(x.GetListFixed64()), + func(numTagOrKey, numIdxOrVal int32) int { + n := 0 + n += fastpb.SizeFixed64(numTagOrKey, x.GetListFixed64()[numIdxOrVal]) + return n + }) + return n +} + +func (x *InnerBase2) sizeField30() (n int) { + if x.MapInt64Sfixed64 == nil { + return n + } + for k, v := range x.GetMapInt64Sfixed64() { + n += fastpb.SizeMapEntry(30, + func(numTagOrKey, numIdxOrVal int32) int { + n := 0 + n += fastpb.SizeInt64(numTagOrKey, k) + n += fastpb.SizeSfixed64(numIdxOrVal, v) + return n + }) + } + return n +} + +func (x *InnerBase2) sizeField31() (n int) { + if x.MapStringFixed32 == nil { + return n + } + for k, v := range x.GetMapStringFixed32() { + n += fastpb.SizeMapEntry(31, + func(numTagOrKey, numIdxOrVal int32) int { + n := 0 + n += fastpb.SizeString(numTagOrKey, k) + n += fastpb.SizeFixed32(numIdxOrVal, v) + return n + }) + } + return n +} + +func (x *InnerBase2) sizeField255() (n int) { + if x.Base == nil { + return n + } + n += fastpb.SizeMessage(255, x.GetBase()) + return n +} + +func (x *InnerBasePartial) Size() (n int) { + if x == nil { + return n + } + n += x.sizeField1() + n += x.sizeField8() + n += x.sizeField9() + n += x.sizeField18() + n += x.sizeField19() + n += x.sizeField20() + n += x.sizeField127() + return n +} + +func (x *InnerBasePartial) sizeField1() (n int) { + if !x.Bool { + return n + } + n += fastpb.SizeBool(1, x.GetBool()) + return n +} + +func (x *InnerBasePartial) sizeField8() (n int) { + if len(x.ListInt32) == 0 { + return n + } + n += fastpb.SizeListPacked(8, len(x.GetListInt32()), + func(numTagOrKey, numIdxOrVal int32) int { + n := 0 + n += fastpb.SizeInt32(numTagOrKey, x.GetListInt32()[numIdxOrVal]) + return n + }) + return n +} + +func (x *InnerBasePartial) sizeField9() (n int) { + if x.MapStringString == nil { + return n + } + for k, v := range x.GetMapStringString() { + n += fastpb.SizeMapEntry(9, + func(numTagOrKey, numIdxOrVal int32) int { + n := 0 + n += fastpb.SizeString(numTagOrKey, k) + n += fastpb.SizeString(numIdxOrVal, v) + return n + }) + } + return n +} + +func (x *InnerBasePartial) sizeField18() (n int) { + if x.ListInnerBase == nil { + return n + } + for i := range x.GetListInnerBase() { + n += fastpb.SizeMessage(18, x.GetListInnerBase()[i]) + } + return n +} + +func (x *InnerBasePartial) sizeField19() (n int) { + if x.ListBase == nil { + return n + } + for i := range x.GetListBase() { + n += fastpb.SizeMessage(19, x.GetListBase()[i]) + } + return n +} + +func (x *InnerBasePartial) sizeField20() (n int) { + if x.MapStringBase == nil { + return n + } + for k, v := range x.GetMapStringBase() { + n += fastpb.SizeMapEntry(20, + func(numTagOrKey, numIdxOrVal int32) int { + n := 0 + n += fastpb.SizeString(numTagOrKey, k) + n += fastpb.SizeMessage(numIdxOrVal, v) + return n + }) + } + return n +} + +func (x *InnerBasePartial) sizeField127() (n int) { + if x.MapStringString2 == nil { + return n + } + for k, v := range x.GetMapStringString2() { + n += fastpb.SizeMapEntry(127, + func(numTagOrKey, numIdxOrVal int32) int { + n := 0 + n += fastpb.SizeString(numTagOrKey, k) + n += fastpb.SizeString(numIdxOrVal, v) + return n + }) + } + return n +} + +func (x *BasePartial) Size() (n int) { + if x == nil { + return n + } + n += x.sizeField5() + return n +} + +func (x *BasePartial) sizeField5() (n int) { + if x.TrafficEnv == nil { + return n + } + n += fastpb.SizeMessage(5, x.GetTrafficEnv()) + return n +} + +func (x *ExampleReq) Size() (n int) { + if x == nil { + return n + } + n += x.sizeField1() + n += x.sizeField2() + n += x.sizeField3() + n += x.sizeField255() + n += x.sizeField32767() + return n +} + +func (x *ExampleReq) sizeField1() (n int) { + if x.Msg == "" { + return n + } + n += fastpb.SizeString(1, x.GetMsg()) + return n +} + +func (x *ExampleReq) sizeField2() (n int) { + if x.A == 0 { + return n + } + n += fastpb.SizeInt32(2, x.GetA()) + return n +} + +func (x *ExampleReq) sizeField3() (n int) { + if x.InnerBase2 == nil { + return n + } + n += fastpb.SizeMessage(3, x.GetInnerBase2()) + return n +} + +func (x *ExampleReq) sizeField255() (n int) { + if x.Base == nil { + return n + } + n += fastpb.SizeMessage(255, x.GetBase()) + return n +} + +func (x *ExampleReq) sizeField32767() (n int) { + if x.Subfix == 0 { + return n + } + n += fastpb.SizeDouble(32767, x.GetSubfix()) + return n +} + +func (x *ExampleSuper) Size() (n int) { + if x == nil { + return n + } + n += x.sizeField1() + n += x.sizeField2() + n += x.sizeField3() + n += x.sizeField4() + n += x.sizeField5() + n += x.sizeField6() + n += x.sizeField7() + n += x.sizeField9() + n += x.sizeField255() + n += x.sizeField32767() + return n +} + +func (x *ExampleSuper) sizeField1() (n int) { + if x.Msg == "" { + return n + } + n += fastpb.SizeString(1, x.GetMsg()) + return n +} + +func (x *ExampleSuper) sizeField2() (n int) { + if x.A == 0 { + return n + } + n += fastpb.SizeInt32(2, x.GetA()) + return n +} + +func (x *ExampleSuper) sizeField3() (n int) { + if x.InnerBase2 == nil { + return n + } + n += fastpb.SizeMessage(3, x.GetInnerBase2()) + return n +} + +func (x *ExampleSuper) sizeField4() (n int) { + if x.Ex1 == "" { + return n + } + n += fastpb.SizeString(4, x.GetEx1()) + return n +} + +func (x *ExampleSuper) sizeField5() (n int) { + if x.Ex2 == "" { + return n + } + n += fastpb.SizeString(5, x.GetEx2()) + return n +} + +func (x *ExampleSuper) sizeField6() (n int) { + if x.Ex3 == "" { + return n + } + n += fastpb.SizeString(6, x.GetEx3()) + return n +} + +func (x *ExampleSuper) sizeField7() (n int) { + if x.Ex4 == "" { + return n + } + n += fastpb.SizeString(7, x.GetEx4()) + return n +} + +func (x *ExampleSuper) sizeField9() (n int) { + if x.SelfRef == nil { + return n + } + n += fastpb.SizeMessage(9, x.GetSelfRef()) + return n +} + +func (x *ExampleSuper) sizeField255() (n int) { + if x.Base == nil { + return n + } + n += fastpb.SizeMessage(255, x.GetBase()) + return n +} + +func (x *ExampleSuper) sizeField32767() (n int) { + if x.Subfix == 0 { + return n + } + n += fastpb.SizeDouble(32767, x.GetSubfix()) + return n +} + +func (x *SelfRef) Size() (n int) { + if x == nil { + return n + } + n += x.sizeField1() + return n +} + +func (x *SelfRef) sizeField1() (n int) { + if x.Self == nil { + return n + } + n += fastpb.SizeMessage(1, x.GetSelf()) + return n +} + +func (x *ExampleReqPartial) Size() (n int) { + if x == nil { + return n + } + n += x.sizeField1() + n += x.sizeField3() + n += x.sizeField255() + return n +} + +func (x *ExampleReqPartial) sizeField1() (n int) { + if x.Msg == "" { + return n + } + n += fastpb.SizeString(1, x.GetMsg()) + return n +} + +func (x *ExampleReqPartial) sizeField3() (n int) { + if x.InnerBase2 == nil { + return n + } + n += fastpb.SizeMessage(3, x.GetInnerBase2()) + return n +} + +func (x *ExampleReqPartial) sizeField255() (n int) { + if x.Base == nil { + return n + } + n += fastpb.SizeMessage(255, x.GetBase()) + return n +} + +func (x *ExampleResp) Size() (n int) { + if x == nil { + return n + } + n += x.sizeField1() + n += x.sizeField2() + n += x.sizeField255() + return n +} + +func (x *ExampleResp) sizeField1() (n int) { + if x.Msg == "" { + return n + } + n += fastpb.SizeString(1, x.GetMsg()) + return n +} + +func (x *ExampleResp) sizeField2() (n int) { + if x.RequiredField == "" { + return n + } + n += fastpb.SizeString(2, x.GetRequiredField()) + return n +} + +func (x *ExampleResp) sizeField255() (n int) { + if x.BaseResp == nil { + return n + } + n += fastpb.SizeMessage(255, x.GetBaseResp()) + return n +} + +func (x *ExampleRespPartial) Size() (n int) { + if x == nil { + return n + } + n += x.sizeField2() + n += x.sizeField255() + return n +} + +func (x *ExampleRespPartial) sizeField2() (n int) { + if x.RequiredField == "" { + return n + } + n += fastpb.SizeString(2, x.GetRequiredField()) + return n +} + +func (x *ExampleRespPartial) sizeField255() (n int) { + if x.BaseResp == nil { + return n + } + n += fastpb.SizeMessage(255, x.GetBaseResp()) + return n +} + +func (x *Exception) Size() (n int) { + if x == nil { + return n + } + n += x.sizeField1() + n += x.sizeField255() + return n +} + +func (x *Exception) sizeField1() (n int) { + if x.Code == 0 { + return n + } + n += fastpb.SizeInt32(1, x.GetCode()) + return n +} + +func (x *Exception) sizeField255() (n int) { + if x.Msg == "" { + return n + } + n += fastpb.SizeString(255, x.GetMsg()) + return n +} + +func (x *A) Size() (n int) { + if x == nil { + return n + } + n += x.sizeField1() + return n +} + +func (x *A) sizeField1() (n int) { + if x.Self == nil { + return n + } + n += fastpb.SizeMessage(1, x.GetSelf()) + return n +} + +func (x *PingResponse) Size() (n int) { + if x == nil { + return n + } + n += x.sizeField1() + return n +} + +func (x *PingResponse) sizeField1() (n int) { + if x.Message == "" { + return n + } + n += fastpb.SizeString(1, x.GetMessage()) + return n +} + +func (x *OnewayRequest) Size() (n int) { + if x == nil { + return n + } + n += x.sizeField1() + return n +} + +func (x *OnewayRequest) sizeField1() (n int) { + if x.Msg == "" { + return n + } + n += fastpb.SizeString(1, x.GetMsg()) + return n +} + +func (x *VoidRequest) Size() (n int) { + if x == nil { + return n + } + n += x.sizeField1() + return n +} + +func (x *VoidRequest) sizeField1() (n int) { + if x.Msg == "" { + return n + } + n += fastpb.SizeString(1, x.GetMsg()) + return n +} + +func (x *VoidResponse) Size() (n int) { + if x == nil { + return n + } + return n +} + +func (x *ExampleInt2Float) Size() (n int) { + if x == nil { + return n + } + n += x.sizeField1() + n += x.sizeField2() + n += x.sizeField3() + n += x.sizeField4() + n += x.sizeField32767() + return n +} + +func (x *ExampleInt2Float) sizeField1() (n int) { + if x.Int32 == 0 { + return n + } + n += fastpb.SizeInt32(1, x.GetInt32()) + return n +} + +func (x *ExampleInt2Float) sizeField2() (n int) { + if x.Float64 == 0 { + return n + } + n += fastpb.SizeDouble(2, x.GetFloat64()) + return n +} + +func (x *ExampleInt2Float) sizeField3() (n int) { + if x.String_ == "" { + return n + } + n += fastpb.SizeString(3, x.GetString_()) + return n +} + +func (x *ExampleInt2Float) sizeField4() (n int) { + if x.Int64 == 0 { + return n + } + n += fastpb.SizeInt64(4, x.GetInt64()) + return n +} + +func (x *ExampleInt2Float) sizeField32767() (n int) { + if x.Subfix == 0 { + return n + } + n += fastpb.SizeDouble(32767, x.GetSubfix()) + return n +} + +var fieldIDToName_InnerBase2 = map[int32]string{ + 1: "Bool", + 2: "Uint32", + 3: "Uint64", + 4: "Int32", + 5: "Int64", + 6: "Double", + 7: "String_", + 8: "ListInt32", + 9: "MapStringString", + 10: "SetInt32", + 11: "Foo", + 12: "MapInt32String", + 13: "Binary", + 14: "MapUint32String", + 15: "MapUint64String", + 16: "MapInt64String", + 17: "MapInt64Base", + 18: "ListInnerBase", + 19: "ListBase", + 20: "MapStringBase", + 21: "ListString", + 22: "Sfixed32", + 23: "Fixed64", + 24: "Sint32", + 25: "Sint64", + 26: "ListSInt64", + 27: "ListSInt32", + 28: "ListSfixed32", + 29: "ListFixed64", + 30: "MapInt64Sfixed64", + 31: "MapStringFixed32", + 255: "Base", +} + +var fieldIDToName_InnerBasePartial = map[int32]string{ + 1: "Bool", + 8: "ListInt32", + 9: "MapStringString", + 18: "ListInnerBase", + 19: "ListBase", + 20: "MapStringBase", + 127: "MapStringString2", +} + +var fieldIDToName_BasePartial = map[int32]string{ + 5: "TrafficEnv", +} + +var fieldIDToName_ExampleReq = map[int32]string{ + 1: "Msg", + 2: "A", + 3: "InnerBase2", + 255: "Base", + 32767: "Subfix", +} + +var fieldIDToName_ExampleSuper = map[int32]string{ + 1: "Msg", + 2: "A", + 3: "InnerBase2", + 4: "Ex1", + 5: "Ex2", + 6: "Ex3", + 7: "Ex4", + 9: "SelfRef", + 255: "Base", + 32767: "Subfix", +} + +var fieldIDToName_SelfRef = map[int32]string{ + 1: "Self", +} + +var fieldIDToName_ExampleReqPartial = map[int32]string{ + 1: "Msg", + 3: "InnerBase2", + 255: "Base", +} + +var fieldIDToName_ExampleResp = map[int32]string{ + 1: "Msg", + 2: "RequiredField", + 255: "BaseResp", +} + +var fieldIDToName_ExampleRespPartial = map[int32]string{ + 2: "RequiredField", + 255: "BaseResp", +} + +var fieldIDToName_Exception = map[int32]string{ + 1: "Code", + 255: "Msg", +} + +var fieldIDToName_A = map[int32]string{ + 1: "Self", +} + +var fieldIDToName_PingResponse = map[int32]string{ + 1: "Message", +} + +var fieldIDToName_OnewayRequest = map[int32]string{ + 1: "Msg", +} + +var fieldIDToName_VoidRequest = map[int32]string{ + 1: "Msg", +} + +var fieldIDToName_VoidResponse = map[int32]string{} + +var fieldIDToName_ExampleInt2Float = map[int32]string{ + 1: "Int32", + 2: "Float64", + 3: "String_", + 4: "Int64", + 32767: "Subfix", +} + +var _ = base.File_idl_base_proto diff --git a/testdata/kitex_gen/pb/example3/example3.pb.go b/testdata/kitex_gen/pb/example3/example3.pb.go new file mode 100644 index 00000000..9ac5c86e --- /dev/null +++ b/testdata/kitex_gen/pb/example3/example3.pb.go @@ -0,0 +1,1925 @@ +// Copyright 2018 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Test Protobuf definitions with proto3 syntax. + +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.28.1 +// protoc v5.26.1 +// source: idl/example3.proto + +package example3 + +import ( + context "context" + base "github.com/cloudwego/dynamicgo/testdata/kitex_gen/pb/base" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +type FOO int32 + +const ( + FOO_FOO_A FOO = 0 +) + +// Enum value maps for FOO. +var ( + FOO_name = map[int32]string{ + 0: "FOO_A", + } + FOO_value = map[string]int32{ + "FOO_A": 0, + } +) + +func (x FOO) Enum() *FOO { + p := new(FOO) + *p = x + return p +} + +func (x FOO) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (FOO) Descriptor() protoreflect.EnumDescriptor { + return file_idl_example3_proto_enumTypes[0].Descriptor() +} + +func (FOO) Type() protoreflect.EnumType { + return &file_idl_example3_proto_enumTypes[0] +} + +func (x FOO) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use FOO.Descriptor instead. +func (FOO) EnumDescriptor() ([]byte, []int) { + return file_idl_example3_proto_rawDescGZIP(), []int{0} +} + +type InnerBase2 struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Bool bool `protobuf:"varint,1,opt,name=Bool,proto3" json:"Bool,omitempty"` + Uint32 uint32 `protobuf:"varint,2,opt,name=Uint32,proto3" json:"Uint32,omitempty"` + Uint64 uint64 `protobuf:"varint,3,opt,name=Uint64,proto3" json:"Uint64,omitempty"` + Int32 int32 `protobuf:"varint,4,opt,name=Int32,proto3" json:"Int32,omitempty"` + Int64 int64 `protobuf:"varint,5,opt,name=Int64,proto3" json:"Int64,omitempty"` + Double float64 `protobuf:"fixed64,6,opt,name=Double,proto3" json:"Double,omitempty"` + String_ string `protobuf:"bytes,7,opt,name=String,proto3" json:"String,omitempty"` + ListInt32 []int32 `protobuf:"varint,8,rep,packed,name=ListInt32,proto3" json:"ListInt32,omitempty"` + MapStringString map[string]string `protobuf:"bytes,9,rep,name=MapStringString,proto3" json:"MapStringString,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + SetInt32 []int32 `protobuf:"varint,10,rep,packed,name=SetInt32,proto3" json:"SetInt32,omitempty"` + Foo FOO `protobuf:"varint,11,opt,name=Foo,proto3,enum=pb3.FOO" json:"Foo,omitempty"` + MapInt32String map[int32]string `protobuf:"bytes,12,rep,name=MapInt32String,proto3" json:"MapInt32String,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + Binary []byte `protobuf:"bytes,13,opt,name=Binary,proto3" json:"Binary,omitempty"` + MapUint32String map[uint32]string `protobuf:"bytes,14,rep,name=MapUint32String,proto3" json:"MapUint32String,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + MapUint64String map[uint64]string `protobuf:"bytes,15,rep,name=MapUint64String,proto3" json:"MapUint64String,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + MapInt64String map[int64]string `protobuf:"bytes,16,rep,name=MapInt64String,proto3" json:"MapInt64String,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + MapInt64Base map[int64]*base.Base `protobuf:"bytes,17,rep,name=MapInt64Base,proto3" json:"MapInt64Base,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + MapStringBase map[string]*base.Base `protobuf:"bytes,20,rep,name=MapStringBase,proto3" json:"MapStringBase,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + ListBase []*base.Base `protobuf:"bytes,19,rep,name=ListBase,proto3" json:"ListBase,omitempty"` + ListInnerBase []*InnerBase2 `protobuf:"bytes,18,rep,name=ListInnerBase,proto3" json:"ListInnerBase,omitempty"` + ListString []string `protobuf:"bytes,21,rep,name=ListString,proto3" json:"ListString,omitempty"` + Sfixed32 int32 `protobuf:"fixed32,22,opt,name=Sfixed32,proto3" json:"Sfixed32,omitempty"` + Fixed64 uint64 `protobuf:"fixed64,23,opt,name=Fixed64,proto3" json:"Fixed64,omitempty"` + Sint32 int32 `protobuf:"zigzag32,24,opt,name=Sint32,proto3" json:"Sint32,omitempty"` + Sint64 int64 `protobuf:"zigzag64,25,opt,name=Sint64,proto3" json:"Sint64,omitempty"` + ListSInt64 []int64 `protobuf:"zigzag64,26,rep,packed,name=ListSInt64,proto3" json:"ListSInt64,omitempty"` + ListSInt32 []int32 `protobuf:"zigzag32,27,rep,packed,name=ListSInt32,proto3" json:"ListSInt32,omitempty"` + ListSfixed32 []int32 `protobuf:"fixed32,28,rep,packed,name=ListSfixed32,proto3" json:"ListSfixed32,omitempty"` + ListFixed64 []uint64 `protobuf:"fixed64,29,rep,packed,name=ListFixed64,proto3" json:"ListFixed64,omitempty"` + MapInt64Sfixed64 map[int64]int64 `protobuf:"bytes,30,rep,name=MapInt64Sfixed64,proto3" json:"MapInt64Sfixed64,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"` + MapStringFixed32 map[string]uint32 `protobuf:"bytes,31,rep,name=MapStringFixed32,proto3" json:"MapStringFixed32,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"fixed32,2,opt,name=value,proto3"` + Base *base.Base `protobuf:"bytes,255,opt,name=Base,proto3" json:"Base,omitempty"` +} + +func (x *InnerBase2) Reset() { + *x = InnerBase2{} + if protoimpl.UnsafeEnabled { + mi := &file_idl_example3_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *InnerBase2) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*InnerBase2) ProtoMessage() {} + +func (x *InnerBase2) ProtoReflect() protoreflect.Message { + mi := &file_idl_example3_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use InnerBase2.ProtoReflect.Descriptor instead. +func (*InnerBase2) Descriptor() ([]byte, []int) { + return file_idl_example3_proto_rawDescGZIP(), []int{0} +} + +func (x *InnerBase2) GetBool() bool { + if x != nil { + return x.Bool + } + return false +} + +func (x *InnerBase2) GetUint32() uint32 { + if x != nil { + return x.Uint32 + } + return 0 +} + +func (x *InnerBase2) GetUint64() uint64 { + if x != nil { + return x.Uint64 + } + return 0 +} + +func (x *InnerBase2) GetInt32() int32 { + if x != nil { + return x.Int32 + } + return 0 +} + +func (x *InnerBase2) GetInt64() int64 { + if x != nil { + return x.Int64 + } + return 0 +} + +func (x *InnerBase2) GetDouble() float64 { + if x != nil { + return x.Double + } + return 0 +} + +func (x *InnerBase2) GetString_() string { + if x != nil { + return x.String_ + } + return "" +} + +func (x *InnerBase2) GetListInt32() []int32 { + if x != nil { + return x.ListInt32 + } + return nil +} + +func (x *InnerBase2) GetMapStringString() map[string]string { + if x != nil { + return x.MapStringString + } + return nil +} + +func (x *InnerBase2) GetSetInt32() []int32 { + if x != nil { + return x.SetInt32 + } + return nil +} + +func (x *InnerBase2) GetFoo() FOO { + if x != nil { + return x.Foo + } + return FOO_FOO_A +} + +func (x *InnerBase2) GetMapInt32String() map[int32]string { + if x != nil { + return x.MapInt32String + } + return nil +} + +func (x *InnerBase2) GetBinary() []byte { + if x != nil { + return x.Binary + } + return nil +} + +func (x *InnerBase2) GetMapUint32String() map[uint32]string { + if x != nil { + return x.MapUint32String + } + return nil +} + +func (x *InnerBase2) GetMapUint64String() map[uint64]string { + if x != nil { + return x.MapUint64String + } + return nil +} + +func (x *InnerBase2) GetMapInt64String() map[int64]string { + if x != nil { + return x.MapInt64String + } + return nil +} + +func (x *InnerBase2) GetMapInt64Base() map[int64]*base.Base { + if x != nil { + return x.MapInt64Base + } + return nil +} + +func (x *InnerBase2) GetMapStringBase() map[string]*base.Base { + if x != nil { + return x.MapStringBase + } + return nil +} + +func (x *InnerBase2) GetListBase() []*base.Base { + if x != nil { + return x.ListBase + } + return nil +} + +func (x *InnerBase2) GetListInnerBase() []*InnerBase2 { + if x != nil { + return x.ListInnerBase + } + return nil +} + +func (x *InnerBase2) GetListString() []string { + if x != nil { + return x.ListString + } + return nil +} + +func (x *InnerBase2) GetSfixed32() int32 { + if x != nil { + return x.Sfixed32 + } + return 0 +} + +func (x *InnerBase2) GetFixed64() uint64 { + if x != nil { + return x.Fixed64 + } + return 0 +} + +func (x *InnerBase2) GetSint32() int32 { + if x != nil { + return x.Sint32 + } + return 0 +} + +func (x *InnerBase2) GetSint64() int64 { + if x != nil { + return x.Sint64 + } + return 0 +} + +func (x *InnerBase2) GetListSInt64() []int64 { + if x != nil { + return x.ListSInt64 + } + return nil +} + +func (x *InnerBase2) GetListSInt32() []int32 { + if x != nil { + return x.ListSInt32 + } + return nil +} + +func (x *InnerBase2) GetListSfixed32() []int32 { + if x != nil { + return x.ListSfixed32 + } + return nil +} + +func (x *InnerBase2) GetListFixed64() []uint64 { + if x != nil { + return x.ListFixed64 + } + return nil +} + +func (x *InnerBase2) GetMapInt64Sfixed64() map[int64]int64 { + if x != nil { + return x.MapInt64Sfixed64 + } + return nil +} + +func (x *InnerBase2) GetMapStringFixed32() map[string]uint32 { + if x != nil { + return x.MapStringFixed32 + } + return nil +} + +func (x *InnerBase2) GetBase() *base.Base { + if x != nil { + return x.Base + } + return nil +} + +type InnerBasePartial struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Bool bool `protobuf:"varint,1,opt,name=Bool,proto3" json:"Bool,omitempty"` + ListInt32 []int32 `protobuf:"varint,8,rep,packed,name=ListInt32,proto3" json:"ListInt32,omitempty"` + MapStringString map[string]string `protobuf:"bytes,9,rep,name=MapStringString,proto3" json:"MapStringString,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + MapStringBase map[string]*BasePartial `protobuf:"bytes,20,rep,name=MapStringBase,proto3" json:"MapStringBase,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + ListInnerBase []*InnerBasePartial `protobuf:"bytes,18,rep,name=ListInnerBase,proto3" json:"ListInnerBase,omitempty"` + ListBase []*BasePartial `protobuf:"bytes,19,rep,name=ListBase,proto3" json:"ListBase,omitempty"` + MapStringString2 map[string]string `protobuf:"bytes,127,rep,name=MapStringString2,proto3" json:"MapStringString2,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (x *InnerBasePartial) Reset() { + *x = InnerBasePartial{} + if protoimpl.UnsafeEnabled { + mi := &file_idl_example3_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *InnerBasePartial) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*InnerBasePartial) ProtoMessage() {} + +func (x *InnerBasePartial) ProtoReflect() protoreflect.Message { + mi := &file_idl_example3_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use InnerBasePartial.ProtoReflect.Descriptor instead. +func (*InnerBasePartial) Descriptor() ([]byte, []int) { + return file_idl_example3_proto_rawDescGZIP(), []int{1} +} + +func (x *InnerBasePartial) GetBool() bool { + if x != nil { + return x.Bool + } + return false +} + +func (x *InnerBasePartial) GetListInt32() []int32 { + if x != nil { + return x.ListInt32 + } + return nil +} + +func (x *InnerBasePartial) GetMapStringString() map[string]string { + if x != nil { + return x.MapStringString + } + return nil +} + +func (x *InnerBasePartial) GetMapStringBase() map[string]*BasePartial { + if x != nil { + return x.MapStringBase + } + return nil +} + +func (x *InnerBasePartial) GetListInnerBase() []*InnerBasePartial { + if x != nil { + return x.ListInnerBase + } + return nil +} + +func (x *InnerBasePartial) GetListBase() []*BasePartial { + if x != nil { + return x.ListBase + } + return nil +} + +func (x *InnerBasePartial) GetMapStringString2() map[string]string { + if x != nil { + return x.MapStringString2 + } + return nil +} + +type BasePartial struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + TrafficEnv *base.TrafficEnv `protobuf:"bytes,5,opt,name=TrafficEnv,proto3" json:"TrafficEnv,omitempty"` +} + +func (x *BasePartial) Reset() { + *x = BasePartial{} + if protoimpl.UnsafeEnabled { + mi := &file_idl_example3_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *BasePartial) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*BasePartial) ProtoMessage() {} + +func (x *BasePartial) ProtoReflect() protoreflect.Message { + mi := &file_idl_example3_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use BasePartial.ProtoReflect.Descriptor instead. +func (*BasePartial) Descriptor() ([]byte, []int) { + return file_idl_example3_proto_rawDescGZIP(), []int{2} +} + +func (x *BasePartial) GetTrafficEnv() *base.TrafficEnv { + if x != nil { + return x.TrafficEnv + } + return nil +} + +type ExampleReq struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Msg string `protobuf:"bytes,1,opt,name=Msg,proto3" json:"Msg,omitempty"` + A int32 `protobuf:"varint,2,opt,name=A,proto3" json:"A,omitempty"` + InnerBase2 *InnerBase2 `protobuf:"bytes,3,opt,name=InnerBase2,proto3" json:"InnerBase2,omitempty"` + Base *base.Base `protobuf:"bytes,255,opt,name=Base,proto3" json:"Base,omitempty"` + Subfix float64 `protobuf:"fixed64,32767,opt,name=Subfix,proto3" json:"Subfix,omitempty"` +} + +func (x *ExampleReq) Reset() { + *x = ExampleReq{} + if protoimpl.UnsafeEnabled { + mi := &file_idl_example3_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ExampleReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ExampleReq) ProtoMessage() {} + +func (x *ExampleReq) ProtoReflect() protoreflect.Message { + mi := &file_idl_example3_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ExampleReq.ProtoReflect.Descriptor instead. +func (*ExampleReq) Descriptor() ([]byte, []int) { + return file_idl_example3_proto_rawDescGZIP(), []int{3} +} + +func (x *ExampleReq) GetMsg() string { + if x != nil { + return x.Msg + } + return "" +} + +func (x *ExampleReq) GetA() int32 { + if x != nil { + return x.A + } + return 0 +} + +func (x *ExampleReq) GetInnerBase2() *InnerBase2 { + if x != nil { + return x.InnerBase2 + } + return nil +} + +func (x *ExampleReq) GetBase() *base.Base { + if x != nil { + return x.Base + } + return nil +} + +func (x *ExampleReq) GetSubfix() float64 { + if x != nil { + return x.Subfix + } + return 0 +} + +type ExampleSuper struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Msg string `protobuf:"bytes,1,opt,name=Msg,proto3" json:"Msg,omitempty"` + A int32 `protobuf:"varint,2,opt,name=A,proto3" json:"A,omitempty"` + InnerBase2 *InnerBase2 `protobuf:"bytes,3,opt,name=InnerBase2,proto3" json:"InnerBase2,omitempty"` + Ex1 string `protobuf:"bytes,4,opt,name=Ex1,proto3" json:"Ex1,omitempty"` + Ex2 string `protobuf:"bytes,5,opt,name=Ex2,proto3" json:"Ex2,omitempty"` + Ex3 string `protobuf:"bytes,6,opt,name=Ex3,proto3" json:"Ex3,omitempty"` + Ex4 string `protobuf:"bytes,7,opt,name=Ex4,proto3" json:"Ex4,omitempty"` + SelfRef *SelfRef `protobuf:"bytes,9,opt,name=SelfRef,proto3" json:"SelfRef,omitempty"` + Base *base.Base `protobuf:"bytes,255,opt,name=Base,proto3" json:"Base,omitempty"` + Subfix float64 `protobuf:"fixed64,32767,opt,name=Subfix,proto3" json:"Subfix,omitempty"` +} + +func (x *ExampleSuper) Reset() { + *x = ExampleSuper{} + if protoimpl.UnsafeEnabled { + mi := &file_idl_example3_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ExampleSuper) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ExampleSuper) ProtoMessage() {} + +func (x *ExampleSuper) ProtoReflect() protoreflect.Message { + mi := &file_idl_example3_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ExampleSuper.ProtoReflect.Descriptor instead. +func (*ExampleSuper) Descriptor() ([]byte, []int) { + return file_idl_example3_proto_rawDescGZIP(), []int{4} +} + +func (x *ExampleSuper) GetMsg() string { + if x != nil { + return x.Msg + } + return "" +} + +func (x *ExampleSuper) GetA() int32 { + if x != nil { + return x.A + } + return 0 +} + +func (x *ExampleSuper) GetInnerBase2() *InnerBase2 { + if x != nil { + return x.InnerBase2 + } + return nil +} + +func (x *ExampleSuper) GetEx1() string { + if x != nil { + return x.Ex1 + } + return "" +} + +func (x *ExampleSuper) GetEx2() string { + if x != nil { + return x.Ex2 + } + return "" +} + +func (x *ExampleSuper) GetEx3() string { + if x != nil { + return x.Ex3 + } + return "" +} + +func (x *ExampleSuper) GetEx4() string { + if x != nil { + return x.Ex4 + } + return "" +} + +func (x *ExampleSuper) GetSelfRef() *SelfRef { + if x != nil { + return x.SelfRef + } + return nil +} + +func (x *ExampleSuper) GetBase() *base.Base { + if x != nil { + return x.Base + } + return nil +} + +func (x *ExampleSuper) GetSubfix() float64 { + if x != nil { + return x.Subfix + } + return 0 +} + +type SelfRef struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Self *SelfRef `protobuf:"bytes,1,opt,name=self,proto3" json:"self,omitempty"` +} + +func (x *SelfRef) Reset() { + *x = SelfRef{} + if protoimpl.UnsafeEnabled { + mi := &file_idl_example3_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SelfRef) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SelfRef) ProtoMessage() {} + +func (x *SelfRef) ProtoReflect() protoreflect.Message { + mi := &file_idl_example3_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SelfRef.ProtoReflect.Descriptor instead. +func (*SelfRef) Descriptor() ([]byte, []int) { + return file_idl_example3_proto_rawDescGZIP(), []int{5} +} + +func (x *SelfRef) GetSelf() *SelfRef { + if x != nil { + return x.Self + } + return nil +} + +type ExampleReqPartial struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Msg string `protobuf:"bytes,1,opt,name=Msg,proto3" json:"Msg,omitempty"` + InnerBase2 *InnerBasePartial `protobuf:"bytes,3,opt,name=InnerBase2,proto3" json:"InnerBase2,omitempty"` + Base *BasePartial `protobuf:"bytes,255,opt,name=Base,proto3" json:"Base,omitempty"` +} + +func (x *ExampleReqPartial) Reset() { + *x = ExampleReqPartial{} + if protoimpl.UnsafeEnabled { + mi := &file_idl_example3_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ExampleReqPartial) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ExampleReqPartial) ProtoMessage() {} + +func (x *ExampleReqPartial) ProtoReflect() protoreflect.Message { + mi := &file_idl_example3_proto_msgTypes[6] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ExampleReqPartial.ProtoReflect.Descriptor instead. +func (*ExampleReqPartial) Descriptor() ([]byte, []int) { + return file_idl_example3_proto_rawDescGZIP(), []int{6} +} + +func (x *ExampleReqPartial) GetMsg() string { + if x != nil { + return x.Msg + } + return "" +} + +func (x *ExampleReqPartial) GetInnerBase2() *InnerBasePartial { + if x != nil { + return x.InnerBase2 + } + return nil +} + +func (x *ExampleReqPartial) GetBase() *BasePartial { + if x != nil { + return x.Base + } + return nil +} + +type ExampleResp struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Msg string `protobuf:"bytes,1,opt,name=Msg,proto3" json:"Msg,omitempty"` + RequiredField string `protobuf:"bytes,2,opt,name=required_field,json=requiredField,proto3" json:"required_field,omitempty"` + BaseResp *base.BaseResp `protobuf:"bytes,255,opt,name=BaseResp,proto3" json:"BaseResp,omitempty"` +} + +func (x *ExampleResp) Reset() { + *x = ExampleResp{} + if protoimpl.UnsafeEnabled { + mi := &file_idl_example3_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ExampleResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ExampleResp) ProtoMessage() {} + +func (x *ExampleResp) ProtoReflect() protoreflect.Message { + mi := &file_idl_example3_proto_msgTypes[7] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ExampleResp.ProtoReflect.Descriptor instead. +func (*ExampleResp) Descriptor() ([]byte, []int) { + return file_idl_example3_proto_rawDescGZIP(), []int{7} +} + +func (x *ExampleResp) GetMsg() string { + if x != nil { + return x.Msg + } + return "" +} + +func (x *ExampleResp) GetRequiredField() string { + if x != nil { + return x.RequiredField + } + return "" +} + +func (x *ExampleResp) GetBaseResp() *base.BaseResp { + if x != nil { + return x.BaseResp + } + return nil +} + +type ExampleRespPartial struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + RequiredField string `protobuf:"bytes,2,opt,name=required_field,json=requiredField,proto3" json:"required_field,omitempty"` + BaseResp *base.BaseResp `protobuf:"bytes,255,opt,name=BaseResp,proto3" json:"BaseResp,omitempty"` +} + +func (x *ExampleRespPartial) Reset() { + *x = ExampleRespPartial{} + if protoimpl.UnsafeEnabled { + mi := &file_idl_example3_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ExampleRespPartial) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ExampleRespPartial) ProtoMessage() {} + +func (x *ExampleRespPartial) ProtoReflect() protoreflect.Message { + mi := &file_idl_example3_proto_msgTypes[8] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ExampleRespPartial.ProtoReflect.Descriptor instead. +func (*ExampleRespPartial) Descriptor() ([]byte, []int) { + return file_idl_example3_proto_rawDescGZIP(), []int{8} +} + +func (x *ExampleRespPartial) GetRequiredField() string { + if x != nil { + return x.RequiredField + } + return "" +} + +func (x *ExampleRespPartial) GetBaseResp() *base.BaseResp { + if x != nil { + return x.BaseResp + } + return nil +} + +type Exception struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Code int32 `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"` + Msg string `protobuf:"bytes,255,opt,name=msg,proto3" json:"msg,omitempty"` +} + +func (x *Exception) Reset() { + *x = Exception{} + if protoimpl.UnsafeEnabled { + mi := &file_idl_example3_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Exception) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Exception) ProtoMessage() {} + +func (x *Exception) ProtoReflect() protoreflect.Message { + mi := &file_idl_example3_proto_msgTypes[9] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Exception.ProtoReflect.Descriptor instead. +func (*Exception) Descriptor() ([]byte, []int) { + return file_idl_example3_proto_rawDescGZIP(), []int{9} +} + +func (x *Exception) GetCode() int32 { + if x != nil { + return x.Code + } + return 0 +} + +func (x *Exception) GetMsg() string { + if x != nil { + return x.Msg + } + return "" +} + +type A struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Self *A `protobuf:"bytes,1,opt,name=self,proto3" json:"self,omitempty"` +} + +func (x *A) Reset() { + *x = A{} + if protoimpl.UnsafeEnabled { + mi := &file_idl_example3_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *A) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*A) ProtoMessage() {} + +func (x *A) ProtoReflect() protoreflect.Message { + mi := &file_idl_example3_proto_msgTypes[10] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use A.ProtoReflect.Descriptor instead. +func (*A) Descriptor() ([]byte, []int) { + return file_idl_example3_proto_rawDescGZIP(), []int{10} +} + +func (x *A) GetSelf() *A { + if x != nil { + return x.Self + } + return nil +} + +type PingResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"` +} + +func (x *PingResponse) Reset() { + *x = PingResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_idl_example3_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *PingResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PingResponse) ProtoMessage() {} + +func (x *PingResponse) ProtoReflect() protoreflect.Message { + mi := &file_idl_example3_proto_msgTypes[11] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use PingResponse.ProtoReflect.Descriptor instead. +func (*PingResponse) Descriptor() ([]byte, []int) { + return file_idl_example3_proto_rawDescGZIP(), []int{11} +} + +func (x *PingResponse) GetMessage() string { + if x != nil { + return x.Message + } + return "" +} + +type OnewayRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Msg string `protobuf:"bytes,1,opt,name=msg,proto3" json:"msg,omitempty"` +} + +func (x *OnewayRequest) Reset() { + *x = OnewayRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_idl_example3_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *OnewayRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*OnewayRequest) ProtoMessage() {} + +func (x *OnewayRequest) ProtoReflect() protoreflect.Message { + mi := &file_idl_example3_proto_msgTypes[12] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use OnewayRequest.ProtoReflect.Descriptor instead. +func (*OnewayRequest) Descriptor() ([]byte, []int) { + return file_idl_example3_proto_rawDescGZIP(), []int{12} +} + +func (x *OnewayRequest) GetMsg() string { + if x != nil { + return x.Msg + } + return "" +} + +type VoidRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Msg string `protobuf:"bytes,1,opt,name=msg,proto3" json:"msg,omitempty"` +} + +func (x *VoidRequest) Reset() { + *x = VoidRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_idl_example3_proto_msgTypes[13] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *VoidRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*VoidRequest) ProtoMessage() {} + +func (x *VoidRequest) ProtoReflect() protoreflect.Message { + mi := &file_idl_example3_proto_msgTypes[13] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use VoidRequest.ProtoReflect.Descriptor instead. +func (*VoidRequest) Descriptor() ([]byte, []int) { + return file_idl_example3_proto_rawDescGZIP(), []int{13} +} + +func (x *VoidRequest) GetMsg() string { + if x != nil { + return x.Msg + } + return "" +} + +type VoidResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *VoidResponse) Reset() { + *x = VoidResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_idl_example3_proto_msgTypes[14] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *VoidResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*VoidResponse) ProtoMessage() {} + +func (x *VoidResponse) ProtoReflect() protoreflect.Message { + mi := &file_idl_example3_proto_msgTypes[14] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use VoidResponse.ProtoReflect.Descriptor instead. +func (*VoidResponse) Descriptor() ([]byte, []int) { + return file_idl_example3_proto_rawDescGZIP(), []int{14} +} + +type ExampleInt2Float struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Int32 int32 `protobuf:"varint,1,opt,name=Int32,proto3" json:"Int32,omitempty"` + Float64 float64 `protobuf:"fixed64,2,opt,name=Float64,proto3" json:"Float64,omitempty"` + String_ string `protobuf:"bytes,3,opt,name=String,proto3" json:"String,omitempty"` + Int64 int64 `protobuf:"varint,4,opt,name=Int64,proto3" json:"Int64,omitempty"` + Subfix float64 `protobuf:"fixed64,32767,opt,name=Subfix,proto3" json:"Subfix,omitempty"` +} + +func (x *ExampleInt2Float) Reset() { + *x = ExampleInt2Float{} + if protoimpl.UnsafeEnabled { + mi := &file_idl_example3_proto_msgTypes[15] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ExampleInt2Float) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ExampleInt2Float) ProtoMessage() {} + +func (x *ExampleInt2Float) ProtoReflect() protoreflect.Message { + mi := &file_idl_example3_proto_msgTypes[15] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ExampleInt2Float.ProtoReflect.Descriptor instead. +func (*ExampleInt2Float) Descriptor() ([]byte, []int) { + return file_idl_example3_proto_rawDescGZIP(), []int{15} +} + +func (x *ExampleInt2Float) GetInt32() int32 { + if x != nil { + return x.Int32 + } + return 0 +} + +func (x *ExampleInt2Float) GetFloat64() float64 { + if x != nil { + return x.Float64 + } + return 0 +} + +func (x *ExampleInt2Float) GetString_() string { + if x != nil { + return x.String_ + } + return "" +} + +func (x *ExampleInt2Float) GetInt64() int64 { + if x != nil { + return x.Int64 + } + return 0 +} + +func (x *ExampleInt2Float) GetSubfix() float64 { + if x != nil { + return x.Subfix + } + return 0 +} + +var File_idl_example3_proto protoreflect.FileDescriptor + +var file_idl_example3_proto_rawDesc = []byte{ + 0x0a, 0x12, 0x69, 0x64, 0x6c, 0x2f, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x33, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x03, 0x70, 0x62, 0x33, 0x1a, 0x0e, 0x69, 0x64, 0x6c, 0x2f, 0x62, + 0x61, 0x73, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xda, 0x0f, 0x0a, 0x0a, 0x49, 0x6e, + 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, 0x32, 0x12, 0x12, 0x0a, 0x04, 0x42, 0x6f, 0x6f, 0x6c, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x04, 0x42, 0x6f, 0x6f, 0x6c, 0x12, 0x16, 0x0a, 0x06, + 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x06, 0x55, 0x69, + 0x6e, 0x74, 0x33, 0x32, 0x12, 0x16, 0x0a, 0x06, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x14, 0x0a, 0x05, + 0x49, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x49, 0x6e, 0x74, + 0x33, 0x32, 0x12, 0x14, 0x0a, 0x05, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x05, 0x20, 0x01, 0x28, + 0x03, 0x52, 0x05, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x16, 0x0a, 0x06, 0x44, 0x6f, 0x75, 0x62, + 0x6c, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x01, 0x52, 0x06, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, + 0x12, 0x16, 0x0a, 0x06, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x06, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x1c, 0x0a, 0x09, 0x4c, 0x69, 0x73, 0x74, + 0x49, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x08, 0x20, 0x03, 0x28, 0x05, 0x52, 0x09, 0x4c, 0x69, 0x73, + 0x74, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x4e, 0x0a, 0x0f, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, + 0x69, 0x6e, 0x67, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x09, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x24, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, 0x32, + 0x2e, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, + 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0f, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, + 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x1a, 0x0a, 0x08, 0x53, 0x65, 0x74, 0x49, 0x6e, 0x74, + 0x33, 0x32, 0x18, 0x0a, 0x20, 0x03, 0x28, 0x05, 0x52, 0x08, 0x53, 0x65, 0x74, 0x49, 0x6e, 0x74, + 0x33, 0x32, 0x12, 0x1a, 0x0a, 0x03, 0x46, 0x6f, 0x6f, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0e, 0x32, + 0x08, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x46, 0x4f, 0x4f, 0x52, 0x03, 0x46, 0x6f, 0x6f, 0x12, 0x4b, + 0x0a, 0x0e, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, + 0x18, 0x0c, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x49, 0x6e, 0x6e, + 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, 0x32, 0x2e, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x33, 0x32, + 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0e, 0x4d, 0x61, 0x70, + 0x49, 0x6e, 0x74, 0x33, 0x32, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x16, 0x0a, 0x06, 0x42, + 0x69, 0x6e, 0x61, 0x72, 0x79, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x06, 0x42, 0x69, 0x6e, + 0x61, 0x72, 0x79, 0x12, 0x4e, 0x0a, 0x0f, 0x4d, 0x61, 0x70, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, + 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x0e, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x70, + 0x62, 0x33, 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, 0x32, 0x2e, 0x4d, 0x61, + 0x70, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x45, 0x6e, 0x74, + 0x72, 0x79, 0x52, 0x0f, 0x4d, 0x61, 0x70, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x53, 0x74, 0x72, + 0x69, 0x6e, 0x67, 0x12, 0x4e, 0x0a, 0x0f, 0x4d, 0x61, 0x70, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, + 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x0f, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x70, + 0x62, 0x33, 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, 0x32, 0x2e, 0x4d, 0x61, + 0x70, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x45, 0x6e, 0x74, + 0x72, 0x79, 0x52, 0x0f, 0x4d, 0x61, 0x70, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x53, 0x74, 0x72, + 0x69, 0x6e, 0x67, 0x12, 0x4b, 0x0a, 0x0e, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x53, + 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x10, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x70, 0x62, + 0x33, 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, 0x32, 0x2e, 0x4d, 0x61, 0x70, + 0x49, 0x6e, 0x74, 0x36, 0x34, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x45, 0x6e, 0x74, 0x72, 0x79, + 0x52, 0x0e, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, + 0x12, 0x45, 0x0a, 0x0c, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x42, 0x61, 0x73, 0x65, + 0x18, 0x11, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x49, 0x6e, 0x6e, + 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, 0x32, 0x2e, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, + 0x42, 0x61, 0x73, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0c, 0x4d, 0x61, 0x70, 0x49, 0x6e, + 0x74, 0x36, 0x34, 0x42, 0x61, 0x73, 0x65, 0x12, 0x48, 0x0a, 0x0d, 0x4d, 0x61, 0x70, 0x53, 0x74, + 0x72, 0x69, 0x6e, 0x67, 0x42, 0x61, 0x73, 0x65, 0x18, 0x14, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x22, + 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, 0x32, 0x2e, + 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x42, 0x61, 0x73, 0x65, 0x45, 0x6e, 0x74, + 0x72, 0x79, 0x52, 0x0d, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x42, 0x61, 0x73, + 0x65, 0x12, 0x25, 0x0a, 0x08, 0x4c, 0x69, 0x73, 0x74, 0x42, 0x61, 0x73, 0x65, 0x18, 0x13, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x09, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x42, 0x61, 0x73, 0x65, 0x52, 0x08, + 0x4c, 0x69, 0x73, 0x74, 0x42, 0x61, 0x73, 0x65, 0x12, 0x35, 0x0a, 0x0d, 0x4c, 0x69, 0x73, 0x74, + 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, 0x18, 0x12, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x0f, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, 0x32, + 0x52, 0x0d, 0x4c, 0x69, 0x73, 0x74, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, 0x12, + 0x1e, 0x0a, 0x0a, 0x4c, 0x69, 0x73, 0x74, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x15, 0x20, + 0x03, 0x28, 0x09, 0x52, 0x0a, 0x4c, 0x69, 0x73, 0x74, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, + 0x1a, 0x0a, 0x08, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x18, 0x16, 0x20, 0x01, 0x28, + 0x0f, 0x52, 0x08, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x18, 0x0a, 0x07, 0x46, + 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0x17, 0x20, 0x01, 0x28, 0x06, 0x52, 0x07, 0x46, 0x69, + 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x16, 0x0a, 0x06, 0x53, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, + 0x18, 0x20, 0x01, 0x28, 0x11, 0x52, 0x06, 0x53, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x16, 0x0a, + 0x06, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x19, 0x20, 0x01, 0x28, 0x12, 0x52, 0x06, 0x53, + 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x4c, 0x69, 0x73, 0x74, 0x53, 0x49, 0x6e, + 0x74, 0x36, 0x34, 0x18, 0x1a, 0x20, 0x03, 0x28, 0x12, 0x52, 0x0a, 0x4c, 0x69, 0x73, 0x74, 0x53, + 0x49, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x1e, 0x0a, 0x0a, 0x4c, 0x69, 0x73, 0x74, 0x53, 0x49, 0x6e, + 0x74, 0x33, 0x32, 0x18, 0x1b, 0x20, 0x03, 0x28, 0x11, 0x52, 0x0a, 0x4c, 0x69, 0x73, 0x74, 0x53, + 0x49, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x22, 0x0a, 0x0c, 0x4c, 0x69, 0x73, 0x74, 0x53, 0x66, 0x69, + 0x78, 0x65, 0x64, 0x33, 0x32, 0x18, 0x1c, 0x20, 0x03, 0x28, 0x0f, 0x52, 0x0c, 0x4c, 0x69, 0x73, + 0x74, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x20, 0x0a, 0x0b, 0x4c, 0x69, 0x73, + 0x74, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0x1d, 0x20, 0x03, 0x28, 0x06, 0x52, 0x0b, + 0x4c, 0x69, 0x73, 0x74, 0x46, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x51, 0x0a, 0x10, 0x4d, + 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, + 0x1e, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x49, 0x6e, 0x6e, 0x65, + 0x72, 0x42, 0x61, 0x73, 0x65, 0x32, 0x2e, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x53, + 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x10, 0x4d, 0x61, + 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x51, + 0x0a, 0x10, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x46, 0x69, 0x78, 0x65, 0x64, + 0x33, 0x32, 0x18, 0x1f, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x49, + 0x6e, 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, 0x32, 0x2e, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, + 0x69, 0x6e, 0x67, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, + 0x10, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, + 0x32, 0x12, 0x1e, 0x0a, 0x04, 0x42, 0x61, 0x73, 0x65, 0x18, 0xff, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x09, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x42, 0x61, 0x73, 0x65, 0x52, 0x04, 0x42, 0x61, 0x73, + 0x65, 0x1a, 0x42, 0x0a, 0x14, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x53, 0x74, + 0x72, 0x69, 0x6e, 0x67, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x41, 0x0a, 0x13, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x33, + 0x32, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, + 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, + 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x42, 0x0a, 0x14, 0x4d, 0x61, 0x70, 0x55, + 0x69, 0x6e, 0x74, 0x33, 0x32, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x45, 0x6e, 0x74, 0x72, 0x79, + 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x03, 0x6b, + 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x42, 0x0a, 0x14, + 0x4d, 0x61, 0x70, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x45, + 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x04, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, + 0x1a, 0x41, 0x0a, 0x13, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x53, 0x74, 0x72, 0x69, + 0x6e, 0x67, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, + 0x02, 0x38, 0x01, 0x1a, 0x4a, 0x0a, 0x11, 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x42, + 0x61, 0x73, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x1f, 0x0a, 0x05, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x09, 0x2e, 0x70, 0x62, 0x33, 0x2e, + 0x42, 0x61, 0x73, 0x65, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, + 0x4b, 0x0a, 0x12, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x42, 0x61, 0x73, 0x65, + 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x1f, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x09, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x42, 0x61, 0x73, + 0x65, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x43, 0x0a, 0x15, + 0x4d, 0x61, 0x70, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, + 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x10, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, + 0x01, 0x1a, 0x43, 0x0a, 0x15, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x46, 0x69, + 0x78, 0x65, 0x64, 0x33, 0x32, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, + 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x07, 0x52, 0x05, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x8b, 0x05, 0x0a, 0x10, 0x49, 0x6e, 0x6e, 0x65, 0x72, + 0x42, 0x61, 0x73, 0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x12, 0x12, 0x0a, 0x04, 0x42, + 0x6f, 0x6f, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x04, 0x42, 0x6f, 0x6f, 0x6c, 0x12, + 0x1c, 0x0a, 0x09, 0x4c, 0x69, 0x73, 0x74, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x08, 0x20, 0x03, + 0x28, 0x05, 0x52, 0x09, 0x4c, 0x69, 0x73, 0x74, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x54, 0x0a, + 0x0f, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, + 0x18, 0x09, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x49, 0x6e, 0x6e, + 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x2e, 0x4d, 0x61, + 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x45, 0x6e, 0x74, + 0x72, 0x79, 0x52, 0x0f, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x72, + 0x69, 0x6e, 0x67, 0x12, 0x4e, 0x0a, 0x0d, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, + 0x42, 0x61, 0x73, 0x65, 0x18, 0x14, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x70, 0x62, 0x33, + 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, + 0x6c, 0x2e, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x42, 0x61, 0x73, 0x65, 0x45, + 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0d, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x42, + 0x61, 0x73, 0x65, 0x12, 0x3b, 0x0a, 0x0d, 0x4c, 0x69, 0x73, 0x74, 0x49, 0x6e, 0x6e, 0x65, 0x72, + 0x42, 0x61, 0x73, 0x65, 0x18, 0x12, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x70, 0x62, 0x33, + 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, + 0x6c, 0x52, 0x0d, 0x4c, 0x69, 0x73, 0x74, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, + 0x12, 0x2c, 0x0a, 0x08, 0x4c, 0x69, 0x73, 0x74, 0x42, 0x61, 0x73, 0x65, 0x18, 0x13, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x42, 0x61, 0x73, 0x65, 0x50, 0x61, 0x72, + 0x74, 0x69, 0x61, 0x6c, 0x52, 0x08, 0x4c, 0x69, 0x73, 0x74, 0x42, 0x61, 0x73, 0x65, 0x12, 0x57, + 0x0a, 0x10, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x72, 0x69, 0x6e, + 0x67, 0x32, 0x18, 0x7f, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x49, + 0x6e, 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x2e, + 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x32, + 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x10, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, + 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x32, 0x1a, 0x42, 0x0a, 0x14, 0x4d, 0x61, 0x70, 0x53, 0x74, + 0x72, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, + 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, + 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x52, 0x0a, 0x12, 0x4d, + 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x42, 0x61, 0x73, 0x65, 0x45, 0x6e, 0x74, 0x72, + 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, + 0x6b, 0x65, 0x79, 0x12, 0x26, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x42, 0x61, 0x73, 0x65, 0x50, 0x61, 0x72, + 0x74, 0x69, 0x61, 0x6c, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, + 0x43, 0x0a, 0x15, 0x4d, 0x61, 0x70, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x72, 0x69, + 0x6e, 0x67, 0x32, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x3a, 0x02, 0x38, 0x01, 0x22, 0x3e, 0x0a, 0x0b, 0x42, 0x61, 0x73, 0x65, 0x50, 0x61, 0x72, 0x74, + 0x69, 0x61, 0x6c, 0x12, 0x2f, 0x0a, 0x0a, 0x54, 0x72, 0x61, 0x66, 0x66, 0x69, 0x63, 0x45, 0x6e, + 0x76, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x54, 0x72, + 0x61, 0x66, 0x66, 0x69, 0x63, 0x45, 0x6e, 0x76, 0x52, 0x0a, 0x54, 0x72, 0x61, 0x66, 0x66, 0x69, + 0x63, 0x45, 0x6e, 0x76, 0x22, 0x97, 0x01, 0x0a, 0x0a, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, + 0x52, 0x65, 0x71, 0x12, 0x10, 0x0a, 0x03, 0x4d, 0x73, 0x67, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x03, 0x4d, 0x73, 0x67, 0x12, 0x0c, 0x0a, 0x01, 0x41, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, + 0x52, 0x01, 0x41, 0x12, 0x2f, 0x0a, 0x0a, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, + 0x32, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x49, 0x6e, + 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, 0x32, 0x52, 0x0a, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, + 0x61, 0x73, 0x65, 0x32, 0x12, 0x1e, 0x0a, 0x04, 0x42, 0x61, 0x73, 0x65, 0x18, 0xff, 0x01, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x09, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x42, 0x61, 0x73, 0x65, 0x52, 0x04, + 0x42, 0x61, 0x73, 0x65, 0x12, 0x18, 0x0a, 0x06, 0x53, 0x75, 0x62, 0x66, 0x69, 0x78, 0x18, 0xff, + 0xff, 0x01, 0x20, 0x01, 0x28, 0x01, 0x52, 0x06, 0x53, 0x75, 0x62, 0x66, 0x69, 0x78, 0x22, 0x89, + 0x02, 0x0a, 0x0c, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x53, 0x75, 0x70, 0x65, 0x72, 0x12, + 0x10, 0x0a, 0x03, 0x4d, 0x73, 0x67, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x4d, 0x73, + 0x67, 0x12, 0x0c, 0x0a, 0x01, 0x41, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x01, 0x41, 0x12, + 0x2f, 0x0a, 0x0a, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, 0x32, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, + 0x61, 0x73, 0x65, 0x32, 0x52, 0x0a, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, 0x32, + 0x12, 0x10, 0x0a, 0x03, 0x45, 0x78, 0x31, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x45, + 0x78, 0x31, 0x12, 0x10, 0x0a, 0x03, 0x45, 0x78, 0x32, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x03, 0x45, 0x78, 0x32, 0x12, 0x10, 0x0a, 0x03, 0x45, 0x78, 0x33, 0x18, 0x06, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x03, 0x45, 0x78, 0x33, 0x12, 0x10, 0x0a, 0x03, 0x45, 0x78, 0x34, 0x18, 0x07, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x03, 0x45, 0x78, 0x34, 0x12, 0x26, 0x0a, 0x07, 0x53, 0x65, 0x6c, 0x66, + 0x52, 0x65, 0x66, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x70, 0x62, 0x33, 0x2e, + 0x53, 0x65, 0x6c, 0x66, 0x52, 0x65, 0x66, 0x52, 0x07, 0x53, 0x65, 0x6c, 0x66, 0x52, 0x65, 0x66, + 0x12, 0x1e, 0x0a, 0x04, 0x42, 0x61, 0x73, 0x65, 0x18, 0xff, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x09, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x42, 0x61, 0x73, 0x65, 0x52, 0x04, 0x42, 0x61, 0x73, 0x65, + 0x12, 0x18, 0x0a, 0x06, 0x53, 0x75, 0x62, 0x66, 0x69, 0x78, 0x18, 0xff, 0xff, 0x01, 0x20, 0x01, + 0x28, 0x01, 0x52, 0x06, 0x53, 0x75, 0x62, 0x66, 0x69, 0x78, 0x22, 0x2b, 0x0a, 0x07, 0x53, 0x65, + 0x6c, 0x66, 0x52, 0x65, 0x66, 0x12, 0x20, 0x0a, 0x04, 0x73, 0x65, 0x6c, 0x66, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x53, 0x65, 0x6c, 0x66, 0x52, 0x65, + 0x66, 0x52, 0x04, 0x73, 0x65, 0x6c, 0x66, 0x22, 0x83, 0x01, 0x0a, 0x11, 0x45, 0x78, 0x61, 0x6d, + 0x70, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x12, 0x10, 0x0a, + 0x03, 0x4d, 0x73, 0x67, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x4d, 0x73, 0x67, 0x12, + 0x35, 0x0a, 0x0a, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, 0x61, 0x73, 0x65, 0x32, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x42, + 0x61, 0x73, 0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x52, 0x0a, 0x49, 0x6e, 0x6e, 0x65, + 0x72, 0x42, 0x61, 0x73, 0x65, 0x32, 0x12, 0x25, 0x0a, 0x04, 0x42, 0x61, 0x73, 0x65, 0x18, 0xff, + 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x42, 0x61, 0x73, 0x65, + 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x52, 0x04, 0x42, 0x61, 0x73, 0x65, 0x22, 0x72, 0x0a, + 0x0b, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x12, 0x10, 0x0a, 0x03, + 0x4d, 0x73, 0x67, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x4d, 0x73, 0x67, 0x12, 0x25, + 0x0a, 0x0e, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, + 0x46, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x2a, 0x0a, 0x08, 0x42, 0x61, 0x73, 0x65, 0x52, 0x65, 0x73, + 0x70, 0x18, 0xff, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0d, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x42, + 0x61, 0x73, 0x65, 0x52, 0x65, 0x73, 0x70, 0x52, 0x08, 0x42, 0x61, 0x73, 0x65, 0x52, 0x65, 0x73, + 0x70, 0x22, 0x67, 0x0a, 0x12, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, + 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x12, 0x25, 0x0a, 0x0e, 0x72, 0x65, 0x71, 0x75, 0x69, + 0x72, 0x65, 0x64, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0d, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x2a, + 0x0a, 0x08, 0x42, 0x61, 0x73, 0x65, 0x52, 0x65, 0x73, 0x70, 0x18, 0xff, 0x01, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x0d, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x42, 0x61, 0x73, 0x65, 0x52, 0x65, 0x73, 0x70, + 0x52, 0x08, 0x42, 0x61, 0x73, 0x65, 0x52, 0x65, 0x73, 0x70, 0x22, 0x32, 0x0a, 0x09, 0x45, 0x78, + 0x63, 0x65, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x12, 0x0a, 0x04, 0x63, 0x6f, 0x64, 0x65, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x04, 0x63, 0x6f, 0x64, 0x65, 0x12, 0x11, 0x0a, 0x03, 0x6d, + 0x73, 0x67, 0x18, 0xff, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6d, 0x73, 0x67, 0x22, 0x1f, + 0x0a, 0x01, 0x41, 0x12, 0x1a, 0x0a, 0x04, 0x73, 0x65, 0x6c, 0x66, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x06, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x41, 0x52, 0x04, 0x73, 0x65, 0x6c, 0x66, 0x22, + 0x28, 0x0a, 0x0c, 0x50, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, + 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x21, 0x0a, 0x0d, 0x4f, 0x6e, 0x65, + 0x77, 0x61, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6d, 0x73, + 0x67, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6d, 0x73, 0x67, 0x22, 0x1f, 0x0a, 0x0b, + 0x56, 0x6f, 0x69, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6d, + 0x73, 0x67, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6d, 0x73, 0x67, 0x22, 0x0e, 0x0a, + 0x0c, 0x56, 0x6f, 0x69, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x8a, 0x01, + 0x0a, 0x10, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x49, 0x6e, 0x74, 0x32, 0x46, 0x6c, 0x6f, + 0x61, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x05, 0x52, 0x05, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x18, 0x0a, 0x07, 0x46, 0x6c, 0x6f, 0x61, + 0x74, 0x36, 0x34, 0x18, 0x02, 0x20, 0x01, 0x28, 0x01, 0x52, 0x07, 0x46, 0x6c, 0x6f, 0x61, 0x74, + 0x36, 0x34, 0x12, 0x16, 0x0a, 0x06, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x06, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x14, 0x0a, 0x05, 0x49, 0x6e, + 0x74, 0x36, 0x34, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x49, 0x6e, 0x74, 0x36, 0x34, + 0x12, 0x18, 0x0a, 0x06, 0x53, 0x75, 0x62, 0x66, 0x69, 0x78, 0x18, 0xff, 0xff, 0x01, 0x20, 0x01, + 0x28, 0x01, 0x52, 0x06, 0x53, 0x75, 0x62, 0x66, 0x69, 0x78, 0x2a, 0x10, 0x0a, 0x03, 0x46, 0x4f, + 0x4f, 0x12, 0x09, 0x0a, 0x05, 0x46, 0x4f, 0x4f, 0x5f, 0x41, 0x10, 0x00, 0x32, 0xce, 0x03, 0x0a, + 0x0c, 0x54, 0x65, 0x73, 0x74, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x32, 0x12, 0x32, 0x0a, + 0x0d, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x12, 0x0f, + 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x1a, + 0x10, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x52, 0x65, 0x73, + 0x70, 0x12, 0x36, 0x0a, 0x14, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x50, 0x61, 0x72, 0x74, + 0x69, 0x61, 0x6c, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x12, 0x16, 0x2e, 0x70, 0x62, 0x33, 0x2e, + 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, + 0x6c, 0x1a, 0x06, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x41, 0x12, 0x48, 0x0a, 0x15, 0x45, 0x78, 0x61, + 0x6d, 0x70, 0x6c, 0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x4d, 0x65, 0x74, 0x68, 0x6f, + 0x64, 0x32, 0x12, 0x16, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, + 0x52, 0x65, 0x71, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x1a, 0x17, 0x2e, 0x70, 0x62, 0x33, + 0x2e, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x50, 0x61, 0x72, 0x74, + 0x69, 0x61, 0x6c, 0x12, 0x2f, 0x0a, 0x12, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x53, 0x75, + 0x70, 0x65, 0x72, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x12, 0x11, 0x2e, 0x70, 0x62, 0x33, 0x2e, + 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x53, 0x75, 0x70, 0x65, 0x72, 0x1a, 0x06, 0x2e, 0x70, + 0x62, 0x33, 0x2e, 0x41, 0x12, 0x3f, 0x0a, 0x0f, 0x49, 0x6e, 0x74, 0x32, 0x46, 0x6c, 0x6f, 0x61, + 0x74, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x12, 0x15, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x45, 0x78, + 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x49, 0x6e, 0x74, 0x32, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x1a, 0x15, + 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x45, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x49, 0x6e, 0x74, 0x32, + 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x12, 0x15, 0x0a, 0x03, 0x46, 0x6f, 0x6f, 0x12, 0x06, 0x2e, 0x70, + 0x62, 0x33, 0x2e, 0x41, 0x1a, 0x06, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x41, 0x12, 0x21, 0x0a, 0x04, + 0x50, 0x69, 0x6e, 0x67, 0x12, 0x06, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x41, 0x1a, 0x11, 0x2e, 0x70, + 0x62, 0x33, 0x2e, 0x50, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, + 0x2f, 0x0a, 0x06, 0x4f, 0x6e, 0x65, 0x77, 0x61, 0x79, 0x12, 0x12, 0x2e, 0x70, 0x62, 0x33, 0x2e, + 0x4f, 0x6e, 0x65, 0x77, 0x61, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x11, 0x2e, + 0x70, 0x62, 0x33, 0x2e, 0x56, 0x6f, 0x69, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x12, 0x2b, 0x0a, 0x04, 0x56, 0x6f, 0x69, 0x64, 0x12, 0x10, 0x2e, 0x70, 0x62, 0x33, 0x2e, 0x56, + 0x6f, 0x69, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x11, 0x2e, 0x70, 0x62, 0x33, + 0x2e, 0x56, 0x6f, 0x69, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x42, 0x3f, 0x5a, + 0x3d, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x63, 0x6c, 0x6f, 0x75, + 0x64, 0x77, 0x65, 0x67, 0x6f, 0x2f, 0x64, 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x67, 0x6f, 0x2f, + 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x2f, 0x6b, 0x69, 0x74, 0x65, 0x78, 0x5f, 0x67, + 0x65, 0x6e, 0x2f, 0x70, 0x62, 0x2f, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x33, 0x62, 0x06, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_idl_example3_proto_rawDescOnce sync.Once + file_idl_example3_proto_rawDescData = file_idl_example3_proto_rawDesc +) + +func file_idl_example3_proto_rawDescGZIP() []byte { + file_idl_example3_proto_rawDescOnce.Do(func() { + file_idl_example3_proto_rawDescData = protoimpl.X.CompressGZIP(file_idl_example3_proto_rawDescData) + }) + return file_idl_example3_proto_rawDescData +} + +var file_idl_example3_proto_enumTypes = make([]protoimpl.EnumInfo, 1) +var file_idl_example3_proto_msgTypes = make([]protoimpl.MessageInfo, 28) +var file_idl_example3_proto_goTypes = []interface{}{ + (FOO)(0), // 0: pb3.FOO + (*InnerBase2)(nil), // 1: pb3.InnerBase2 + (*InnerBasePartial)(nil), // 2: pb3.InnerBasePartial + (*BasePartial)(nil), // 3: pb3.BasePartial + (*ExampleReq)(nil), // 4: pb3.ExampleReq + (*ExampleSuper)(nil), // 5: pb3.ExampleSuper + (*SelfRef)(nil), // 6: pb3.SelfRef + (*ExampleReqPartial)(nil), // 7: pb3.ExampleReqPartial + (*ExampleResp)(nil), // 8: pb3.ExampleResp + (*ExampleRespPartial)(nil), // 9: pb3.ExampleRespPartial + (*Exception)(nil), // 10: pb3.Exception + (*A)(nil), // 11: pb3.A + (*PingResponse)(nil), // 12: pb3.PingResponse + (*OnewayRequest)(nil), // 13: pb3.OnewayRequest + (*VoidRequest)(nil), // 14: pb3.VoidRequest + (*VoidResponse)(nil), // 15: pb3.VoidResponse + (*ExampleInt2Float)(nil), // 16: pb3.ExampleInt2Float + nil, // 17: pb3.InnerBase2.MapStringStringEntry + nil, // 18: pb3.InnerBase2.MapInt32StringEntry + nil, // 19: pb3.InnerBase2.MapUint32StringEntry + nil, // 20: pb3.InnerBase2.MapUint64StringEntry + nil, // 21: pb3.InnerBase2.MapInt64StringEntry + nil, // 22: pb3.InnerBase2.MapInt64BaseEntry + nil, // 23: pb3.InnerBase2.MapStringBaseEntry + nil, // 24: pb3.InnerBase2.MapInt64Sfixed64Entry + nil, // 25: pb3.InnerBase2.MapStringFixed32Entry + nil, // 26: pb3.InnerBasePartial.MapStringStringEntry + nil, // 27: pb3.InnerBasePartial.MapStringBaseEntry + nil, // 28: pb3.InnerBasePartial.MapStringString2Entry + (*base.Base)(nil), // 29: pb3.Base + (*base.TrafficEnv)(nil), // 30: pb3.TrafficEnv + (*base.BaseResp)(nil), // 31: pb3.BaseResp +} +var file_idl_example3_proto_depIdxs = []int32{ + 17, // 0: pb3.InnerBase2.MapStringString:type_name -> pb3.InnerBase2.MapStringStringEntry + 0, // 1: pb3.InnerBase2.Foo:type_name -> pb3.FOO + 18, // 2: pb3.InnerBase2.MapInt32String:type_name -> pb3.InnerBase2.MapInt32StringEntry + 19, // 3: pb3.InnerBase2.MapUint32String:type_name -> pb3.InnerBase2.MapUint32StringEntry + 20, // 4: pb3.InnerBase2.MapUint64String:type_name -> pb3.InnerBase2.MapUint64StringEntry + 21, // 5: pb3.InnerBase2.MapInt64String:type_name -> pb3.InnerBase2.MapInt64StringEntry + 22, // 6: pb3.InnerBase2.MapInt64Base:type_name -> pb3.InnerBase2.MapInt64BaseEntry + 23, // 7: pb3.InnerBase2.MapStringBase:type_name -> pb3.InnerBase2.MapStringBaseEntry + 29, // 8: pb3.InnerBase2.ListBase:type_name -> pb3.Base + 1, // 9: pb3.InnerBase2.ListInnerBase:type_name -> pb3.InnerBase2 + 24, // 10: pb3.InnerBase2.MapInt64Sfixed64:type_name -> pb3.InnerBase2.MapInt64Sfixed64Entry + 25, // 11: pb3.InnerBase2.MapStringFixed32:type_name -> pb3.InnerBase2.MapStringFixed32Entry + 29, // 12: pb3.InnerBase2.Base:type_name -> pb3.Base + 26, // 13: pb3.InnerBasePartial.MapStringString:type_name -> pb3.InnerBasePartial.MapStringStringEntry + 27, // 14: pb3.InnerBasePartial.MapStringBase:type_name -> pb3.InnerBasePartial.MapStringBaseEntry + 2, // 15: pb3.InnerBasePartial.ListInnerBase:type_name -> pb3.InnerBasePartial + 3, // 16: pb3.InnerBasePartial.ListBase:type_name -> pb3.BasePartial + 28, // 17: pb3.InnerBasePartial.MapStringString2:type_name -> pb3.InnerBasePartial.MapStringString2Entry + 30, // 18: pb3.BasePartial.TrafficEnv:type_name -> pb3.TrafficEnv + 1, // 19: pb3.ExampleReq.InnerBase2:type_name -> pb3.InnerBase2 + 29, // 20: pb3.ExampleReq.Base:type_name -> pb3.Base + 1, // 21: pb3.ExampleSuper.InnerBase2:type_name -> pb3.InnerBase2 + 6, // 22: pb3.ExampleSuper.SelfRef:type_name -> pb3.SelfRef + 29, // 23: pb3.ExampleSuper.Base:type_name -> pb3.Base + 6, // 24: pb3.SelfRef.self:type_name -> pb3.SelfRef + 2, // 25: pb3.ExampleReqPartial.InnerBase2:type_name -> pb3.InnerBasePartial + 3, // 26: pb3.ExampleReqPartial.Base:type_name -> pb3.BasePartial + 31, // 27: pb3.ExampleResp.BaseResp:type_name -> pb3.BaseResp + 31, // 28: pb3.ExampleRespPartial.BaseResp:type_name -> pb3.BaseResp + 11, // 29: pb3.A.self:type_name -> pb3.A + 29, // 30: pb3.InnerBase2.MapInt64BaseEntry.value:type_name -> pb3.Base + 29, // 31: pb3.InnerBase2.MapStringBaseEntry.value:type_name -> pb3.Base + 3, // 32: pb3.InnerBasePartial.MapStringBaseEntry.value:type_name -> pb3.BasePartial + 4, // 33: pb3.TestService2.ExampleMethod:input_type -> pb3.ExampleReq + 7, // 34: pb3.TestService2.ExamplePartialMethod:input_type -> pb3.ExampleReqPartial + 7, // 35: pb3.TestService2.ExamplePartialMethod2:input_type -> pb3.ExampleReqPartial + 5, // 36: pb3.TestService2.ExampleSuperMethod:input_type -> pb3.ExampleSuper + 16, // 37: pb3.TestService2.Int2FloatMethod:input_type -> pb3.ExampleInt2Float + 11, // 38: pb3.TestService2.Foo:input_type -> pb3.A + 11, // 39: pb3.TestService2.Ping:input_type -> pb3.A + 13, // 40: pb3.TestService2.Oneway:input_type -> pb3.OnewayRequest + 14, // 41: pb3.TestService2.Void:input_type -> pb3.VoidRequest + 8, // 42: pb3.TestService2.ExampleMethod:output_type -> pb3.ExampleResp + 11, // 43: pb3.TestService2.ExamplePartialMethod:output_type -> pb3.A + 9, // 44: pb3.TestService2.ExamplePartialMethod2:output_type -> pb3.ExampleRespPartial + 11, // 45: pb3.TestService2.ExampleSuperMethod:output_type -> pb3.A + 16, // 46: pb3.TestService2.Int2FloatMethod:output_type -> pb3.ExampleInt2Float + 11, // 47: pb3.TestService2.Foo:output_type -> pb3.A + 12, // 48: pb3.TestService2.Ping:output_type -> pb3.PingResponse + 15, // 49: pb3.TestService2.Oneway:output_type -> pb3.VoidResponse + 15, // 50: pb3.TestService2.Void:output_type -> pb3.VoidResponse + 42, // [42:51] is the sub-list for method output_type + 33, // [33:42] is the sub-list for method input_type + 33, // [33:33] is the sub-list for extension type_name + 33, // [33:33] is the sub-list for extension extendee + 0, // [0:33] is the sub-list for field type_name +} + +func init() { file_idl_example3_proto_init() } +func file_idl_example3_proto_init() { + if File_idl_example3_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_idl_example3_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*InnerBase2); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_idl_example3_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*InnerBasePartial); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_idl_example3_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*BasePartial); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_idl_example3_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ExampleReq); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_idl_example3_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ExampleSuper); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_idl_example3_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SelfRef); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_idl_example3_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ExampleReqPartial); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_idl_example3_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ExampleResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_idl_example3_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ExampleRespPartial); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_idl_example3_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Exception); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_idl_example3_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*A); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_idl_example3_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*PingResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_idl_example3_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*OnewayRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_idl_example3_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*VoidRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_idl_example3_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*VoidResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_idl_example3_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ExampleInt2Float); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_idl_example3_proto_rawDesc, + NumEnums: 1, + NumMessages: 28, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_idl_example3_proto_goTypes, + DependencyIndexes: file_idl_example3_proto_depIdxs, + EnumInfos: file_idl_example3_proto_enumTypes, + MessageInfos: file_idl_example3_proto_msgTypes, + }.Build() + File_idl_example3_proto = out.File + file_idl_example3_proto_rawDesc = nil + file_idl_example3_proto_goTypes = nil + file_idl_example3_proto_depIdxs = nil +} + +var _ context.Context + +// Code generated by Kitex v0.9.1. DO NOT EDIT. + +type TestService2 interface { + ExampleMethod(ctx context.Context, req *ExampleReq) (res *ExampleResp, err error) + ExamplePartialMethod(ctx context.Context, req *ExampleReqPartial) (res *A, err error) + ExamplePartialMethod2(ctx context.Context, req *ExampleReqPartial) (res *ExampleRespPartial, err error) + ExampleSuperMethod(ctx context.Context, req *ExampleSuper) (res *A, err error) + Int2FloatMethod(ctx context.Context, req *ExampleInt2Float) (res *ExampleInt2Float, err error) + Foo(ctx context.Context, req *A) (res *A, err error) + Ping(ctx context.Context, req *A) (res *PingResponse, err error) + Oneway(ctx context.Context, req *OnewayRequest) (res *VoidResponse, err error) + Void(ctx context.Context, req *VoidRequest) (res *VoidResponse, err error) +}