diff --git a/x/tx/CHANGELOG.md b/x/tx/CHANGELOG.md index baf46b9f622c..1e4a07892e7c 100644 --- a/x/tx/CHANGELOG.md +++ b/x/tx/CHANGELOG.md @@ -40,4 +40,4 @@ Ref: https://keepachangelog.com/en/1.0.0/ ## Improvements * [#15302](https://github.com/cosmos/cosmos-sdk/pull/15302) Add support for a custom registry (e.g. gogo's MergedRegistry) to be plugged into SIGN_MODE_TEXTUAL. - +* [#15557](https://github.com/cosmos/cosmos-sdk/pull/15557) Implement unknown field filtering. diff --git a/x/tx/decode/errors.go b/x/tx/decode/errors.go new file mode 100644 index 000000000000..f7fbcfcd29eb --- /dev/null +++ b/x/tx/decode/errors.go @@ -0,0 +1,11 @@ +package decode + +import "cosmossdk.io/errors" + +const ( + txCodespace = "tx" +) + +var ( + ErrUnknownField = errors.Register(txCodespace, 2, "unknown protobuf field") +) diff --git a/x/tx/decode/unknown.go b/x/tx/decode/unknown.go new file mode 100644 index 000000000000..2bdd453dad9d --- /dev/null +++ b/x/tx/decode/unknown.go @@ -0,0 +1,161 @@ +package decode + +import ( + "errors" + "fmt" + "strings" + + "google.golang.org/protobuf/encoding/protowire" + "google.golang.org/protobuf/proto" + "google.golang.org/protobuf/reflect/protodesc" + "google.golang.org/protobuf/reflect/protoreflect" + "google.golang.org/protobuf/types/known/anypb" +) + +const bit11NonCritical = 1 << 10 + +var anyDesc = (&anypb.Any{}).ProtoReflect().Descriptor() +var anyFullName = anyDesc.FullName() + +// RejectUnknownFieldsStrict operates by the same rules as RejectUnknownFields, but returns an error if any unknown +// non-critical fields are encountered. +func RejectUnknownFieldsStrict(bz []byte, msg protoreflect.MessageDescriptor, resolver protodesc.Resolver) error { + var _, err = RejectUnknownFields(bz, msg, false, resolver) + return err +} + +// RejectUnknownFields rejects any bytes bz with an error that has unknown fields for the provided proto.Message type with an +// option to allow non-critical fields (specified as those fields with bit 11) to pass through. In either case, the +// hasUnknownNonCriticals will be set to true if non-critical fields were encountered during traversal. This flag can be +// used to treat a message with non-critical field different in different security contexts (such as transaction signing). +// This function traverses inside of messages nested via google.protobuf.Any. It does not do any deserialization of the proto.Message. +// An AnyResolver must be provided for traversing inside google.protobuf.Any's. +func RejectUnknownFields(bz []byte, desc protoreflect.MessageDescriptor, allowUnknownNonCriticals bool, resolver protodesc.Resolver) (hasUnknownNonCriticals bool, err error) { + if len(bz) == 0 { + return hasUnknownNonCriticals, nil + } + + fields := desc.Fields() + + for len(bz) > 0 { + tagNum, wireType, m := protowire.ConsumeTag(bz) + if m < 0 { + return hasUnknownNonCriticals, errors.New("invalid length") + } + + fieldDesc := fields.ByNumber(tagNum) + if fieldDesc == nil { + isCriticalField := tagNum&bit11NonCritical == 0 + + if !isCriticalField { + hasUnknownNonCriticals = true + } + + if isCriticalField || !allowUnknownNonCriticals { + // The tag is critical, so report it. + return hasUnknownNonCriticals, ErrUnknownField.Wrapf( + "%s: {TagNum: %d, WireType:%q}", + desc.FullName(), tagNum, WireTypeToString(wireType)) + } + } + + // Skip over the bytes that store fieldNumber and wireType bytes. + bz = bz[m:] + n := protowire.ConsumeFieldValue(tagNum, wireType, bz) + if n < 0 { + err = fmt.Errorf("could not consume field value for tagNum: %d, wireType: %q; %w", + tagNum, WireTypeToString(wireType), protowire.ParseError(n)) + return hasUnknownNonCriticals, err + } + fieldBytes := bz[:n] + bz = bz[n:] + + // An unknown but non-critical field + if fieldDesc == nil { + continue + } + + fieldMessage := fieldDesc.Message() + // not message or group kind + if fieldMessage == nil { + continue + } + + // consume length prefix of nested message + _, o := protowire.ConsumeVarint(fieldBytes) + fieldBytes = fieldBytes[o:] + + var err error + + if fieldMessage.FullName() == anyFullName { + // Firstly typecheck types.Any to ensure nothing snuck in. + hasUnknownNonCriticalsChild, err := RejectUnknownFields(fieldBytes, anyDesc, allowUnknownNonCriticals, resolver) + hasUnknownNonCriticals = hasUnknownNonCriticals || hasUnknownNonCriticalsChild + if err != nil { + return hasUnknownNonCriticals, err + } + var a anypb.Any + if err = proto.Unmarshal(fieldBytes, &a); err != nil { + return hasUnknownNonCriticals, err + } + + msgName := protoreflect.FullName(strings.TrimPrefix(a.TypeUrl, "/")) + msgDesc, err := resolver.FindDescriptorByName(msgName) + if err != nil { + return hasUnknownNonCriticals, err + } + + fieldMessage = msgDesc.(protoreflect.MessageDescriptor) + fieldBytes = a.Value + } + + hasUnknownNonCriticalsChild, err := RejectUnknownFields(fieldBytes, fieldMessage, allowUnknownNonCriticals, resolver) + hasUnknownNonCriticals = hasUnknownNonCriticals || hasUnknownNonCriticalsChild + if err != nil { + return hasUnknownNonCriticals, err + } + } + + return hasUnknownNonCriticals, nil +} + +// errUnknownField represents an error indicating that we encountered +// a field that isn't available in the target proto.Message. +type errUnknownField struct { + Desc protoreflect.MessageDescriptor + TagNum protowire.Number + WireType protowire.Type +} + +// String implements fmt.Stringer. +func (twt *errUnknownField) String() string { + return fmt.Sprintf("errUnknownField %q: {TagNum: %d, WireType:%q}", + twt.Desc.FullName(), twt.TagNum, WireTypeToString(twt.WireType)) +} + +// Error implements the error interface. +func (twt *errUnknownField) Error() string { + return twt.String() +} + +var _ error = (*errUnknownField)(nil) + +// WireTypeToString returns a string representation of the given protowire.Type. +func WireTypeToString(wt protowire.Type) string { + switch wt { + case 0: + return "varint" + case 1: + return "fixed64" + case 2: + return "bytes" + case 3: + return "start_group" + case 4: + return "end_group" + case 5: + return "fixed32" + default: + return fmt.Sprintf("unknown type: %d", wt) + } +} diff --git a/x/tx/decode/unknown_test.go b/x/tx/decode/unknown_test.go new file mode 100644 index 000000000000..058147aaa962 --- /dev/null +++ b/x/tx/decode/unknown_test.go @@ -0,0 +1,674 @@ +package decode_test + +import ( + "fmt" + "testing" + + "github.com/stretchr/testify/require" + "google.golang.org/protobuf/encoding/protowire" + "google.golang.org/protobuf/proto" + "google.golang.org/protobuf/reflect/protoregistry" + "google.golang.org/protobuf/types/known/anypb" + + "cosmossdk.io/x/tx/decode" + "cosmossdk.io/x/tx/internal/testpb" +) + +func errUnknownField(typ string, tagNum int, wireType protowire.Type) error { + var wt string + if wireType >= 0 && wireType < 6 { + wt = decode.WireTypeToString(wireType) + } + return decode.ErrUnknownField.Wrapf("%s: {TagNum: %d, WireType:%q}", typ, tagNum, wt) +} + +func errMismatchedField(typ string, wireType protowire.Type) error { + return fmt.Errorf("invalid wire type %s for field %s", decode.WireTypeToString(wireType), typ) +} + +var ProtoResolver = protoregistry.GlobalFiles + +func TestRejectUnknownFieldsRepeated(t *testing.T) { + tests := []struct { + name string + in proto.Message + recv proto.Message + wantErr error + allowUnknownNonCriticals bool + hasUnknownNonCriticals bool + }{ + { + name: "Unknown field in midst of repeated values", + in: &testpb.TestVersion2{ + C: []*testpb.TestVersion2{ + { + C: []*testpb.TestVersion2{ + { + Sum: &testpb.TestVersion2_F{ + F: &testpb.TestVersion2{ + A: &testpb.TestVersion2{ + B: &testpb.TestVersion2{ + H: []*testpb.TestVersion1{ + { + X: 0x01, + }, + }, + }, + }, + }, + }, + }, + { + Sum: &testpb.TestVersion2_F{ + F: &testpb.TestVersion2{ + A: &testpb.TestVersion2{ + B: &testpb.TestVersion2{ + H: []*testpb.TestVersion1{ + { + X: 0x02, + }, + }, + }, + }, + }, + }, + }, + { + Sum: &testpb.TestVersion2_F{ + F: &testpb.TestVersion2{ + NewField_: 411, + }, + }, + }, + }, + }, + }, + }, + recv: new(testpb.TestVersion1), + wantErr: errUnknownField( + "testpb.TestVersion1", + 25, + 0), + }, + { + name: "Unknown field in midst of repeated values, allowUnknownNonCriticals set", + allowUnknownNonCriticals: true, + in: &testpb.TestVersion2{ + C: []*testpb.TestVersion2{ + { + C: []*testpb.TestVersion2{ + { + Sum: &testpb.TestVersion2_F{ + F: &testpb.TestVersion2{ + A: &testpb.TestVersion2{ + B: &testpb.TestVersion2{ + H: []*testpb.TestVersion1{ + { + X: 0x01, + }, + }, + }, + }, + }, + }, + }, + { + Sum: &testpb.TestVersion2_F{ + F: &testpb.TestVersion2{ + A: &testpb.TestVersion2{ + B: &testpb.TestVersion2{ + H: []*testpb.TestVersion1{ + { + X: 0x02, + }, + }, + }, + }, + }, + }, + }, + { + Sum: &testpb.TestVersion2_F{ + F: &testpb.TestVersion2{ + NewField_: 411, + }, + }, + }, + }, + }, + }, + }, + recv: new(testpb.TestVersion1), + wantErr: errUnknownField( + "testpb.TestVersion1", + 25, + 0), + }, + { + name: "Unknown field in midst of repeated values, non-critical field to be rejected", + in: &testpb.TestVersion3{ + C: []*testpb.TestVersion3{ + { + C: []*testpb.TestVersion3{ + { + Sum: &testpb.TestVersion3_F{ + F: &testpb.TestVersion3{ + A: &testpb.TestVersion3{ + B: &testpb.TestVersion3{ + X: 0x01, + }, + }, + }, + }, + }, + { + Sum: &testpb.TestVersion3_F{ + F: &testpb.TestVersion3{ + A: &testpb.TestVersion3{ + B: &testpb.TestVersion3{ + X: 0x02, + }, + }, + }, + }, + }, + { + Sum: &testpb.TestVersion3_F{ + F: &testpb.TestVersion3{ + NonCriticalField: "non-critical", + }, + }, + }, + }, + }, + }, + }, + recv: new(testpb.TestVersion1), + wantErr: errUnknownField( + "testpb.TestVersion1", + 1031, + 2), + hasUnknownNonCriticals: true, + }, + { + name: "Unknown field in midst of repeated values, non-critical field ignored", + allowUnknownNonCriticals: true, + in: &testpb.TestVersion3{ + C: []*testpb.TestVersion3{ + { + C: []*testpb.TestVersion3{ + { + Sum: &testpb.TestVersion3_F{ + F: &testpb.TestVersion3{ + A: &testpb.TestVersion3{ + B: &testpb.TestVersion3{ + X: 0x01, + }, + }, + }, + }, + }, + { + Sum: &testpb.TestVersion3_F{ + F: &testpb.TestVersion3{ + A: &testpb.TestVersion3{ + B: &testpb.TestVersion3{ + X: 0x02, + }, + }, + }, + }, + }, + { + Sum: &testpb.TestVersion3_F{ + F: &testpb.TestVersion3{ + NonCriticalField: "non-critical", + }, + }, + }, + }, + }, + }, + }, + recv: new(testpb.TestVersion1), + wantErr: nil, + hasUnknownNonCriticals: true, + }, + } + + for _, tt := range tests { + tt := tt + t.Run(tt.name, func(t *testing.T) { + protoBlob, err := proto.Marshal(tt.in) + if err != nil { + t.Fatal(err) + } + desc := tt.recv.ProtoReflect().Descriptor() + hasUnknownNonCriticals, gotErr := decode.RejectUnknownFields( + protoBlob, desc, tt.allowUnknownNonCriticals, ProtoResolver) + if tt.wantErr != nil { + require.EqualError(t, gotErr, tt.wantErr.Error()) + } else { + require.NoError(t, gotErr) + } + require.Equal(t, tt.hasUnknownNonCriticals, hasUnknownNonCriticals) + }) + } +} + +func TestRejectUnknownFields_allowUnknownNonCriticals(t *testing.T) { + tests := []struct { + name string + in proto.Message + allowUnknownNonCriticals bool + wantErr error + }{ + { + name: "Field that's in the reserved range, should fail by default", + in: &testpb.Customer2{ + Id: 289, + Reserved: 99, + }, + wantErr: errUnknownField( + "testpb.Customer1", + 1047, + 0), + }, + { + name: "Field that's in the reserved range, toggle allowUnknownNonCriticals", + allowUnknownNonCriticals: true, + in: &testpb.Customer2{ + Id: 289, + Reserved: 99, + }, + wantErr: nil, + }, + { + name: "Unknown fields that are critical, but with allowUnknownNonCriticals set", + allowUnknownNonCriticals: true, + in: &testpb.Customer2{ + Id: 289, + City: testpb.Customer2_PaloAlto, + }, + wantErr: errUnknownField( + "testpb.Customer1", + 6, + 0), + }, + } + + for _, tt := range tests { + tt := tt + t.Run(tt.name, func(t *testing.T) { + blob, err := proto.Marshal(tt.in) + if err != nil { + t.Fatalf("Failed to marshal input: %v", err) + } + + c1 := new(testpb.Customer1).ProtoReflect().Descriptor() + _, gotErr := decode.RejectUnknownFields(blob, c1, tt.allowUnknownNonCriticals, ProtoResolver) + if tt.wantErr != nil { + require.EqualError(t, gotErr, tt.wantErr.Error()) + } else { + require.NoError(t, gotErr) + } + }) + } +} + +func TestRejectUnknownFieldsNested(t *testing.T) { + tests := []struct { + name string + in proto.Message + recv proto.Message + wantErr error + }{ + { + name: "TestVersion3 from TestVersionFD1", + in: &testpb.TestVersion2{ + X: 5, + Sum: &testpb.TestVersion2_E{ + E: 100, + }, + H: []*testpb.TestVersion1{ + {X: 999}, + {X: -55}, + { + X: 102, + Sum: &testpb.TestVersion1_F{ + F: &testpb.TestVersion1{ + X: 4, + }, + }, + }, + }, + K: &testpb.Customer1{ + Id: 45, + Name: "customer1", + SubscriptionFee: 99, + }, + }, + recv: new(testpb.TestVersionFD1), + wantErr: errUnknownField( + "testpb.TestVersionFD1", + 12, + 2), + }, + { + name: "Alternating oneofs", + in: &testpb.TestVersion3{ + Sum: &testpb.TestVersion3_E{ + E: 99, + }, + }, + recv: new(testpb.TestVersion3LoneOneOfValue), + wantErr: nil, + }, + { + name: "Alternating oneofs mismatched field", + in: &testpb.TestVersion3{ + Sum: &testpb.TestVersion3_F{ + F: &testpb.TestVersion3{ + X: 99, + }, + }, + }, + recv: new(testpb.TestVersion3LoneOneOfValue), + wantErr: errUnknownField( + "testpb.TestVersion3LoneOneOfValue", + 7, + 2), + }, + { + name: "Discrepancy in a deeply nested one of field", + in: &testpb.TestVersion3{ + Sum: &testpb.TestVersion3_F{ + F: &testpb.TestVersion3{ + Sum: &testpb.TestVersion3_F{ + F: &testpb.TestVersion3{ + X: 19, + Sum: &testpb.TestVersion3_E{ + E: 99, + }, + }, + }, + }, + }, + }, + recv: new(testpb.TestVersion3LoneNesting), + wantErr: errUnknownField( + "testpb.TestVersion3LoneNesting", + 6, + 0), + }, + { + name: "unknown field types.Any in G", + in: &testpb.TestVersion3{ + G: &anypb.Any{ + TypeUrl: "/testpb.TestVersion1", + Value: mustMarshal(&testpb.TestVersion2{ + Sum: &testpb.TestVersion2_F{ + F: &testpb.TestVersion2{ + NewField_: 999, + }, + }, + }), + }, + }, + recv: new(testpb.TestVersion3), + wantErr: errUnknownField( + "testpb.TestVersion1", + 25, 0), + }, + { + name: "types.Any with extra fields", + in: &testpb.TestVersionFD1WithExtraAny{ + G: &testpb.AnyWithExtra{ + A: &anypb.Any{ + TypeUrl: "/testpb.TestVersion1", + Value: mustMarshal(&testpb.TestVersion2{ + Sum: &testpb.TestVersion2_F{ + F: &testpb.TestVersion2{ + NewField_: 999, + }, + }, + }), + }, + B: 3, + C: 2, + }, + }, + recv: new(testpb.TestVersion3), + wantErr: errUnknownField( + "google.protobuf.Any", + 3, + 0), + }, + { + name: "mismatched types.Any in G", + in: &testpb.TestVersion1{ + G: &anypb.Any{ + TypeUrl: "/testpb.TestVersion4LoneNesting", + Value: mustMarshal(&testpb.TestVersion3LoneNesting_Inner1{ + Inner: &testpb.TestVersion3LoneNesting_Inner1_InnerInner{ + Id: "ID", + City: "Gotham", + }, + }), + }, + }, + recv: new(testpb.TestVersion1), + // behavior change from previous implementation: we allow mismatched wire -> proto types, + // but this will still error on ConsumeFieldValue + wantErr: fmt.Errorf(`could not consume field value for tagNum: 8, wireType: "unknown type: 7"; proto: cannot parse reserved wire type`), + }, + { + name: "From nested proto message, message index 0", + in: &testpb.TestVersion3LoneNesting{ + Inner1: &testpb.TestVersion3LoneNesting_Inner1{ + Id: 10, + Name: "foo", + Inner: &testpb.TestVersion3LoneNesting_Inner1_InnerInner{ + Id: "ID", + City: "Palo Alto", + }, + }, + }, + recv: new(testpb.TestVersion4LoneNesting), + wantErr: nil, + }, + { + name: "From nested proto message, message index 1", + in: &testpb.TestVersion3LoneNesting{ + Inner2: &testpb.TestVersion3LoneNesting_Inner2{ + Id: "ID", + Country: "Maldives", + Inner: &testpb.TestVersion3LoneNesting_Inner2_InnerInner{ + Id: "ID", + City: "Unknown", + }, + }, + }, + recv: new(testpb.TestVersion4LoneNesting), + wantErr: nil, + }, + } + + for _, tt := range tests { + tt := tt + t.Run(tt.name, func(t *testing.T) { + protoBlob, err := proto.Marshal(tt.in) + if err != nil { + t.Fatal(err) + } + + desc := tt.recv.ProtoReflect().Descriptor() + gotErr := decode.RejectUnknownFieldsStrict(protoBlob, desc, ProtoResolver) + if tt.wantErr != nil { + require.EqualError(t, gotErr, tt.wantErr.Error()) + } else { + require.NoError(t, gotErr) + } + }) + } +} + +func TestRejectUnknownFieldsFlat(t *testing.T) { + tests := []struct { + name string + in proto.Message + wantErr error + }{ + { + name: "Oneof with same field number, shouldn't complain", + in: &testpb.Customer3{ + Id: 68, + Name: "ACME3", + Payment: &testpb.Customer3_CreditCardNo{ + CreditCardNo: "123-XXXX-XXX881", + }, + }, + wantErr: nil, + }, + { + name: "Oneof with different field number, should fail", + in: &testpb.Customer3{ + Id: 68, + Name: "ACME3", + Payment: &testpb.Customer3_ChequeNo{ + ChequeNo: "123XXXXXXX881", + }, + }, + wantErr: errUnknownField( + "testpb.Customer1", + 8, 2), + }, + { + name: "Any in a field, the extra field will be serialized so should fail", + in: &testpb.Customer2{ + Miscellaneous: &anypb.Any{}, + }, + wantErr: errUnknownField( + "testpb.Customer1", + 10, + 2), + }, + { + name: "With a nested struct as a field", + in: &testpb.Customer3{ + Id: 289, + Original: &testpb.Customer1{ + Id: 991, + }, + }, + wantErr: errUnknownField( + "testpb.Customer1", + 9, + 2), + }, + { + name: "An extra field that's non-existent in Customer1", + in: &testpb.Customer2{ + Id: 289, + Name: "Customer1", + Industry: 5299, + Fewer: 199.9, + }, + wantErr: errUnknownField("testpb.Customer1", 4, 5), + }, + { + name: "Using a field that's in the reserved range, should fail by default", + in: &testpb.Customer2{ + Id: 289, + Reserved: 99, + }, + wantErr: errUnknownField( + "testpb.Customer1", + 1047, + 0), + }, + { + name: "Only fields matching", + in: &testpb.Customer2{ + Id: 289, + Name: "CustomerCustomerCustomerCustomerCustomer11111Customer1", + }, + // behavior change from previous implementation: we allow mismatched wire -> proto types. + // wantErr: errMismatchedField("testpb.Customer1", 4, 5), + }, + { + name: "Extra field that's non-existent in Customer1, along with Reserved set", + in: &testpb.Customer2{ + Id: 289, + Name: "Customer1", + Industry: 5299, + Fewer: 199.9, + Reserved: 819, + }, + wantErr: errUnknownField("testpb.Customer1", 4, 5), + }, + { + name: "Using enumerated field", + in: &testpb.Customer2{ + Id: 289, + Name: "Customer1", + Industry: 5299, + City: testpb.Customer2_PaloAlto, + }, + wantErr: errUnknownField("testpb.Customer1", 6, 0), + }, + { + name: "multiple extraneous fields", + in: &testpb.Customer2{ + Id: 289, + Name: "Customer1", + Industry: 5299, + City: testpb.Customer2_PaloAlto, + Fewer: 45, + }, + wantErr: errUnknownField("testpb.Customer1", 4, 5), + }, + } + + for _, tt := range tests { + tt := tt + t.Run(tt.name, func(t *testing.T) { + blob, err := proto.Marshal(tt.in) + if err != nil { + t.Fatalf("Failed to marshal input: %v", err) + } + + c1 := new(testpb.Customer1) + c1Desc := c1.ProtoReflect().Descriptor() + //err = proto.Unmarshal(blob, c1) + //require.NoError(t, err) + gotErr := decode.RejectUnknownFieldsStrict(blob, c1Desc, ProtoResolver) + if tt.wantErr != nil { + require.EqualError(t, gotErr, tt.wantErr.Error()) + } else { + require.NoError(t, gotErr) + } + }) + } +} + +// Issue https://github.com/cosmos/cosmos-sdk/issues/7222, we need to ensure that repeated +// uint64 are recognized as packed. +func TestPackedEncoding(t *testing.T) { + data := &testpb.TestRepeatedUints{Nums: []uint64{12, 13}} + + marshalled, err := proto.Marshal(data) + require.NoError(t, err) + + unmarshalled := data.ProtoReflect().Descriptor() + _, err = decode.RejectUnknownFields(marshalled, unmarshalled, false, ProtoResolver) + require.NoError(t, err) +} + +func mustMarshal(msg proto.Message) []byte { + blob, err := proto.Marshal(msg) + if err != nil { + panic(err) + } + return blob +} diff --git a/x/tx/go.mod b/x/tx/go.mod index c7efe6ba02c7..28b554c90d65 100644 --- a/x/tx/go.mod +++ b/x/tx/go.mod @@ -5,6 +5,7 @@ go 1.20 require ( cosmossdk.io/api v0.3.2-0.20230313131911-55bf5d4efbe7 cosmossdk.io/core v0.6.1 + cosmossdk.io/errors v1.0.0-beta.7 cosmossdk.io/math v1.0.0 github.com/cosmos/cosmos-proto v1.0.0-beta.3 github.com/google/go-cmp v0.5.9 diff --git a/x/tx/go.sum b/x/tx/go.sum index f935d69ec6fa..ba2c42779fea 100644 --- a/x/tx/go.sum +++ b/x/tx/go.sum @@ -2,6 +2,8 @@ cosmossdk.io/api v0.3.2-0.20230313131911-55bf5d4efbe7 h1:4LrWK+uGP5IxznxtHHsHD+Z cosmossdk.io/api v0.3.2-0.20230313131911-55bf5d4efbe7/go.mod h1:yVns7mKgcsG+hZW/3C5FdJtC6QYWdFIcRlKb9+5HV5g= cosmossdk.io/core v0.6.1 h1:OBy7TI2W+/gyn2z40vVvruK3di+cAluinA6cybFbE7s= cosmossdk.io/core v0.6.1/go.mod h1:g3MMBCBXtxbDWBURDVnJE7XML4BG5qENhs0gzkcpuFA= +cosmossdk.io/errors v1.0.0-beta.7 h1:gypHW76pTQGVnHKo6QBkb4yFOJjC+sUGRc5Al3Odj1w= +cosmossdk.io/errors v1.0.0-beta.7/go.mod h1:mz6FQMJRku4bY7aqS/Gwfcmr/ue91roMEKAmDUDpBfE= cosmossdk.io/math v1.0.0 h1:ro9w7eKx23om2tZz/VM2Pf+z2WAbGX1yDQQOJ6iGeJw= cosmossdk.io/math v1.0.0/go.mod h1:Ygz4wBHrgc7g0N+8+MrnTfS9LLn9aaTGa9hKopuym5k= github.com/cosmos/cosmos-proto v1.0.0-beta.3 h1:VitvZ1lPORTVxkmF2fAp3IiA61xVwArQYKXTdEcpW6o= diff --git a/x/tx/internal/testpb/unknonwnproto.proto b/x/tx/internal/testpb/unknonwnproto.proto new file mode 100644 index 000000000000..fa177fcef59e --- /dev/null +++ b/x/tx/internal/testpb/unknonwnproto.proto @@ -0,0 +1,306 @@ +syntax = "proto3"; +package testpb; + +import "gogoproto/gogo.proto"; +import "google/protobuf/any.proto"; +import "cosmos/tx/v1beta1/tx.proto"; + +message Customer1 { + int32 id = 1; + string name = 2; + float subscription_fee = 3; + + string payment = 7; +} + +message Customer2 { + int32 id = 1; + int32 industry = 2; + string name = 3; + float fewer = 4; + + int64 reserved = 1047; + + enum City { + Laos = 0; + LosAngeles = 1; + PaloAlto = 2; + Moscow = 3; + Nairobi = 4; + } + + City city = 6; + + google.protobuf.Any miscellaneous = 10; +} + +message Nested4A { + int32 id = 1; + string name = 2; +} + +message Nested3A { + int32 id = 1; + string name = 2; + repeated Nested4A a4 = 4; + map index = 5; +} + +message Nested2A { + int32 id = 1; + string name = 2; + Nested3A nested = 3; +} + +message Nested1A { + int32 id = 1; + Nested2A nested = 2; +} + +message Nested4B { + int32 id = 1; + int32 age = 2; + string name = 3; +} + +message Nested3B { + int32 id = 1; + int32 age = 2; + string name = 3; + repeated Nested4B b4 = 4; +} + +message Nested2B { + int32 id = 1; + double fee = 2; + Nested3B nested = 3; + string route = 4; +} + +message Nested1B { + int32 id = 1; + Nested2B nested = 2; + int32 age = 3; +} + +message Customer3 { + int32 id = 1; + string name = 2; + float sf = 3; + float surcharge = 4; + string destination = 5; + + oneof payment { + string credit_card_no = 7; + string cheque_no = 8; + } + + Customer1 original = 9; +} + +message TestVersion1 { + int64 x = 1; + TestVersion1 a = 2; + TestVersion1 b = 3; // [(gogoproto.nullable) = false] generates invalid recursive structs; + repeated TestVersion1 c = 4; + repeated TestVersion1 d = 5 [(gogoproto.nullable) = false]; + oneof sum { + int32 e = 6; + TestVersion1 f = 7; + } + google.protobuf.Any g = 8; + repeated TestVersion1 h = 9; // [(gogoproto.castrepeated) = "TestVersion1"]; + // google.protobuf.Timestamp i = 10; + // google.protobuf.Timestamp j = 11; // [(gogoproto.stdtime) = true]; + Customer1 k = 12 [(gogoproto.embed) = true]; +} +message TestVersion2 { + int64 x = 1; + TestVersion2 a = 2; + TestVersion2 b = 3; // [(gogoproto.nullable) = false]; + repeated TestVersion2 c = 4; + repeated TestVersion2 d = 5; // [(gogoproto.nullable) = false]; + oneof sum { + int32 e = 6; + TestVersion2 f = 7; + } + google.protobuf.Any g = 8; + repeated TestVersion1 h = 9; // [(gogoproto.castrepeated) = "TestVersion1"]; + // google.protobuf.Timestamp i = 10; + // google.protobuf.Timestamp j = 11; // [(gogoproto.stdtime) = true]; + Customer1 k = 12 [(gogoproto.embed) = true]; + uint64 new_field = 25; +} +message TestVersion3 { + int64 x = 1; + TestVersion3 a = 2; + TestVersion3 b = 3; // [(gogoproto.nullable) = false]; + repeated TestVersion3 c = 4; + repeated TestVersion3 d = 5; // [(gogoproto.nullable) = false]; + oneof sum { + int32 e = 6; + TestVersion3 f = 7; + } + google.protobuf.Any g = 8; + repeated TestVersion1 h = 9; //[(gogoproto.castrepeated) = "TestVersion1"]; + // google.protobuf.Timestamp i = 10; + // google.protobuf.Timestamp j = 11; // [(gogoproto.stdtime) = true]; + Customer1 k = 12 [(gogoproto.embed) = true]; + string non_critical_field = 1031; +} + +message TestVersion3LoneOneOfValue { + int64 x = 1; + TestVersion3 a = 2; + TestVersion3 b = 3; // [(gogoproto.nullable) = false]; + repeated TestVersion3 c = 4; + repeated TestVersion3 d = 5; // [(gogoproto.nullable) = false]; + oneof sum { + int32 e = 6; + } + google.protobuf.Any g = 8; + repeated TestVersion1 h = 9; //[(gogoproto.castrepeated) = "TestVersion1"]; + // google.protobuf.Timestamp i = 10; + // google.protobuf.Timestamp j = 11; // [(gogoproto.stdtime) = true]; + Customer1 k = 12 [(gogoproto.embed) = true]; + string non_critical_field = 1031; +} + +message TestVersion3LoneNesting { + int64 x = 1; + TestVersion3 a = 2; + TestVersion3 b = 3; // [(gogoproto.nullable) = false]; + repeated TestVersion3 c = 4; + repeated TestVersion3 d = 5; // [(gogoproto.nullable) = false]; + oneof sum { + TestVersion3LoneNesting f = 7; + } + google.protobuf.Any g = 8; + repeated TestVersion1 h = 9; //[(gogoproto.castrepeated) = "TestVersion1"]; + // google.protobuf.Timestamp i = 10; + // google.protobuf.Timestamp j = 11; // [(gogoproto.stdtime) = true]; + Customer1 k = 12 [(gogoproto.embed) = true]; + string non_critical_field = 1031; + + message Inner1 { + int64 id = 1; + string name = 2; + message InnerInner { + string id = 1; + string city = 2; + } + InnerInner inner = 3; + } + + Inner1 inner1 = 14; + + message Inner2 { + string id = 1; + string country = 2; + message InnerInner { + string id = 1; + string city = 2; + } + InnerInner inner = 3; + } + + Inner2 inner2 = 15; +} + +message TestVersion4LoneNesting { + int64 x = 1; + TestVersion3 a = 2; + TestVersion3 b = 3; // [(gogoproto.nullable) = false]; + repeated TestVersion3 c = 4; + repeated TestVersion3 d = 5; // [(gogoproto.nullable) = false]; + oneof sum { + TestVersion3LoneNesting f = 7; + } + google.protobuf.Any g = 8; + repeated TestVersion1 h = 9; //[(gogoproto.castrepeated) = "TestVersion1"]; + // google.protobuf.Timestamp i = 10; + // google.protobuf.Timestamp j = 11; // [(gogoproto.stdtime) = true]; + Customer1 k = 12 [(gogoproto.embed) = true]; + string non_critical_field = 1031; + + message Inner1 { + int64 id = 1; + string name = 2; + message InnerInner { + int64 id = 1; + string city = 2; + } + InnerInner inner = 3; + } + + Inner1 inner1 = 14; + + message Inner2 { + string id = 1; + string country = 2; + message InnerInner { + string id = 1; + int64 value = 2; + } + InnerInner inner = 3; + } + + Inner2 inner2 = 15; +} + +message TestVersionFD1 { + int64 x = 1; + TestVersion1 a = 2; + oneof sum { + int32 e = 6; + TestVersion1 f = 7; + } + google.protobuf.Any g = 8; + repeated TestVersion1 h = 9; // [(gogoproto.castrepeated) = "TestVersion1"]; +} + +message TestVersionFD1WithExtraAny { + int64 x = 1; + TestVersion1 a = 2; + oneof sum { + int32 e = 6; + TestVersion1 f = 7; + } + AnyWithExtra g = 8; + repeated TestVersion1 h = 9; // [(gogoproto.castrepeated) = "TestVersion1"]; +} + +message AnyWithExtra { + google.protobuf.Any a = 1 [(gogoproto.embed) = true]; + int64 b = 3; + int64 c = 4; +} + +message TestUpdatedTxRaw { + bytes body_bytes = 1; + bytes auth_info_bytes = 2; + repeated bytes signatures = 3; + bytes new_field_5 = 5; + bytes new_field_1024 = 1024; +} + +message TestUpdatedTxBody { + repeated google.protobuf.Any messages = 1; + string memo = 2; + int64 timeout_height = 3; + uint64 some_new_field = 4; + string some_new_field_non_critical_field = 1050; + repeated google.protobuf.Any extension_options = 1023; + repeated google.protobuf.Any non_critical_extension_options = 2047; +} + +message TestUpdatedAuthInfo { + repeated cosmos.tx.v1beta1.SignerInfo signer_infos = 1; + cosmos.tx.v1beta1.Fee fee = 2; + bytes new_field_3 = 3; + bytes new_field_1024 = 1024; +} + +message TestRepeatedUints { + repeated uint64 nums = 1; +} diff --git a/x/tx/internal/testpb/unknonwnproto.pulsar.go b/x/tx/internal/testpb/unknonwnproto.pulsar.go new file mode 100644 index 000000000000..6ffc0245df4e --- /dev/null +++ b/x/tx/internal/testpb/unknonwnproto.pulsar.go @@ -0,0 +1,28039 @@ +// Code generated by protoc-gen-go-pulsar. DO NOT EDIT. +package testpb + +import ( + v1beta1 "cosmossdk.io/api/cosmos/tx/v1beta1" + binary "encoding/binary" + fmt "fmt" + runtime "github.com/cosmos/cosmos-proto/runtime" + _ "github.com/cosmos/gogoproto/gogoproto" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoiface "google.golang.org/protobuf/runtime/protoiface" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + anypb "google.golang.org/protobuf/types/known/anypb" + io "io" + math "math" + reflect "reflect" + sort "sort" + sync "sync" +) + +var ( + md_Customer1 protoreflect.MessageDescriptor + fd_Customer1_id protoreflect.FieldDescriptor + fd_Customer1_name protoreflect.FieldDescriptor + fd_Customer1_subscription_fee protoreflect.FieldDescriptor + fd_Customer1_payment protoreflect.FieldDescriptor +) + +func init() { + file_unknonwnproto_proto_init() + md_Customer1 = File_unknonwnproto_proto.Messages().ByName("Customer1") + fd_Customer1_id = md_Customer1.Fields().ByName("id") + fd_Customer1_name = md_Customer1.Fields().ByName("name") + fd_Customer1_subscription_fee = md_Customer1.Fields().ByName("subscription_fee") + fd_Customer1_payment = md_Customer1.Fields().ByName("payment") +} + +var _ protoreflect.Message = (*fastReflection_Customer1)(nil) + +type fastReflection_Customer1 Customer1 + +func (x *Customer1) ProtoReflect() protoreflect.Message { + return (*fastReflection_Customer1)(x) +} + +func (x *Customer1) slowProtoReflect() protoreflect.Message { + mi := &file_unknonwnproto_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) +} + +var _fastReflection_Customer1_messageType fastReflection_Customer1_messageType +var _ protoreflect.MessageType = fastReflection_Customer1_messageType{} + +type fastReflection_Customer1_messageType struct{} + +func (x fastReflection_Customer1_messageType) Zero() protoreflect.Message { + return (*fastReflection_Customer1)(nil) +} +func (x fastReflection_Customer1_messageType) New() protoreflect.Message { + return new(fastReflection_Customer1) +} +func (x fastReflection_Customer1_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_Customer1 +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_Customer1) Descriptor() protoreflect.MessageDescriptor { + return md_Customer1 +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_Customer1) Type() protoreflect.MessageType { + return _fastReflection_Customer1_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_Customer1) New() protoreflect.Message { + return new(fastReflection_Customer1) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_Customer1) Interface() protoreflect.ProtoMessage { + return (*Customer1)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_Customer1) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Id != int32(0) { + value := protoreflect.ValueOfInt32(x.Id) + if !f(fd_Customer1_id, value) { + return + } + } + if x.Name != "" { + value := protoreflect.ValueOfString(x.Name) + if !f(fd_Customer1_name, value) { + return + } + } + if x.SubscriptionFee != float32(0) || math.Signbit(float64(x.SubscriptionFee)) { + value := protoreflect.ValueOfFloat32(x.SubscriptionFee) + if !f(fd_Customer1_subscription_fee, value) { + return + } + } + if x.Payment != "" { + value := protoreflect.ValueOfString(x.Payment) + if !f(fd_Customer1_payment, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_Customer1) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "testpb.Customer1.id": + return x.Id != int32(0) + case "testpb.Customer1.name": + return x.Name != "" + case "testpb.Customer1.subscription_fee": + return x.SubscriptionFee != float32(0) || math.Signbit(float64(x.SubscriptionFee)) + case "testpb.Customer1.payment": + return x.Payment != "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Customer1")) + } + panic(fmt.Errorf("message testpb.Customer1 does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_Customer1) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "testpb.Customer1.id": + x.Id = int32(0) + case "testpb.Customer1.name": + x.Name = "" + case "testpb.Customer1.subscription_fee": + x.SubscriptionFee = float32(0) + case "testpb.Customer1.payment": + x.Payment = "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Customer1")) + } + panic(fmt.Errorf("message testpb.Customer1 does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_Customer1) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "testpb.Customer1.id": + value := x.Id + return protoreflect.ValueOfInt32(value) + case "testpb.Customer1.name": + value := x.Name + return protoreflect.ValueOfString(value) + case "testpb.Customer1.subscription_fee": + value := x.SubscriptionFee + return protoreflect.ValueOfFloat32(value) + case "testpb.Customer1.payment": + value := x.Payment + return protoreflect.ValueOfString(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Customer1")) + } + panic(fmt.Errorf("message testpb.Customer1 does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_Customer1) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "testpb.Customer1.id": + x.Id = int32(value.Int()) + case "testpb.Customer1.name": + x.Name = value.Interface().(string) + case "testpb.Customer1.subscription_fee": + x.SubscriptionFee = float32(value.Float()) + case "testpb.Customer1.payment": + x.Payment = value.Interface().(string) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Customer1")) + } + panic(fmt.Errorf("message testpb.Customer1 does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_Customer1) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.Customer1.id": + panic(fmt.Errorf("field id of message testpb.Customer1 is not mutable")) + case "testpb.Customer1.name": + panic(fmt.Errorf("field name of message testpb.Customer1 is not mutable")) + case "testpb.Customer1.subscription_fee": + panic(fmt.Errorf("field subscription_fee of message testpb.Customer1 is not mutable")) + case "testpb.Customer1.payment": + panic(fmt.Errorf("field payment of message testpb.Customer1 is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Customer1")) + } + panic(fmt.Errorf("message testpb.Customer1 does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_Customer1) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.Customer1.id": + return protoreflect.ValueOfInt32(int32(0)) + case "testpb.Customer1.name": + return protoreflect.ValueOfString("") + case "testpb.Customer1.subscription_fee": + return protoreflect.ValueOfFloat32(float32(0)) + case "testpb.Customer1.payment": + return protoreflect.ValueOfString("") + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Customer1")) + } + panic(fmt.Errorf("message testpb.Customer1 does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_Customer1) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in testpb.Customer1", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_Customer1) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_Customer1) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_Customer1) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_Customer1) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*Customer1) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + if x.Id != 0 { + n += 1 + runtime.Sov(uint64(x.Id)) + } + l = len(x.Name) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.SubscriptionFee != 0 || math.Signbit(float64(x.SubscriptionFee)) { + n += 5 + } + l = len(x.Payment) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*Customer1) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if len(x.Payment) > 0 { + i -= len(x.Payment) + copy(dAtA[i:], x.Payment) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Payment))) + i-- + dAtA[i] = 0x3a + } + if x.SubscriptionFee != 0 || math.Signbit(float64(x.SubscriptionFee)) { + i -= 4 + binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(x.SubscriptionFee)))) + i-- + dAtA[i] = 0x1d + } + if len(x.Name) > 0 { + i -= len(x.Name) + copy(dAtA[i:], x.Name) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Name))) + i-- + dAtA[i] = 0x12 + } + if x.Id != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.Id)) + i-- + dAtA[i] = 0x8 + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*Customer1) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Customer1: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Customer1: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + x.Id = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.Id |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 5 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field SubscriptionFee", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + v = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:])) + iNdEx += 4 + x.SubscriptionFee = float32(math.Float32frombits(v)) + case 7: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Payment", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Payment = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var ( + md_Customer2 protoreflect.MessageDescriptor + fd_Customer2_id protoreflect.FieldDescriptor + fd_Customer2_industry protoreflect.FieldDescriptor + fd_Customer2_name protoreflect.FieldDescriptor + fd_Customer2_fewer protoreflect.FieldDescriptor + fd_Customer2_reserved protoreflect.FieldDescriptor + fd_Customer2_city protoreflect.FieldDescriptor + fd_Customer2_miscellaneous protoreflect.FieldDescriptor +) + +func init() { + file_unknonwnproto_proto_init() + md_Customer2 = File_unknonwnproto_proto.Messages().ByName("Customer2") + fd_Customer2_id = md_Customer2.Fields().ByName("id") + fd_Customer2_industry = md_Customer2.Fields().ByName("industry") + fd_Customer2_name = md_Customer2.Fields().ByName("name") + fd_Customer2_fewer = md_Customer2.Fields().ByName("fewer") + fd_Customer2_reserved = md_Customer2.Fields().ByName("reserved") + fd_Customer2_city = md_Customer2.Fields().ByName("city") + fd_Customer2_miscellaneous = md_Customer2.Fields().ByName("miscellaneous") +} + +var _ protoreflect.Message = (*fastReflection_Customer2)(nil) + +type fastReflection_Customer2 Customer2 + +func (x *Customer2) ProtoReflect() protoreflect.Message { + return (*fastReflection_Customer2)(x) +} + +func (x *Customer2) slowProtoReflect() protoreflect.Message { + mi := &file_unknonwnproto_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) +} + +var _fastReflection_Customer2_messageType fastReflection_Customer2_messageType +var _ protoreflect.MessageType = fastReflection_Customer2_messageType{} + +type fastReflection_Customer2_messageType struct{} + +func (x fastReflection_Customer2_messageType) Zero() protoreflect.Message { + return (*fastReflection_Customer2)(nil) +} +func (x fastReflection_Customer2_messageType) New() protoreflect.Message { + return new(fastReflection_Customer2) +} +func (x fastReflection_Customer2_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_Customer2 +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_Customer2) Descriptor() protoreflect.MessageDescriptor { + return md_Customer2 +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_Customer2) Type() protoreflect.MessageType { + return _fastReflection_Customer2_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_Customer2) New() protoreflect.Message { + return new(fastReflection_Customer2) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_Customer2) Interface() protoreflect.ProtoMessage { + return (*Customer2)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_Customer2) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Id != int32(0) { + value := protoreflect.ValueOfInt32(x.Id) + if !f(fd_Customer2_id, value) { + return + } + } + if x.Industry != int32(0) { + value := protoreflect.ValueOfInt32(x.Industry) + if !f(fd_Customer2_industry, value) { + return + } + } + if x.Name != "" { + value := protoreflect.ValueOfString(x.Name) + if !f(fd_Customer2_name, value) { + return + } + } + if x.Fewer != float32(0) || math.Signbit(float64(x.Fewer)) { + value := protoreflect.ValueOfFloat32(x.Fewer) + if !f(fd_Customer2_fewer, value) { + return + } + } + if x.Reserved != int64(0) { + value := protoreflect.ValueOfInt64(x.Reserved) + if !f(fd_Customer2_reserved, value) { + return + } + } + if x.City != 0 { + value := protoreflect.ValueOfEnum((protoreflect.EnumNumber)(x.City)) + if !f(fd_Customer2_city, value) { + return + } + } + if x.Miscellaneous != nil { + value := protoreflect.ValueOfMessage(x.Miscellaneous.ProtoReflect()) + if !f(fd_Customer2_miscellaneous, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_Customer2) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "testpb.Customer2.id": + return x.Id != int32(0) + case "testpb.Customer2.industry": + return x.Industry != int32(0) + case "testpb.Customer2.name": + return x.Name != "" + case "testpb.Customer2.fewer": + return x.Fewer != float32(0) || math.Signbit(float64(x.Fewer)) + case "testpb.Customer2.reserved": + return x.Reserved != int64(0) + case "testpb.Customer2.city": + return x.City != 0 + case "testpb.Customer2.miscellaneous": + return x.Miscellaneous != nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Customer2")) + } + panic(fmt.Errorf("message testpb.Customer2 does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_Customer2) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "testpb.Customer2.id": + x.Id = int32(0) + case "testpb.Customer2.industry": + x.Industry = int32(0) + case "testpb.Customer2.name": + x.Name = "" + case "testpb.Customer2.fewer": + x.Fewer = float32(0) + case "testpb.Customer2.reserved": + x.Reserved = int64(0) + case "testpb.Customer2.city": + x.City = 0 + case "testpb.Customer2.miscellaneous": + x.Miscellaneous = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Customer2")) + } + panic(fmt.Errorf("message testpb.Customer2 does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_Customer2) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "testpb.Customer2.id": + value := x.Id + return protoreflect.ValueOfInt32(value) + case "testpb.Customer2.industry": + value := x.Industry + return protoreflect.ValueOfInt32(value) + case "testpb.Customer2.name": + value := x.Name + return protoreflect.ValueOfString(value) + case "testpb.Customer2.fewer": + value := x.Fewer + return protoreflect.ValueOfFloat32(value) + case "testpb.Customer2.reserved": + value := x.Reserved + return protoreflect.ValueOfInt64(value) + case "testpb.Customer2.city": + value := x.City + return protoreflect.ValueOfEnum((protoreflect.EnumNumber)(value)) + case "testpb.Customer2.miscellaneous": + value := x.Miscellaneous + return protoreflect.ValueOfMessage(value.ProtoReflect()) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Customer2")) + } + panic(fmt.Errorf("message testpb.Customer2 does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_Customer2) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "testpb.Customer2.id": + x.Id = int32(value.Int()) + case "testpb.Customer2.industry": + x.Industry = int32(value.Int()) + case "testpb.Customer2.name": + x.Name = value.Interface().(string) + case "testpb.Customer2.fewer": + x.Fewer = float32(value.Float()) + case "testpb.Customer2.reserved": + x.Reserved = value.Int() + case "testpb.Customer2.city": + x.City = (Customer2_City)(value.Enum()) + case "testpb.Customer2.miscellaneous": + x.Miscellaneous = value.Message().Interface().(*anypb.Any) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Customer2")) + } + panic(fmt.Errorf("message testpb.Customer2 does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_Customer2) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.Customer2.miscellaneous": + if x.Miscellaneous == nil { + x.Miscellaneous = new(anypb.Any) + } + return protoreflect.ValueOfMessage(x.Miscellaneous.ProtoReflect()) + case "testpb.Customer2.id": + panic(fmt.Errorf("field id of message testpb.Customer2 is not mutable")) + case "testpb.Customer2.industry": + panic(fmt.Errorf("field industry of message testpb.Customer2 is not mutable")) + case "testpb.Customer2.name": + panic(fmt.Errorf("field name of message testpb.Customer2 is not mutable")) + case "testpb.Customer2.fewer": + panic(fmt.Errorf("field fewer of message testpb.Customer2 is not mutable")) + case "testpb.Customer2.reserved": + panic(fmt.Errorf("field reserved of message testpb.Customer2 is not mutable")) + case "testpb.Customer2.city": + panic(fmt.Errorf("field city of message testpb.Customer2 is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Customer2")) + } + panic(fmt.Errorf("message testpb.Customer2 does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_Customer2) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.Customer2.id": + return protoreflect.ValueOfInt32(int32(0)) + case "testpb.Customer2.industry": + return protoreflect.ValueOfInt32(int32(0)) + case "testpb.Customer2.name": + return protoreflect.ValueOfString("") + case "testpb.Customer2.fewer": + return protoreflect.ValueOfFloat32(float32(0)) + case "testpb.Customer2.reserved": + return protoreflect.ValueOfInt64(int64(0)) + case "testpb.Customer2.city": + return protoreflect.ValueOfEnum(0) + case "testpb.Customer2.miscellaneous": + m := new(anypb.Any) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Customer2")) + } + panic(fmt.Errorf("message testpb.Customer2 does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_Customer2) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in testpb.Customer2", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_Customer2) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_Customer2) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_Customer2) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_Customer2) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*Customer2) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + if x.Id != 0 { + n += 1 + runtime.Sov(uint64(x.Id)) + } + if x.Industry != 0 { + n += 1 + runtime.Sov(uint64(x.Industry)) + } + l = len(x.Name) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.Fewer != 0 || math.Signbit(float64(x.Fewer)) { + n += 5 + } + if x.Reserved != 0 { + n += 2 + runtime.Sov(uint64(x.Reserved)) + } + if x.City != 0 { + n += 1 + runtime.Sov(uint64(x.City)) + } + if x.Miscellaneous != nil { + l = options.Size(x.Miscellaneous) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*Customer2) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if x.Reserved != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.Reserved)) + i-- + dAtA[i] = 0x41 + i-- + dAtA[i] = 0xb8 + } + if x.Miscellaneous != nil { + encoded, err := options.Marshal(x.Miscellaneous) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x52 + } + if x.City != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.City)) + i-- + dAtA[i] = 0x30 + } + if x.Fewer != 0 || math.Signbit(float64(x.Fewer)) { + i -= 4 + binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(x.Fewer)))) + i-- + dAtA[i] = 0x25 + } + if len(x.Name) > 0 { + i -= len(x.Name) + copy(dAtA[i:], x.Name) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Name))) + i-- + dAtA[i] = 0x1a + } + if x.Industry != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.Industry)) + i-- + dAtA[i] = 0x10 + } + if x.Id != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.Id)) + i-- + dAtA[i] = 0x8 + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*Customer2) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Customer2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Customer2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + x.Id = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.Id |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Industry", wireType) + } + x.Industry = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.Industry |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 5 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Fewer", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + v = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:])) + iNdEx += 4 + x.Fewer = float32(math.Float32frombits(v)) + case 1047: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Reserved", wireType) + } + x.Reserved = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.Reserved |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 6: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field City", wireType) + } + x.City = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.City |= Customer2_City(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 10: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Miscellaneous", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.Miscellaneous == nil { + x.Miscellaneous = &anypb.Any{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Miscellaneous); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var ( + md_Nested4A protoreflect.MessageDescriptor + fd_Nested4A_id protoreflect.FieldDescriptor + fd_Nested4A_name protoreflect.FieldDescriptor +) + +func init() { + file_unknonwnproto_proto_init() + md_Nested4A = File_unknonwnproto_proto.Messages().ByName("Nested4A") + fd_Nested4A_id = md_Nested4A.Fields().ByName("id") + fd_Nested4A_name = md_Nested4A.Fields().ByName("name") +} + +var _ protoreflect.Message = (*fastReflection_Nested4A)(nil) + +type fastReflection_Nested4A Nested4A + +func (x *Nested4A) ProtoReflect() protoreflect.Message { + return (*fastReflection_Nested4A)(x) +} + +func (x *Nested4A) slowProtoReflect() protoreflect.Message { + mi := &file_unknonwnproto_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) +} + +var _fastReflection_Nested4A_messageType fastReflection_Nested4A_messageType +var _ protoreflect.MessageType = fastReflection_Nested4A_messageType{} + +type fastReflection_Nested4A_messageType struct{} + +func (x fastReflection_Nested4A_messageType) Zero() protoreflect.Message { + return (*fastReflection_Nested4A)(nil) +} +func (x fastReflection_Nested4A_messageType) New() protoreflect.Message { + return new(fastReflection_Nested4A) +} +func (x fastReflection_Nested4A_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_Nested4A +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_Nested4A) Descriptor() protoreflect.MessageDescriptor { + return md_Nested4A +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_Nested4A) Type() protoreflect.MessageType { + return _fastReflection_Nested4A_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_Nested4A) New() protoreflect.Message { + return new(fastReflection_Nested4A) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_Nested4A) Interface() protoreflect.ProtoMessage { + return (*Nested4A)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_Nested4A) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Id != int32(0) { + value := protoreflect.ValueOfInt32(x.Id) + if !f(fd_Nested4A_id, value) { + return + } + } + if x.Name != "" { + value := protoreflect.ValueOfString(x.Name) + if !f(fd_Nested4A_name, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_Nested4A) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "testpb.Nested4A.id": + return x.Id != int32(0) + case "testpb.Nested4A.name": + return x.Name != "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested4A")) + } + panic(fmt.Errorf("message testpb.Nested4A does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_Nested4A) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "testpb.Nested4A.id": + x.Id = int32(0) + case "testpb.Nested4A.name": + x.Name = "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested4A")) + } + panic(fmt.Errorf("message testpb.Nested4A does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_Nested4A) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "testpb.Nested4A.id": + value := x.Id + return protoreflect.ValueOfInt32(value) + case "testpb.Nested4A.name": + value := x.Name + return protoreflect.ValueOfString(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested4A")) + } + panic(fmt.Errorf("message testpb.Nested4A does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_Nested4A) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "testpb.Nested4A.id": + x.Id = int32(value.Int()) + case "testpb.Nested4A.name": + x.Name = value.Interface().(string) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested4A")) + } + panic(fmt.Errorf("message testpb.Nested4A does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_Nested4A) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.Nested4A.id": + panic(fmt.Errorf("field id of message testpb.Nested4A is not mutable")) + case "testpb.Nested4A.name": + panic(fmt.Errorf("field name of message testpb.Nested4A is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested4A")) + } + panic(fmt.Errorf("message testpb.Nested4A does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_Nested4A) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.Nested4A.id": + return protoreflect.ValueOfInt32(int32(0)) + case "testpb.Nested4A.name": + return protoreflect.ValueOfString("") + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested4A")) + } + panic(fmt.Errorf("message testpb.Nested4A does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_Nested4A) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in testpb.Nested4A", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_Nested4A) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_Nested4A) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_Nested4A) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_Nested4A) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*Nested4A) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + if x.Id != 0 { + n += 1 + runtime.Sov(uint64(x.Id)) + } + l = len(x.Name) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*Nested4A) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if len(x.Name) > 0 { + i -= len(x.Name) + copy(dAtA[i:], x.Name) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Name))) + i-- + dAtA[i] = 0x12 + } + if x.Id != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.Id)) + i-- + dAtA[i] = 0x8 + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*Nested4A) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Nested4A: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Nested4A: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + x.Id = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.Id |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var _ protoreflect.List = (*_Nested3A_4_list)(nil) + +type _Nested3A_4_list struct { + list *[]*Nested4A +} + +func (x *_Nested3A_4_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_Nested3A_4_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_Nested3A_4_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*Nested4A) + (*x.list)[i] = concreteValue +} + +func (x *_Nested3A_4_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*Nested4A) + *x.list = append(*x.list, concreteValue) +} + +func (x *_Nested3A_4_list) AppendMutable() protoreflect.Value { + v := new(Nested4A) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_Nested3A_4_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_Nested3A_4_list) NewElement() protoreflect.Value { + v := new(Nested4A) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_Nested3A_4_list) IsValid() bool { + return x.list != nil +} + +var _ protoreflect.Map = (*_Nested3A_5_map)(nil) + +type _Nested3A_5_map struct { + m *map[int64]*Nested4A +} + +func (x *_Nested3A_5_map) Len() int { + if x.m == nil { + return 0 + } + return len(*x.m) +} + +func (x *_Nested3A_5_map) Range(f func(protoreflect.MapKey, protoreflect.Value) bool) { + if x.m == nil { + return + } + for k, v := range *x.m { + mapKey := (protoreflect.MapKey)(protoreflect.ValueOfInt64(k)) + mapValue := protoreflect.ValueOfMessage(v.ProtoReflect()) + if !f(mapKey, mapValue) { + break + } + } +} + +func (x *_Nested3A_5_map) Has(key protoreflect.MapKey) bool { + if x.m == nil { + return false + } + keyUnwrapped := key.Int() + concreteValue := keyUnwrapped + _, ok := (*x.m)[concreteValue] + return ok +} + +func (x *_Nested3A_5_map) Clear(key protoreflect.MapKey) { + if x.m == nil { + return + } + keyUnwrapped := key.Int() + concreteKey := keyUnwrapped + delete(*x.m, concreteKey) +} + +func (x *_Nested3A_5_map) Get(key protoreflect.MapKey) protoreflect.Value { + if x.m == nil { + return protoreflect.Value{} + } + keyUnwrapped := key.Int() + concreteKey := keyUnwrapped + v, ok := (*x.m)[concreteKey] + if !ok { + return protoreflect.Value{} + } + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_Nested3A_5_map) Set(key protoreflect.MapKey, value protoreflect.Value) { + if !key.IsValid() || !value.IsValid() { + panic("invalid key or value provided") + } + keyUnwrapped := key.Int() + concreteKey := keyUnwrapped + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*Nested4A) + (*x.m)[concreteKey] = concreteValue +} + +func (x *_Nested3A_5_map) Mutable(key protoreflect.MapKey) protoreflect.Value { + keyUnwrapped := key.Int() + concreteKey := keyUnwrapped + v, ok := (*x.m)[concreteKey] + if ok { + return protoreflect.ValueOfMessage(v.ProtoReflect()) + } + newValue := new(Nested4A) + (*x.m)[concreteKey] = newValue + return protoreflect.ValueOfMessage(newValue.ProtoReflect()) +} + +func (x *_Nested3A_5_map) NewValue() protoreflect.Value { + v := new(Nested4A) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_Nested3A_5_map) IsValid() bool { + return x.m != nil +} + +var ( + md_Nested3A protoreflect.MessageDescriptor + fd_Nested3A_id protoreflect.FieldDescriptor + fd_Nested3A_name protoreflect.FieldDescriptor + fd_Nested3A_a4 protoreflect.FieldDescriptor + fd_Nested3A_index protoreflect.FieldDescriptor +) + +func init() { + file_unknonwnproto_proto_init() + md_Nested3A = File_unknonwnproto_proto.Messages().ByName("Nested3A") + fd_Nested3A_id = md_Nested3A.Fields().ByName("id") + fd_Nested3A_name = md_Nested3A.Fields().ByName("name") + fd_Nested3A_a4 = md_Nested3A.Fields().ByName("a4") + fd_Nested3A_index = md_Nested3A.Fields().ByName("index") +} + +var _ protoreflect.Message = (*fastReflection_Nested3A)(nil) + +type fastReflection_Nested3A Nested3A + +func (x *Nested3A) ProtoReflect() protoreflect.Message { + return (*fastReflection_Nested3A)(x) +} + +func (x *Nested3A) slowProtoReflect() protoreflect.Message { + mi := &file_unknonwnproto_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) +} + +var _fastReflection_Nested3A_messageType fastReflection_Nested3A_messageType +var _ protoreflect.MessageType = fastReflection_Nested3A_messageType{} + +type fastReflection_Nested3A_messageType struct{} + +func (x fastReflection_Nested3A_messageType) Zero() protoreflect.Message { + return (*fastReflection_Nested3A)(nil) +} +func (x fastReflection_Nested3A_messageType) New() protoreflect.Message { + return new(fastReflection_Nested3A) +} +func (x fastReflection_Nested3A_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_Nested3A +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_Nested3A) Descriptor() protoreflect.MessageDescriptor { + return md_Nested3A +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_Nested3A) Type() protoreflect.MessageType { + return _fastReflection_Nested3A_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_Nested3A) New() protoreflect.Message { + return new(fastReflection_Nested3A) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_Nested3A) Interface() protoreflect.ProtoMessage { + return (*Nested3A)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_Nested3A) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Id != int32(0) { + value := protoreflect.ValueOfInt32(x.Id) + if !f(fd_Nested3A_id, value) { + return + } + } + if x.Name != "" { + value := protoreflect.ValueOfString(x.Name) + if !f(fd_Nested3A_name, value) { + return + } + } + if len(x.A4) != 0 { + value := protoreflect.ValueOfList(&_Nested3A_4_list{list: &x.A4}) + if !f(fd_Nested3A_a4, value) { + return + } + } + if len(x.Index) != 0 { + value := protoreflect.ValueOfMap(&_Nested3A_5_map{m: &x.Index}) + if !f(fd_Nested3A_index, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_Nested3A) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "testpb.Nested3A.id": + return x.Id != int32(0) + case "testpb.Nested3A.name": + return x.Name != "" + case "testpb.Nested3A.a4": + return len(x.A4) != 0 + case "testpb.Nested3A.index": + return len(x.Index) != 0 + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested3A")) + } + panic(fmt.Errorf("message testpb.Nested3A does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_Nested3A) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "testpb.Nested3A.id": + x.Id = int32(0) + case "testpb.Nested3A.name": + x.Name = "" + case "testpb.Nested3A.a4": + x.A4 = nil + case "testpb.Nested3A.index": + x.Index = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested3A")) + } + panic(fmt.Errorf("message testpb.Nested3A does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_Nested3A) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "testpb.Nested3A.id": + value := x.Id + return protoreflect.ValueOfInt32(value) + case "testpb.Nested3A.name": + value := x.Name + return protoreflect.ValueOfString(value) + case "testpb.Nested3A.a4": + if len(x.A4) == 0 { + return protoreflect.ValueOfList(&_Nested3A_4_list{}) + } + listValue := &_Nested3A_4_list{list: &x.A4} + return protoreflect.ValueOfList(listValue) + case "testpb.Nested3A.index": + if len(x.Index) == 0 { + return protoreflect.ValueOfMap(&_Nested3A_5_map{}) + } + mapValue := &_Nested3A_5_map{m: &x.Index} + return protoreflect.ValueOfMap(mapValue) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested3A")) + } + panic(fmt.Errorf("message testpb.Nested3A does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_Nested3A) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "testpb.Nested3A.id": + x.Id = int32(value.Int()) + case "testpb.Nested3A.name": + x.Name = value.Interface().(string) + case "testpb.Nested3A.a4": + lv := value.List() + clv := lv.(*_Nested3A_4_list) + x.A4 = *clv.list + case "testpb.Nested3A.index": + mv := value.Map() + cmv := mv.(*_Nested3A_5_map) + x.Index = *cmv.m + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested3A")) + } + panic(fmt.Errorf("message testpb.Nested3A does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_Nested3A) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.Nested3A.a4": + if x.A4 == nil { + x.A4 = []*Nested4A{} + } + value := &_Nested3A_4_list{list: &x.A4} + return protoreflect.ValueOfList(value) + case "testpb.Nested3A.index": + if x.Index == nil { + x.Index = make(map[int64]*Nested4A) + } + value := &_Nested3A_5_map{m: &x.Index} + return protoreflect.ValueOfMap(value) + case "testpb.Nested3A.id": + panic(fmt.Errorf("field id of message testpb.Nested3A is not mutable")) + case "testpb.Nested3A.name": + panic(fmt.Errorf("field name of message testpb.Nested3A is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested3A")) + } + panic(fmt.Errorf("message testpb.Nested3A does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_Nested3A) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.Nested3A.id": + return protoreflect.ValueOfInt32(int32(0)) + case "testpb.Nested3A.name": + return protoreflect.ValueOfString("") + case "testpb.Nested3A.a4": + list := []*Nested4A{} + return protoreflect.ValueOfList(&_Nested3A_4_list{list: &list}) + case "testpb.Nested3A.index": + m := make(map[int64]*Nested4A) + return protoreflect.ValueOfMap(&_Nested3A_5_map{m: &m}) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested3A")) + } + panic(fmt.Errorf("message testpb.Nested3A does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_Nested3A) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in testpb.Nested3A", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_Nested3A) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_Nested3A) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_Nested3A) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_Nested3A) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*Nested3A) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + if x.Id != 0 { + n += 1 + runtime.Sov(uint64(x.Id)) + } + l = len(x.Name) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if len(x.A4) > 0 { + for _, e := range x.A4 { + l = options.Size(e) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + if len(x.Index) > 0 { + SiZeMaP := func(k int64, v *Nested4A) { + l := 0 + if v != nil { + l = options.Size(v) + } + l += 1 + runtime.Sov(uint64(l)) + mapEntrySize := 1 + runtime.Sov(uint64(k)) + l + n += mapEntrySize + 1 + runtime.Sov(uint64(mapEntrySize)) + } + if options.Deterministic { + sortme := make([]int64, 0, len(x.Index)) + for k := range x.Index { + sortme = append(sortme, k) + } + sort.Slice(sortme, func(i, j int) bool { + return sortme[i] < sortme[j] + }) + for _, k := range sortme { + v := x.Index[k] + SiZeMaP(k, v) + } + } else { + for k, v := range x.Index { + SiZeMaP(k, v) + } + } + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*Nested3A) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if len(x.Index) > 0 { + MaRsHaLmAp := func(k int64, v *Nested4A) (protoiface.MarshalOutput, error) { + baseI := i + encoded, err := options.Marshal(v) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x12 + i = runtime.EncodeVarint(dAtA, i, uint64(k)) + i-- + dAtA[i] = 0x8 + i = runtime.EncodeVarint(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0x2a + return protoiface.MarshalOutput{}, nil + } + if options.Deterministic { + keysForIndex := make([]int64, 0, len(x.Index)) + for k := range x.Index { + keysForIndex = append(keysForIndex, int64(k)) + } + sort.Slice(keysForIndex, func(i, j int) bool { + return keysForIndex[i] < keysForIndex[j] + }) + for iNdEx := len(keysForIndex) - 1; iNdEx >= 0; iNdEx-- { + v := x.Index[int64(keysForIndex[iNdEx])] + out, err := MaRsHaLmAp(keysForIndex[iNdEx], v) + if err != nil { + return out, err + } + } + } else { + for k := range x.Index { + v := x.Index[k] + out, err := MaRsHaLmAp(k, v) + if err != nil { + return out, err + } + } + } + } + if len(x.A4) > 0 { + for iNdEx := len(x.A4) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.A4[iNdEx]) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x22 + } + } + if len(x.Name) > 0 { + i -= len(x.Name) + copy(dAtA[i:], x.Name) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Name))) + i-- + dAtA[i] = 0x12 + } + if x.Id != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.Id)) + i-- + dAtA[i] = 0x8 + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*Nested3A) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Nested3A: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Nested3A: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + x.Id = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.Id |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field A4", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.A4 = append(x.A4, &Nested4A{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.A4[len(x.A4)-1]); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.Index == nil { + x.Index = make(map[int64]*Nested4A) + } + var mapkey int64 + var mapvalue *Nested4A + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapkey |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + } else if fieldNum == 2 { + var mapmsglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapmsglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if mapmsglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postmsgIndex := iNdEx + mapmsglen + if postmsgIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postmsgIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + mapvalue = &Nested4A{} + if err := options.Unmarshal(dAtA[iNdEx:postmsgIndex], mapvalue); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postmsgIndex + } else { + iNdEx = entryPreIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > postIndex { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + x.Index[mapkey] = mapvalue + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var ( + md_Nested2A protoreflect.MessageDescriptor + fd_Nested2A_id protoreflect.FieldDescriptor + fd_Nested2A_name protoreflect.FieldDescriptor + fd_Nested2A_nested protoreflect.FieldDescriptor +) + +func init() { + file_unknonwnproto_proto_init() + md_Nested2A = File_unknonwnproto_proto.Messages().ByName("Nested2A") + fd_Nested2A_id = md_Nested2A.Fields().ByName("id") + fd_Nested2A_name = md_Nested2A.Fields().ByName("name") + fd_Nested2A_nested = md_Nested2A.Fields().ByName("nested") +} + +var _ protoreflect.Message = (*fastReflection_Nested2A)(nil) + +type fastReflection_Nested2A Nested2A + +func (x *Nested2A) ProtoReflect() protoreflect.Message { + return (*fastReflection_Nested2A)(x) +} + +func (x *Nested2A) slowProtoReflect() protoreflect.Message { + mi := &file_unknonwnproto_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) +} + +var _fastReflection_Nested2A_messageType fastReflection_Nested2A_messageType +var _ protoreflect.MessageType = fastReflection_Nested2A_messageType{} + +type fastReflection_Nested2A_messageType struct{} + +func (x fastReflection_Nested2A_messageType) Zero() protoreflect.Message { + return (*fastReflection_Nested2A)(nil) +} +func (x fastReflection_Nested2A_messageType) New() protoreflect.Message { + return new(fastReflection_Nested2A) +} +func (x fastReflection_Nested2A_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_Nested2A +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_Nested2A) Descriptor() protoreflect.MessageDescriptor { + return md_Nested2A +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_Nested2A) Type() protoreflect.MessageType { + return _fastReflection_Nested2A_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_Nested2A) New() protoreflect.Message { + return new(fastReflection_Nested2A) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_Nested2A) Interface() protoreflect.ProtoMessage { + return (*Nested2A)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_Nested2A) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Id != int32(0) { + value := protoreflect.ValueOfInt32(x.Id) + if !f(fd_Nested2A_id, value) { + return + } + } + if x.Name != "" { + value := protoreflect.ValueOfString(x.Name) + if !f(fd_Nested2A_name, value) { + return + } + } + if x.Nested != nil { + value := protoreflect.ValueOfMessage(x.Nested.ProtoReflect()) + if !f(fd_Nested2A_nested, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_Nested2A) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "testpb.Nested2A.id": + return x.Id != int32(0) + case "testpb.Nested2A.name": + return x.Name != "" + case "testpb.Nested2A.nested": + return x.Nested != nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested2A")) + } + panic(fmt.Errorf("message testpb.Nested2A does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_Nested2A) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "testpb.Nested2A.id": + x.Id = int32(0) + case "testpb.Nested2A.name": + x.Name = "" + case "testpb.Nested2A.nested": + x.Nested = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested2A")) + } + panic(fmt.Errorf("message testpb.Nested2A does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_Nested2A) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "testpb.Nested2A.id": + value := x.Id + return protoreflect.ValueOfInt32(value) + case "testpb.Nested2A.name": + value := x.Name + return protoreflect.ValueOfString(value) + case "testpb.Nested2A.nested": + value := x.Nested + return protoreflect.ValueOfMessage(value.ProtoReflect()) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested2A")) + } + panic(fmt.Errorf("message testpb.Nested2A does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_Nested2A) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "testpb.Nested2A.id": + x.Id = int32(value.Int()) + case "testpb.Nested2A.name": + x.Name = value.Interface().(string) + case "testpb.Nested2A.nested": + x.Nested = value.Message().Interface().(*Nested3A) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested2A")) + } + panic(fmt.Errorf("message testpb.Nested2A does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_Nested2A) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.Nested2A.nested": + if x.Nested == nil { + x.Nested = new(Nested3A) + } + return protoreflect.ValueOfMessage(x.Nested.ProtoReflect()) + case "testpb.Nested2A.id": + panic(fmt.Errorf("field id of message testpb.Nested2A is not mutable")) + case "testpb.Nested2A.name": + panic(fmt.Errorf("field name of message testpb.Nested2A is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested2A")) + } + panic(fmt.Errorf("message testpb.Nested2A does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_Nested2A) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.Nested2A.id": + return protoreflect.ValueOfInt32(int32(0)) + case "testpb.Nested2A.name": + return protoreflect.ValueOfString("") + case "testpb.Nested2A.nested": + m := new(Nested3A) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested2A")) + } + panic(fmt.Errorf("message testpb.Nested2A does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_Nested2A) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in testpb.Nested2A", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_Nested2A) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_Nested2A) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_Nested2A) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_Nested2A) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*Nested2A) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + if x.Id != 0 { + n += 1 + runtime.Sov(uint64(x.Id)) + } + l = len(x.Name) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.Nested != nil { + l = options.Size(x.Nested) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*Nested2A) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if x.Nested != nil { + encoded, err := options.Marshal(x.Nested) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x1a + } + if len(x.Name) > 0 { + i -= len(x.Name) + copy(dAtA[i:], x.Name) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Name))) + i-- + dAtA[i] = 0x12 + } + if x.Id != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.Id)) + i-- + dAtA[i] = 0x8 + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*Nested2A) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Nested2A: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Nested2A: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + x.Id = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.Id |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Nested", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.Nested == nil { + x.Nested = &Nested3A{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Nested); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var ( + md_Nested1A protoreflect.MessageDescriptor + fd_Nested1A_id protoreflect.FieldDescriptor + fd_Nested1A_nested protoreflect.FieldDescriptor +) + +func init() { + file_unknonwnproto_proto_init() + md_Nested1A = File_unknonwnproto_proto.Messages().ByName("Nested1A") + fd_Nested1A_id = md_Nested1A.Fields().ByName("id") + fd_Nested1A_nested = md_Nested1A.Fields().ByName("nested") +} + +var _ protoreflect.Message = (*fastReflection_Nested1A)(nil) + +type fastReflection_Nested1A Nested1A + +func (x *Nested1A) ProtoReflect() protoreflect.Message { + return (*fastReflection_Nested1A)(x) +} + +func (x *Nested1A) slowProtoReflect() protoreflect.Message { + mi := &file_unknonwnproto_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) +} + +var _fastReflection_Nested1A_messageType fastReflection_Nested1A_messageType +var _ protoreflect.MessageType = fastReflection_Nested1A_messageType{} + +type fastReflection_Nested1A_messageType struct{} + +func (x fastReflection_Nested1A_messageType) Zero() protoreflect.Message { + return (*fastReflection_Nested1A)(nil) +} +func (x fastReflection_Nested1A_messageType) New() protoreflect.Message { + return new(fastReflection_Nested1A) +} +func (x fastReflection_Nested1A_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_Nested1A +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_Nested1A) Descriptor() protoreflect.MessageDescriptor { + return md_Nested1A +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_Nested1A) Type() protoreflect.MessageType { + return _fastReflection_Nested1A_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_Nested1A) New() protoreflect.Message { + return new(fastReflection_Nested1A) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_Nested1A) Interface() protoreflect.ProtoMessage { + return (*Nested1A)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_Nested1A) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Id != int32(0) { + value := protoreflect.ValueOfInt32(x.Id) + if !f(fd_Nested1A_id, value) { + return + } + } + if x.Nested != nil { + value := protoreflect.ValueOfMessage(x.Nested.ProtoReflect()) + if !f(fd_Nested1A_nested, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_Nested1A) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "testpb.Nested1A.id": + return x.Id != int32(0) + case "testpb.Nested1A.nested": + return x.Nested != nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested1A")) + } + panic(fmt.Errorf("message testpb.Nested1A does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_Nested1A) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "testpb.Nested1A.id": + x.Id = int32(0) + case "testpb.Nested1A.nested": + x.Nested = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested1A")) + } + panic(fmt.Errorf("message testpb.Nested1A does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_Nested1A) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "testpb.Nested1A.id": + value := x.Id + return protoreflect.ValueOfInt32(value) + case "testpb.Nested1A.nested": + value := x.Nested + return protoreflect.ValueOfMessage(value.ProtoReflect()) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested1A")) + } + panic(fmt.Errorf("message testpb.Nested1A does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_Nested1A) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "testpb.Nested1A.id": + x.Id = int32(value.Int()) + case "testpb.Nested1A.nested": + x.Nested = value.Message().Interface().(*Nested2A) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested1A")) + } + panic(fmt.Errorf("message testpb.Nested1A does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_Nested1A) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.Nested1A.nested": + if x.Nested == nil { + x.Nested = new(Nested2A) + } + return protoreflect.ValueOfMessage(x.Nested.ProtoReflect()) + case "testpb.Nested1A.id": + panic(fmt.Errorf("field id of message testpb.Nested1A is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested1A")) + } + panic(fmt.Errorf("message testpb.Nested1A does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_Nested1A) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.Nested1A.id": + return protoreflect.ValueOfInt32(int32(0)) + case "testpb.Nested1A.nested": + m := new(Nested2A) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested1A")) + } + panic(fmt.Errorf("message testpb.Nested1A does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_Nested1A) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in testpb.Nested1A", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_Nested1A) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_Nested1A) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_Nested1A) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_Nested1A) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*Nested1A) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + if x.Id != 0 { + n += 1 + runtime.Sov(uint64(x.Id)) + } + if x.Nested != nil { + l = options.Size(x.Nested) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*Nested1A) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if x.Nested != nil { + encoded, err := options.Marshal(x.Nested) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x12 + } + if x.Id != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.Id)) + i-- + dAtA[i] = 0x8 + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*Nested1A) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Nested1A: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Nested1A: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + x.Id = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.Id |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Nested", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.Nested == nil { + x.Nested = &Nested2A{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Nested); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var ( + md_Nested4B protoreflect.MessageDescriptor + fd_Nested4B_id protoreflect.FieldDescriptor + fd_Nested4B_age protoreflect.FieldDescriptor + fd_Nested4B_name protoreflect.FieldDescriptor +) + +func init() { + file_unknonwnproto_proto_init() + md_Nested4B = File_unknonwnproto_proto.Messages().ByName("Nested4B") + fd_Nested4B_id = md_Nested4B.Fields().ByName("id") + fd_Nested4B_age = md_Nested4B.Fields().ByName("age") + fd_Nested4B_name = md_Nested4B.Fields().ByName("name") +} + +var _ protoreflect.Message = (*fastReflection_Nested4B)(nil) + +type fastReflection_Nested4B Nested4B + +func (x *Nested4B) ProtoReflect() protoreflect.Message { + return (*fastReflection_Nested4B)(x) +} + +func (x *Nested4B) slowProtoReflect() protoreflect.Message { + mi := &file_unknonwnproto_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) +} + +var _fastReflection_Nested4B_messageType fastReflection_Nested4B_messageType +var _ protoreflect.MessageType = fastReflection_Nested4B_messageType{} + +type fastReflection_Nested4B_messageType struct{} + +func (x fastReflection_Nested4B_messageType) Zero() protoreflect.Message { + return (*fastReflection_Nested4B)(nil) +} +func (x fastReflection_Nested4B_messageType) New() protoreflect.Message { + return new(fastReflection_Nested4B) +} +func (x fastReflection_Nested4B_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_Nested4B +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_Nested4B) Descriptor() protoreflect.MessageDescriptor { + return md_Nested4B +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_Nested4B) Type() protoreflect.MessageType { + return _fastReflection_Nested4B_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_Nested4B) New() protoreflect.Message { + return new(fastReflection_Nested4B) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_Nested4B) Interface() protoreflect.ProtoMessage { + return (*Nested4B)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_Nested4B) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Id != int32(0) { + value := protoreflect.ValueOfInt32(x.Id) + if !f(fd_Nested4B_id, value) { + return + } + } + if x.Age != int32(0) { + value := protoreflect.ValueOfInt32(x.Age) + if !f(fd_Nested4B_age, value) { + return + } + } + if x.Name != "" { + value := protoreflect.ValueOfString(x.Name) + if !f(fd_Nested4B_name, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_Nested4B) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "testpb.Nested4B.id": + return x.Id != int32(0) + case "testpb.Nested4B.age": + return x.Age != int32(0) + case "testpb.Nested4B.name": + return x.Name != "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested4B")) + } + panic(fmt.Errorf("message testpb.Nested4B does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_Nested4B) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "testpb.Nested4B.id": + x.Id = int32(0) + case "testpb.Nested4B.age": + x.Age = int32(0) + case "testpb.Nested4B.name": + x.Name = "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested4B")) + } + panic(fmt.Errorf("message testpb.Nested4B does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_Nested4B) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "testpb.Nested4B.id": + value := x.Id + return protoreflect.ValueOfInt32(value) + case "testpb.Nested4B.age": + value := x.Age + return protoreflect.ValueOfInt32(value) + case "testpb.Nested4B.name": + value := x.Name + return protoreflect.ValueOfString(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested4B")) + } + panic(fmt.Errorf("message testpb.Nested4B does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_Nested4B) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "testpb.Nested4B.id": + x.Id = int32(value.Int()) + case "testpb.Nested4B.age": + x.Age = int32(value.Int()) + case "testpb.Nested4B.name": + x.Name = value.Interface().(string) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested4B")) + } + panic(fmt.Errorf("message testpb.Nested4B does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_Nested4B) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.Nested4B.id": + panic(fmt.Errorf("field id of message testpb.Nested4B is not mutable")) + case "testpb.Nested4B.age": + panic(fmt.Errorf("field age of message testpb.Nested4B is not mutable")) + case "testpb.Nested4B.name": + panic(fmt.Errorf("field name of message testpb.Nested4B is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested4B")) + } + panic(fmt.Errorf("message testpb.Nested4B does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_Nested4B) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.Nested4B.id": + return protoreflect.ValueOfInt32(int32(0)) + case "testpb.Nested4B.age": + return protoreflect.ValueOfInt32(int32(0)) + case "testpb.Nested4B.name": + return protoreflect.ValueOfString("") + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested4B")) + } + panic(fmt.Errorf("message testpb.Nested4B does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_Nested4B) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in testpb.Nested4B", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_Nested4B) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_Nested4B) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_Nested4B) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_Nested4B) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*Nested4B) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + if x.Id != 0 { + n += 1 + runtime.Sov(uint64(x.Id)) + } + if x.Age != 0 { + n += 1 + runtime.Sov(uint64(x.Age)) + } + l = len(x.Name) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*Nested4B) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if len(x.Name) > 0 { + i -= len(x.Name) + copy(dAtA[i:], x.Name) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Name))) + i-- + dAtA[i] = 0x1a + } + if x.Age != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.Age)) + i-- + dAtA[i] = 0x10 + } + if x.Id != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.Id)) + i-- + dAtA[i] = 0x8 + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*Nested4B) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Nested4B: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Nested4B: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + x.Id = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.Id |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Age", wireType) + } + x.Age = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.Age |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var _ protoreflect.List = (*_Nested3B_4_list)(nil) + +type _Nested3B_4_list struct { + list *[]*Nested4B +} + +func (x *_Nested3B_4_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_Nested3B_4_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_Nested3B_4_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*Nested4B) + (*x.list)[i] = concreteValue +} + +func (x *_Nested3B_4_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*Nested4B) + *x.list = append(*x.list, concreteValue) +} + +func (x *_Nested3B_4_list) AppendMutable() protoreflect.Value { + v := new(Nested4B) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_Nested3B_4_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_Nested3B_4_list) NewElement() protoreflect.Value { + v := new(Nested4B) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_Nested3B_4_list) IsValid() bool { + return x.list != nil +} + +var ( + md_Nested3B protoreflect.MessageDescriptor + fd_Nested3B_id protoreflect.FieldDescriptor + fd_Nested3B_age protoreflect.FieldDescriptor + fd_Nested3B_name protoreflect.FieldDescriptor + fd_Nested3B_b4 protoreflect.FieldDescriptor +) + +func init() { + file_unknonwnproto_proto_init() + md_Nested3B = File_unknonwnproto_proto.Messages().ByName("Nested3B") + fd_Nested3B_id = md_Nested3B.Fields().ByName("id") + fd_Nested3B_age = md_Nested3B.Fields().ByName("age") + fd_Nested3B_name = md_Nested3B.Fields().ByName("name") + fd_Nested3B_b4 = md_Nested3B.Fields().ByName("b4") +} + +var _ protoreflect.Message = (*fastReflection_Nested3B)(nil) + +type fastReflection_Nested3B Nested3B + +func (x *Nested3B) ProtoReflect() protoreflect.Message { + return (*fastReflection_Nested3B)(x) +} + +func (x *Nested3B) slowProtoReflect() protoreflect.Message { + mi := &file_unknonwnproto_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) +} + +var _fastReflection_Nested3B_messageType fastReflection_Nested3B_messageType +var _ protoreflect.MessageType = fastReflection_Nested3B_messageType{} + +type fastReflection_Nested3B_messageType struct{} + +func (x fastReflection_Nested3B_messageType) Zero() protoreflect.Message { + return (*fastReflection_Nested3B)(nil) +} +func (x fastReflection_Nested3B_messageType) New() protoreflect.Message { + return new(fastReflection_Nested3B) +} +func (x fastReflection_Nested3B_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_Nested3B +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_Nested3B) Descriptor() protoreflect.MessageDescriptor { + return md_Nested3B +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_Nested3B) Type() protoreflect.MessageType { + return _fastReflection_Nested3B_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_Nested3B) New() protoreflect.Message { + return new(fastReflection_Nested3B) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_Nested3B) Interface() protoreflect.ProtoMessage { + return (*Nested3B)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_Nested3B) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Id != int32(0) { + value := protoreflect.ValueOfInt32(x.Id) + if !f(fd_Nested3B_id, value) { + return + } + } + if x.Age != int32(0) { + value := protoreflect.ValueOfInt32(x.Age) + if !f(fd_Nested3B_age, value) { + return + } + } + if x.Name != "" { + value := protoreflect.ValueOfString(x.Name) + if !f(fd_Nested3B_name, value) { + return + } + } + if len(x.B4) != 0 { + value := protoreflect.ValueOfList(&_Nested3B_4_list{list: &x.B4}) + if !f(fd_Nested3B_b4, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_Nested3B) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "testpb.Nested3B.id": + return x.Id != int32(0) + case "testpb.Nested3B.age": + return x.Age != int32(0) + case "testpb.Nested3B.name": + return x.Name != "" + case "testpb.Nested3B.b4": + return len(x.B4) != 0 + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested3B")) + } + panic(fmt.Errorf("message testpb.Nested3B does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_Nested3B) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "testpb.Nested3B.id": + x.Id = int32(0) + case "testpb.Nested3B.age": + x.Age = int32(0) + case "testpb.Nested3B.name": + x.Name = "" + case "testpb.Nested3B.b4": + x.B4 = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested3B")) + } + panic(fmt.Errorf("message testpb.Nested3B does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_Nested3B) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "testpb.Nested3B.id": + value := x.Id + return protoreflect.ValueOfInt32(value) + case "testpb.Nested3B.age": + value := x.Age + return protoreflect.ValueOfInt32(value) + case "testpb.Nested3B.name": + value := x.Name + return protoreflect.ValueOfString(value) + case "testpb.Nested3B.b4": + if len(x.B4) == 0 { + return protoreflect.ValueOfList(&_Nested3B_4_list{}) + } + listValue := &_Nested3B_4_list{list: &x.B4} + return protoreflect.ValueOfList(listValue) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested3B")) + } + panic(fmt.Errorf("message testpb.Nested3B does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_Nested3B) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "testpb.Nested3B.id": + x.Id = int32(value.Int()) + case "testpb.Nested3B.age": + x.Age = int32(value.Int()) + case "testpb.Nested3B.name": + x.Name = value.Interface().(string) + case "testpb.Nested3B.b4": + lv := value.List() + clv := lv.(*_Nested3B_4_list) + x.B4 = *clv.list + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested3B")) + } + panic(fmt.Errorf("message testpb.Nested3B does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_Nested3B) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.Nested3B.b4": + if x.B4 == nil { + x.B4 = []*Nested4B{} + } + value := &_Nested3B_4_list{list: &x.B4} + return protoreflect.ValueOfList(value) + case "testpb.Nested3B.id": + panic(fmt.Errorf("field id of message testpb.Nested3B is not mutable")) + case "testpb.Nested3B.age": + panic(fmt.Errorf("field age of message testpb.Nested3B is not mutable")) + case "testpb.Nested3B.name": + panic(fmt.Errorf("field name of message testpb.Nested3B is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested3B")) + } + panic(fmt.Errorf("message testpb.Nested3B does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_Nested3B) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.Nested3B.id": + return protoreflect.ValueOfInt32(int32(0)) + case "testpb.Nested3B.age": + return protoreflect.ValueOfInt32(int32(0)) + case "testpb.Nested3B.name": + return protoreflect.ValueOfString("") + case "testpb.Nested3B.b4": + list := []*Nested4B{} + return protoreflect.ValueOfList(&_Nested3B_4_list{list: &list}) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested3B")) + } + panic(fmt.Errorf("message testpb.Nested3B does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_Nested3B) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in testpb.Nested3B", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_Nested3B) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_Nested3B) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_Nested3B) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_Nested3B) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*Nested3B) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + if x.Id != 0 { + n += 1 + runtime.Sov(uint64(x.Id)) + } + if x.Age != 0 { + n += 1 + runtime.Sov(uint64(x.Age)) + } + l = len(x.Name) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if len(x.B4) > 0 { + for _, e := range x.B4 { + l = options.Size(e) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*Nested3B) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if len(x.B4) > 0 { + for iNdEx := len(x.B4) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.B4[iNdEx]) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x22 + } + } + if len(x.Name) > 0 { + i -= len(x.Name) + copy(dAtA[i:], x.Name) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Name))) + i-- + dAtA[i] = 0x1a + } + if x.Age != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.Age)) + i-- + dAtA[i] = 0x10 + } + if x.Id != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.Id)) + i-- + dAtA[i] = 0x8 + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*Nested3B) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Nested3B: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Nested3B: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + x.Id = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.Id |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Age", wireType) + } + x.Age = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.Age |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field B4", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.B4 = append(x.B4, &Nested4B{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.B4[len(x.B4)-1]); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var ( + md_Nested2B protoreflect.MessageDescriptor + fd_Nested2B_id protoreflect.FieldDescriptor + fd_Nested2B_fee protoreflect.FieldDescriptor + fd_Nested2B_nested protoreflect.FieldDescriptor + fd_Nested2B_route protoreflect.FieldDescriptor +) + +func init() { + file_unknonwnproto_proto_init() + md_Nested2B = File_unknonwnproto_proto.Messages().ByName("Nested2B") + fd_Nested2B_id = md_Nested2B.Fields().ByName("id") + fd_Nested2B_fee = md_Nested2B.Fields().ByName("fee") + fd_Nested2B_nested = md_Nested2B.Fields().ByName("nested") + fd_Nested2B_route = md_Nested2B.Fields().ByName("route") +} + +var _ protoreflect.Message = (*fastReflection_Nested2B)(nil) + +type fastReflection_Nested2B Nested2B + +func (x *Nested2B) ProtoReflect() protoreflect.Message { + return (*fastReflection_Nested2B)(x) +} + +func (x *Nested2B) slowProtoReflect() protoreflect.Message { + mi := &file_unknonwnproto_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) +} + +var _fastReflection_Nested2B_messageType fastReflection_Nested2B_messageType +var _ protoreflect.MessageType = fastReflection_Nested2B_messageType{} + +type fastReflection_Nested2B_messageType struct{} + +func (x fastReflection_Nested2B_messageType) Zero() protoreflect.Message { + return (*fastReflection_Nested2B)(nil) +} +func (x fastReflection_Nested2B_messageType) New() protoreflect.Message { + return new(fastReflection_Nested2B) +} +func (x fastReflection_Nested2B_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_Nested2B +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_Nested2B) Descriptor() protoreflect.MessageDescriptor { + return md_Nested2B +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_Nested2B) Type() protoreflect.MessageType { + return _fastReflection_Nested2B_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_Nested2B) New() protoreflect.Message { + return new(fastReflection_Nested2B) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_Nested2B) Interface() protoreflect.ProtoMessage { + return (*Nested2B)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_Nested2B) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Id != int32(0) { + value := protoreflect.ValueOfInt32(x.Id) + if !f(fd_Nested2B_id, value) { + return + } + } + if x.Fee != float64(0) || math.Signbit(x.Fee) { + value := protoreflect.ValueOfFloat64(x.Fee) + if !f(fd_Nested2B_fee, value) { + return + } + } + if x.Nested != nil { + value := protoreflect.ValueOfMessage(x.Nested.ProtoReflect()) + if !f(fd_Nested2B_nested, value) { + return + } + } + if x.Route != "" { + value := protoreflect.ValueOfString(x.Route) + if !f(fd_Nested2B_route, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_Nested2B) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "testpb.Nested2B.id": + return x.Id != int32(0) + case "testpb.Nested2B.fee": + return x.Fee != float64(0) || math.Signbit(x.Fee) + case "testpb.Nested2B.nested": + return x.Nested != nil + case "testpb.Nested2B.route": + return x.Route != "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested2B")) + } + panic(fmt.Errorf("message testpb.Nested2B does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_Nested2B) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "testpb.Nested2B.id": + x.Id = int32(0) + case "testpb.Nested2B.fee": + x.Fee = float64(0) + case "testpb.Nested2B.nested": + x.Nested = nil + case "testpb.Nested2B.route": + x.Route = "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested2B")) + } + panic(fmt.Errorf("message testpb.Nested2B does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_Nested2B) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "testpb.Nested2B.id": + value := x.Id + return protoreflect.ValueOfInt32(value) + case "testpb.Nested2B.fee": + value := x.Fee + return protoreflect.ValueOfFloat64(value) + case "testpb.Nested2B.nested": + value := x.Nested + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "testpb.Nested2B.route": + value := x.Route + return protoreflect.ValueOfString(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested2B")) + } + panic(fmt.Errorf("message testpb.Nested2B does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_Nested2B) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "testpb.Nested2B.id": + x.Id = int32(value.Int()) + case "testpb.Nested2B.fee": + x.Fee = value.Float() + case "testpb.Nested2B.nested": + x.Nested = value.Message().Interface().(*Nested3B) + case "testpb.Nested2B.route": + x.Route = value.Interface().(string) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested2B")) + } + panic(fmt.Errorf("message testpb.Nested2B does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_Nested2B) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.Nested2B.nested": + if x.Nested == nil { + x.Nested = new(Nested3B) + } + return protoreflect.ValueOfMessage(x.Nested.ProtoReflect()) + case "testpb.Nested2B.id": + panic(fmt.Errorf("field id of message testpb.Nested2B is not mutable")) + case "testpb.Nested2B.fee": + panic(fmt.Errorf("field fee of message testpb.Nested2B is not mutable")) + case "testpb.Nested2B.route": + panic(fmt.Errorf("field route of message testpb.Nested2B is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested2B")) + } + panic(fmt.Errorf("message testpb.Nested2B does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_Nested2B) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.Nested2B.id": + return protoreflect.ValueOfInt32(int32(0)) + case "testpb.Nested2B.fee": + return protoreflect.ValueOfFloat64(float64(0)) + case "testpb.Nested2B.nested": + m := new(Nested3B) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "testpb.Nested2B.route": + return protoreflect.ValueOfString("") + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested2B")) + } + panic(fmt.Errorf("message testpb.Nested2B does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_Nested2B) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in testpb.Nested2B", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_Nested2B) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_Nested2B) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_Nested2B) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_Nested2B) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*Nested2B) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + if x.Id != 0 { + n += 1 + runtime.Sov(uint64(x.Id)) + } + if x.Fee != 0 || math.Signbit(x.Fee) { + n += 9 + } + if x.Nested != nil { + l = options.Size(x.Nested) + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Route) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*Nested2B) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if len(x.Route) > 0 { + i -= len(x.Route) + copy(dAtA[i:], x.Route) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Route))) + i-- + dAtA[i] = 0x22 + } + if x.Nested != nil { + encoded, err := options.Marshal(x.Nested) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x1a + } + if x.Fee != 0 || math.Signbit(x.Fee) { + i -= 8 + binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(x.Fee)))) + i-- + dAtA[i] = 0x11 + } + if x.Id != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.Id)) + i-- + dAtA[i] = 0x8 + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*Nested2B) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Nested2B: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Nested2B: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + x.Id = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.Id |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 1 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Fee", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:])) + iNdEx += 8 + x.Fee = float64(math.Float64frombits(v)) + case 3: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Nested", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.Nested == nil { + x.Nested = &Nested3B{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Nested); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Route", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Route = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var ( + md_Nested1B protoreflect.MessageDescriptor + fd_Nested1B_id protoreflect.FieldDescriptor + fd_Nested1B_nested protoreflect.FieldDescriptor + fd_Nested1B_age protoreflect.FieldDescriptor +) + +func init() { + file_unknonwnproto_proto_init() + md_Nested1B = File_unknonwnproto_proto.Messages().ByName("Nested1B") + fd_Nested1B_id = md_Nested1B.Fields().ByName("id") + fd_Nested1B_nested = md_Nested1B.Fields().ByName("nested") + fd_Nested1B_age = md_Nested1B.Fields().ByName("age") +} + +var _ protoreflect.Message = (*fastReflection_Nested1B)(nil) + +type fastReflection_Nested1B Nested1B + +func (x *Nested1B) ProtoReflect() protoreflect.Message { + return (*fastReflection_Nested1B)(x) +} + +func (x *Nested1B) slowProtoReflect() protoreflect.Message { + mi := &file_unknonwnproto_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) +} + +var _fastReflection_Nested1B_messageType fastReflection_Nested1B_messageType +var _ protoreflect.MessageType = fastReflection_Nested1B_messageType{} + +type fastReflection_Nested1B_messageType struct{} + +func (x fastReflection_Nested1B_messageType) Zero() protoreflect.Message { + return (*fastReflection_Nested1B)(nil) +} +func (x fastReflection_Nested1B_messageType) New() protoreflect.Message { + return new(fastReflection_Nested1B) +} +func (x fastReflection_Nested1B_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_Nested1B +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_Nested1B) Descriptor() protoreflect.MessageDescriptor { + return md_Nested1B +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_Nested1B) Type() protoreflect.MessageType { + return _fastReflection_Nested1B_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_Nested1B) New() protoreflect.Message { + return new(fastReflection_Nested1B) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_Nested1B) Interface() protoreflect.ProtoMessage { + return (*Nested1B)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_Nested1B) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Id != int32(0) { + value := protoreflect.ValueOfInt32(x.Id) + if !f(fd_Nested1B_id, value) { + return + } + } + if x.Nested != nil { + value := protoreflect.ValueOfMessage(x.Nested.ProtoReflect()) + if !f(fd_Nested1B_nested, value) { + return + } + } + if x.Age != int32(0) { + value := protoreflect.ValueOfInt32(x.Age) + if !f(fd_Nested1B_age, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_Nested1B) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "testpb.Nested1B.id": + return x.Id != int32(0) + case "testpb.Nested1B.nested": + return x.Nested != nil + case "testpb.Nested1B.age": + return x.Age != int32(0) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested1B")) + } + panic(fmt.Errorf("message testpb.Nested1B does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_Nested1B) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "testpb.Nested1B.id": + x.Id = int32(0) + case "testpb.Nested1B.nested": + x.Nested = nil + case "testpb.Nested1B.age": + x.Age = int32(0) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested1B")) + } + panic(fmt.Errorf("message testpb.Nested1B does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_Nested1B) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "testpb.Nested1B.id": + value := x.Id + return protoreflect.ValueOfInt32(value) + case "testpb.Nested1B.nested": + value := x.Nested + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "testpb.Nested1B.age": + value := x.Age + return protoreflect.ValueOfInt32(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested1B")) + } + panic(fmt.Errorf("message testpb.Nested1B does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_Nested1B) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "testpb.Nested1B.id": + x.Id = int32(value.Int()) + case "testpb.Nested1B.nested": + x.Nested = value.Message().Interface().(*Nested2B) + case "testpb.Nested1B.age": + x.Age = int32(value.Int()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested1B")) + } + panic(fmt.Errorf("message testpb.Nested1B does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_Nested1B) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.Nested1B.nested": + if x.Nested == nil { + x.Nested = new(Nested2B) + } + return protoreflect.ValueOfMessage(x.Nested.ProtoReflect()) + case "testpb.Nested1B.id": + panic(fmt.Errorf("field id of message testpb.Nested1B is not mutable")) + case "testpb.Nested1B.age": + panic(fmt.Errorf("field age of message testpb.Nested1B is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested1B")) + } + panic(fmt.Errorf("message testpb.Nested1B does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_Nested1B) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.Nested1B.id": + return protoreflect.ValueOfInt32(int32(0)) + case "testpb.Nested1B.nested": + m := new(Nested2B) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "testpb.Nested1B.age": + return protoreflect.ValueOfInt32(int32(0)) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested1B")) + } + panic(fmt.Errorf("message testpb.Nested1B does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_Nested1B) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in testpb.Nested1B", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_Nested1B) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_Nested1B) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_Nested1B) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_Nested1B) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*Nested1B) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + if x.Id != 0 { + n += 1 + runtime.Sov(uint64(x.Id)) + } + if x.Nested != nil { + l = options.Size(x.Nested) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.Age != 0 { + n += 1 + runtime.Sov(uint64(x.Age)) + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*Nested1B) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if x.Age != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.Age)) + i-- + dAtA[i] = 0x18 + } + if x.Nested != nil { + encoded, err := options.Marshal(x.Nested) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x12 + } + if x.Id != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.Id)) + i-- + dAtA[i] = 0x8 + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*Nested1B) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Nested1B: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Nested1B: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + x.Id = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.Id |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Nested", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.Nested == nil { + x.Nested = &Nested2B{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Nested); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 3: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Age", wireType) + } + x.Age = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.Age |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var ( + md_Customer3 protoreflect.MessageDescriptor + fd_Customer3_id protoreflect.FieldDescriptor + fd_Customer3_name protoreflect.FieldDescriptor + fd_Customer3_sf protoreflect.FieldDescriptor + fd_Customer3_surcharge protoreflect.FieldDescriptor + fd_Customer3_destination protoreflect.FieldDescriptor + fd_Customer3_credit_card_no protoreflect.FieldDescriptor + fd_Customer3_cheque_no protoreflect.FieldDescriptor + fd_Customer3_original protoreflect.FieldDescriptor +) + +func init() { + file_unknonwnproto_proto_init() + md_Customer3 = File_unknonwnproto_proto.Messages().ByName("Customer3") + fd_Customer3_id = md_Customer3.Fields().ByName("id") + fd_Customer3_name = md_Customer3.Fields().ByName("name") + fd_Customer3_sf = md_Customer3.Fields().ByName("sf") + fd_Customer3_surcharge = md_Customer3.Fields().ByName("surcharge") + fd_Customer3_destination = md_Customer3.Fields().ByName("destination") + fd_Customer3_credit_card_no = md_Customer3.Fields().ByName("credit_card_no") + fd_Customer3_cheque_no = md_Customer3.Fields().ByName("cheque_no") + fd_Customer3_original = md_Customer3.Fields().ByName("original") +} + +var _ protoreflect.Message = (*fastReflection_Customer3)(nil) + +type fastReflection_Customer3 Customer3 + +func (x *Customer3) ProtoReflect() protoreflect.Message { + return (*fastReflection_Customer3)(x) +} + +func (x *Customer3) slowProtoReflect() protoreflect.Message { + mi := &file_unknonwnproto_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) +} + +var _fastReflection_Customer3_messageType fastReflection_Customer3_messageType +var _ protoreflect.MessageType = fastReflection_Customer3_messageType{} + +type fastReflection_Customer3_messageType struct{} + +func (x fastReflection_Customer3_messageType) Zero() protoreflect.Message { + return (*fastReflection_Customer3)(nil) +} +func (x fastReflection_Customer3_messageType) New() protoreflect.Message { + return new(fastReflection_Customer3) +} +func (x fastReflection_Customer3_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_Customer3 +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_Customer3) Descriptor() protoreflect.MessageDescriptor { + return md_Customer3 +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_Customer3) Type() protoreflect.MessageType { + return _fastReflection_Customer3_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_Customer3) New() protoreflect.Message { + return new(fastReflection_Customer3) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_Customer3) Interface() protoreflect.ProtoMessage { + return (*Customer3)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_Customer3) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Id != int32(0) { + value := protoreflect.ValueOfInt32(x.Id) + if !f(fd_Customer3_id, value) { + return + } + } + if x.Name != "" { + value := protoreflect.ValueOfString(x.Name) + if !f(fd_Customer3_name, value) { + return + } + } + if x.Sf != float32(0) || math.Signbit(float64(x.Sf)) { + value := protoreflect.ValueOfFloat32(x.Sf) + if !f(fd_Customer3_sf, value) { + return + } + } + if x.Surcharge != float32(0) || math.Signbit(float64(x.Surcharge)) { + value := protoreflect.ValueOfFloat32(x.Surcharge) + if !f(fd_Customer3_surcharge, value) { + return + } + } + if x.Destination != "" { + value := protoreflect.ValueOfString(x.Destination) + if !f(fd_Customer3_destination, value) { + return + } + } + if x.Payment != nil { + switch o := x.Payment.(type) { + case *Customer3_CreditCardNo: + v := o.CreditCardNo + value := protoreflect.ValueOfString(v) + if !f(fd_Customer3_credit_card_no, value) { + return + } + case *Customer3_ChequeNo: + v := o.ChequeNo + value := protoreflect.ValueOfString(v) + if !f(fd_Customer3_cheque_no, value) { + return + } + } + } + if x.Original != nil { + value := protoreflect.ValueOfMessage(x.Original.ProtoReflect()) + if !f(fd_Customer3_original, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_Customer3) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "testpb.Customer3.id": + return x.Id != int32(0) + case "testpb.Customer3.name": + return x.Name != "" + case "testpb.Customer3.sf": + return x.Sf != float32(0) || math.Signbit(float64(x.Sf)) + case "testpb.Customer3.surcharge": + return x.Surcharge != float32(0) || math.Signbit(float64(x.Surcharge)) + case "testpb.Customer3.destination": + return x.Destination != "" + case "testpb.Customer3.credit_card_no": + if x.Payment == nil { + return false + } else if _, ok := x.Payment.(*Customer3_CreditCardNo); ok { + return true + } else { + return false + } + case "testpb.Customer3.cheque_no": + if x.Payment == nil { + return false + } else if _, ok := x.Payment.(*Customer3_ChequeNo); ok { + return true + } else { + return false + } + case "testpb.Customer3.original": + return x.Original != nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Customer3")) + } + panic(fmt.Errorf("message testpb.Customer3 does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_Customer3) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "testpb.Customer3.id": + x.Id = int32(0) + case "testpb.Customer3.name": + x.Name = "" + case "testpb.Customer3.sf": + x.Sf = float32(0) + case "testpb.Customer3.surcharge": + x.Surcharge = float32(0) + case "testpb.Customer3.destination": + x.Destination = "" + case "testpb.Customer3.credit_card_no": + x.Payment = nil + case "testpb.Customer3.cheque_no": + x.Payment = nil + case "testpb.Customer3.original": + x.Original = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Customer3")) + } + panic(fmt.Errorf("message testpb.Customer3 does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_Customer3) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "testpb.Customer3.id": + value := x.Id + return protoreflect.ValueOfInt32(value) + case "testpb.Customer3.name": + value := x.Name + return protoreflect.ValueOfString(value) + case "testpb.Customer3.sf": + value := x.Sf + return protoreflect.ValueOfFloat32(value) + case "testpb.Customer3.surcharge": + value := x.Surcharge + return protoreflect.ValueOfFloat32(value) + case "testpb.Customer3.destination": + value := x.Destination + return protoreflect.ValueOfString(value) + case "testpb.Customer3.credit_card_no": + if x.Payment == nil { + return protoreflect.ValueOfString("") + } else if v, ok := x.Payment.(*Customer3_CreditCardNo); ok { + return protoreflect.ValueOfString(v.CreditCardNo) + } else { + return protoreflect.ValueOfString("") + } + case "testpb.Customer3.cheque_no": + if x.Payment == nil { + return protoreflect.ValueOfString("") + } else if v, ok := x.Payment.(*Customer3_ChequeNo); ok { + return protoreflect.ValueOfString(v.ChequeNo) + } else { + return protoreflect.ValueOfString("") + } + case "testpb.Customer3.original": + value := x.Original + return protoreflect.ValueOfMessage(value.ProtoReflect()) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Customer3")) + } + panic(fmt.Errorf("message testpb.Customer3 does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_Customer3) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "testpb.Customer3.id": + x.Id = int32(value.Int()) + case "testpb.Customer3.name": + x.Name = value.Interface().(string) + case "testpb.Customer3.sf": + x.Sf = float32(value.Float()) + case "testpb.Customer3.surcharge": + x.Surcharge = float32(value.Float()) + case "testpb.Customer3.destination": + x.Destination = value.Interface().(string) + case "testpb.Customer3.credit_card_no": + cv := value.Interface().(string) + x.Payment = &Customer3_CreditCardNo{CreditCardNo: cv} + case "testpb.Customer3.cheque_no": + cv := value.Interface().(string) + x.Payment = &Customer3_ChequeNo{ChequeNo: cv} + case "testpb.Customer3.original": + x.Original = value.Message().Interface().(*Customer1) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Customer3")) + } + panic(fmt.Errorf("message testpb.Customer3 does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_Customer3) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.Customer3.original": + if x.Original == nil { + x.Original = new(Customer1) + } + return protoreflect.ValueOfMessage(x.Original.ProtoReflect()) + case "testpb.Customer3.id": + panic(fmt.Errorf("field id of message testpb.Customer3 is not mutable")) + case "testpb.Customer3.name": + panic(fmt.Errorf("field name of message testpb.Customer3 is not mutable")) + case "testpb.Customer3.sf": + panic(fmt.Errorf("field sf of message testpb.Customer3 is not mutable")) + case "testpb.Customer3.surcharge": + panic(fmt.Errorf("field surcharge of message testpb.Customer3 is not mutable")) + case "testpb.Customer3.destination": + panic(fmt.Errorf("field destination of message testpb.Customer3 is not mutable")) + case "testpb.Customer3.credit_card_no": + panic(fmt.Errorf("field credit_card_no of message testpb.Customer3 is not mutable")) + case "testpb.Customer3.cheque_no": + panic(fmt.Errorf("field cheque_no of message testpb.Customer3 is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Customer3")) + } + panic(fmt.Errorf("message testpb.Customer3 does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_Customer3) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.Customer3.id": + return protoreflect.ValueOfInt32(int32(0)) + case "testpb.Customer3.name": + return protoreflect.ValueOfString("") + case "testpb.Customer3.sf": + return protoreflect.ValueOfFloat32(float32(0)) + case "testpb.Customer3.surcharge": + return protoreflect.ValueOfFloat32(float32(0)) + case "testpb.Customer3.destination": + return protoreflect.ValueOfString("") + case "testpb.Customer3.credit_card_no": + return protoreflect.ValueOfString("") + case "testpb.Customer3.cheque_no": + return protoreflect.ValueOfString("") + case "testpb.Customer3.original": + m := new(Customer1) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Customer3")) + } + panic(fmt.Errorf("message testpb.Customer3 does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_Customer3) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + case "testpb.Customer3.payment": + if x.Payment == nil { + return nil + } + switch x.Payment.(type) { + case *Customer3_CreditCardNo: + return x.Descriptor().Fields().ByName("credit_card_no") + case *Customer3_ChequeNo: + return x.Descriptor().Fields().ByName("cheque_no") + } + default: + panic(fmt.Errorf("%s is not a oneof field in testpb.Customer3", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_Customer3) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_Customer3) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_Customer3) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_Customer3) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*Customer3) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + if x.Id != 0 { + n += 1 + runtime.Sov(uint64(x.Id)) + } + l = len(x.Name) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.Sf != 0 || math.Signbit(float64(x.Sf)) { + n += 5 + } + if x.Surcharge != 0 || math.Signbit(float64(x.Surcharge)) { + n += 5 + } + l = len(x.Destination) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + switch x := x.Payment.(type) { + case *Customer3_CreditCardNo: + if x == nil { + break + } + l = len(x.CreditCardNo) + n += 1 + l + runtime.Sov(uint64(l)) + case *Customer3_ChequeNo: + if x == nil { + break + } + l = len(x.ChequeNo) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.Original != nil { + l = options.Size(x.Original) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*Customer3) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + switch x := x.Payment.(type) { + case *Customer3_CreditCardNo: + i -= len(x.CreditCardNo) + copy(dAtA[i:], x.CreditCardNo) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.CreditCardNo))) + i-- + dAtA[i] = 0x3a + case *Customer3_ChequeNo: + i -= len(x.ChequeNo) + copy(dAtA[i:], x.ChequeNo) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ChequeNo))) + i-- + dAtA[i] = 0x42 + } + if x.Original != nil { + encoded, err := options.Marshal(x.Original) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x4a + } + if len(x.Destination) > 0 { + i -= len(x.Destination) + copy(dAtA[i:], x.Destination) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Destination))) + i-- + dAtA[i] = 0x2a + } + if x.Surcharge != 0 || math.Signbit(float64(x.Surcharge)) { + i -= 4 + binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(x.Surcharge)))) + i-- + dAtA[i] = 0x25 + } + if x.Sf != 0 || math.Signbit(float64(x.Sf)) { + i -= 4 + binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(x.Sf)))) + i-- + dAtA[i] = 0x1d + } + if len(x.Name) > 0 { + i -= len(x.Name) + copy(dAtA[i:], x.Name) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Name))) + i-- + dAtA[i] = 0x12 + } + if x.Id != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.Id)) + i-- + dAtA[i] = 0x8 + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*Customer3) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Customer3: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Customer3: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + x.Id = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.Id |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 5 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Sf", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + v = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:])) + iNdEx += 4 + x.Sf = float32(math.Float32frombits(v)) + case 4: + if wireType != 5 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Surcharge", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + v = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:])) + iNdEx += 4 + x.Surcharge = float32(math.Float32frombits(v)) + case 5: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Destination", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Destination = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field CreditCardNo", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Payment = &Customer3_CreditCardNo{string(dAtA[iNdEx:postIndex])} + iNdEx = postIndex + case 8: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ChequeNo", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Payment = &Customer3_ChequeNo{string(dAtA[iNdEx:postIndex])} + iNdEx = postIndex + case 9: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Original", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.Original == nil { + x.Original = &Customer1{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Original); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var _ protoreflect.List = (*_TestVersion1_4_list)(nil) + +type _TestVersion1_4_list struct { + list *[]*TestVersion1 +} + +func (x *_TestVersion1_4_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_TestVersion1_4_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_TestVersion1_4_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*TestVersion1) + (*x.list)[i] = concreteValue +} + +func (x *_TestVersion1_4_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*TestVersion1) + *x.list = append(*x.list, concreteValue) +} + +func (x *_TestVersion1_4_list) AppendMutable() protoreflect.Value { + v := new(TestVersion1) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_TestVersion1_4_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_TestVersion1_4_list) NewElement() protoreflect.Value { + v := new(TestVersion1) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_TestVersion1_4_list) IsValid() bool { + return x.list != nil +} + +var _ protoreflect.List = (*_TestVersion1_5_list)(nil) + +type _TestVersion1_5_list struct { + list *[]*TestVersion1 +} + +func (x *_TestVersion1_5_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_TestVersion1_5_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_TestVersion1_5_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*TestVersion1) + (*x.list)[i] = concreteValue +} + +func (x *_TestVersion1_5_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*TestVersion1) + *x.list = append(*x.list, concreteValue) +} + +func (x *_TestVersion1_5_list) AppendMutable() protoreflect.Value { + v := new(TestVersion1) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_TestVersion1_5_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_TestVersion1_5_list) NewElement() protoreflect.Value { + v := new(TestVersion1) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_TestVersion1_5_list) IsValid() bool { + return x.list != nil +} + +var _ protoreflect.List = (*_TestVersion1_9_list)(nil) + +type _TestVersion1_9_list struct { + list *[]*TestVersion1 +} + +func (x *_TestVersion1_9_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_TestVersion1_9_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_TestVersion1_9_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*TestVersion1) + (*x.list)[i] = concreteValue +} + +func (x *_TestVersion1_9_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*TestVersion1) + *x.list = append(*x.list, concreteValue) +} + +func (x *_TestVersion1_9_list) AppendMutable() protoreflect.Value { + v := new(TestVersion1) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_TestVersion1_9_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_TestVersion1_9_list) NewElement() protoreflect.Value { + v := new(TestVersion1) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_TestVersion1_9_list) IsValid() bool { + return x.list != nil +} + +var ( + md_TestVersion1 protoreflect.MessageDescriptor + fd_TestVersion1_x protoreflect.FieldDescriptor + fd_TestVersion1_a protoreflect.FieldDescriptor + fd_TestVersion1_b protoreflect.FieldDescriptor + fd_TestVersion1_c protoreflect.FieldDescriptor + fd_TestVersion1_d protoreflect.FieldDescriptor + fd_TestVersion1_e protoreflect.FieldDescriptor + fd_TestVersion1_f protoreflect.FieldDescriptor + fd_TestVersion1_g protoreflect.FieldDescriptor + fd_TestVersion1_h protoreflect.FieldDescriptor + fd_TestVersion1_k protoreflect.FieldDescriptor +) + +func init() { + file_unknonwnproto_proto_init() + md_TestVersion1 = File_unknonwnproto_proto.Messages().ByName("TestVersion1") + fd_TestVersion1_x = md_TestVersion1.Fields().ByName("x") + fd_TestVersion1_a = md_TestVersion1.Fields().ByName("a") + fd_TestVersion1_b = md_TestVersion1.Fields().ByName("b") + fd_TestVersion1_c = md_TestVersion1.Fields().ByName("c") + fd_TestVersion1_d = md_TestVersion1.Fields().ByName("d") + fd_TestVersion1_e = md_TestVersion1.Fields().ByName("e") + fd_TestVersion1_f = md_TestVersion1.Fields().ByName("f") + fd_TestVersion1_g = md_TestVersion1.Fields().ByName("g") + fd_TestVersion1_h = md_TestVersion1.Fields().ByName("h") + fd_TestVersion1_k = md_TestVersion1.Fields().ByName("k") +} + +var _ protoreflect.Message = (*fastReflection_TestVersion1)(nil) + +type fastReflection_TestVersion1 TestVersion1 + +func (x *TestVersion1) ProtoReflect() protoreflect.Message { + return (*fastReflection_TestVersion1)(x) +} + +func (x *TestVersion1) slowProtoReflect() protoreflect.Message { + mi := &file_unknonwnproto_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) +} + +var _fastReflection_TestVersion1_messageType fastReflection_TestVersion1_messageType +var _ protoreflect.MessageType = fastReflection_TestVersion1_messageType{} + +type fastReflection_TestVersion1_messageType struct{} + +func (x fastReflection_TestVersion1_messageType) Zero() protoreflect.Message { + return (*fastReflection_TestVersion1)(nil) +} +func (x fastReflection_TestVersion1_messageType) New() protoreflect.Message { + return new(fastReflection_TestVersion1) +} +func (x fastReflection_TestVersion1_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_TestVersion1 +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_TestVersion1) Descriptor() protoreflect.MessageDescriptor { + return md_TestVersion1 +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_TestVersion1) Type() protoreflect.MessageType { + return _fastReflection_TestVersion1_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_TestVersion1) New() protoreflect.Message { + return new(fastReflection_TestVersion1) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_TestVersion1) Interface() protoreflect.ProtoMessage { + return (*TestVersion1)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_TestVersion1) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.X != int64(0) { + value := protoreflect.ValueOfInt64(x.X) + if !f(fd_TestVersion1_x, value) { + return + } + } + if x.A != nil { + value := protoreflect.ValueOfMessage(x.A.ProtoReflect()) + if !f(fd_TestVersion1_a, value) { + return + } + } + if x.B != nil { + value := protoreflect.ValueOfMessage(x.B.ProtoReflect()) + if !f(fd_TestVersion1_b, value) { + return + } + } + if len(x.C) != 0 { + value := protoreflect.ValueOfList(&_TestVersion1_4_list{list: &x.C}) + if !f(fd_TestVersion1_c, value) { + return + } + } + if len(x.D) != 0 { + value := protoreflect.ValueOfList(&_TestVersion1_5_list{list: &x.D}) + if !f(fd_TestVersion1_d, value) { + return + } + } + if x.Sum != nil { + switch o := x.Sum.(type) { + case *TestVersion1_E: + v := o.E + value := protoreflect.ValueOfInt32(v) + if !f(fd_TestVersion1_e, value) { + return + } + case *TestVersion1_F: + v := o.F + value := protoreflect.ValueOfMessage(v.ProtoReflect()) + if !f(fd_TestVersion1_f, value) { + return + } + } + } + if x.G != nil { + value := protoreflect.ValueOfMessage(x.G.ProtoReflect()) + if !f(fd_TestVersion1_g, value) { + return + } + } + if len(x.H) != 0 { + value := protoreflect.ValueOfList(&_TestVersion1_9_list{list: &x.H}) + if !f(fd_TestVersion1_h, value) { + return + } + } + if x.K != nil { + value := protoreflect.ValueOfMessage(x.K.ProtoReflect()) + if !f(fd_TestVersion1_k, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_TestVersion1) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "testpb.TestVersion1.x": + return x.X != int64(0) + case "testpb.TestVersion1.a": + return x.A != nil + case "testpb.TestVersion1.b": + return x.B != nil + case "testpb.TestVersion1.c": + return len(x.C) != 0 + case "testpb.TestVersion1.d": + return len(x.D) != 0 + case "testpb.TestVersion1.e": + if x.Sum == nil { + return false + } else if _, ok := x.Sum.(*TestVersion1_E); ok { + return true + } else { + return false + } + case "testpb.TestVersion1.f": + if x.Sum == nil { + return false + } else if _, ok := x.Sum.(*TestVersion1_F); ok { + return true + } else { + return false + } + case "testpb.TestVersion1.g": + return x.G != nil + case "testpb.TestVersion1.h": + return len(x.H) != 0 + case "testpb.TestVersion1.k": + return x.K != nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion1")) + } + panic(fmt.Errorf("message testpb.TestVersion1 does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion1) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "testpb.TestVersion1.x": + x.X = int64(0) + case "testpb.TestVersion1.a": + x.A = nil + case "testpb.TestVersion1.b": + x.B = nil + case "testpb.TestVersion1.c": + x.C = nil + case "testpb.TestVersion1.d": + x.D = nil + case "testpb.TestVersion1.e": + x.Sum = nil + case "testpb.TestVersion1.f": + x.Sum = nil + case "testpb.TestVersion1.g": + x.G = nil + case "testpb.TestVersion1.h": + x.H = nil + case "testpb.TestVersion1.k": + x.K = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion1")) + } + panic(fmt.Errorf("message testpb.TestVersion1 does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_TestVersion1) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "testpb.TestVersion1.x": + value := x.X + return protoreflect.ValueOfInt64(value) + case "testpb.TestVersion1.a": + value := x.A + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "testpb.TestVersion1.b": + value := x.B + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "testpb.TestVersion1.c": + if len(x.C) == 0 { + return protoreflect.ValueOfList(&_TestVersion1_4_list{}) + } + listValue := &_TestVersion1_4_list{list: &x.C} + return protoreflect.ValueOfList(listValue) + case "testpb.TestVersion1.d": + if len(x.D) == 0 { + return protoreflect.ValueOfList(&_TestVersion1_5_list{}) + } + listValue := &_TestVersion1_5_list{list: &x.D} + return protoreflect.ValueOfList(listValue) + case "testpb.TestVersion1.e": + if x.Sum == nil { + return protoreflect.ValueOfInt32(int32(0)) + } else if v, ok := x.Sum.(*TestVersion1_E); ok { + return protoreflect.ValueOfInt32(v.E) + } else { + return protoreflect.ValueOfInt32(int32(0)) + } + case "testpb.TestVersion1.f": + if x.Sum == nil { + return protoreflect.ValueOfMessage((*TestVersion1)(nil).ProtoReflect()) + } else if v, ok := x.Sum.(*TestVersion1_F); ok { + return protoreflect.ValueOfMessage(v.F.ProtoReflect()) + } else { + return protoreflect.ValueOfMessage((*TestVersion1)(nil).ProtoReflect()) + } + case "testpb.TestVersion1.g": + value := x.G + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "testpb.TestVersion1.h": + if len(x.H) == 0 { + return protoreflect.ValueOfList(&_TestVersion1_9_list{}) + } + listValue := &_TestVersion1_9_list{list: &x.H} + return protoreflect.ValueOfList(listValue) + case "testpb.TestVersion1.k": + value := x.K + return protoreflect.ValueOfMessage(value.ProtoReflect()) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion1")) + } + panic(fmt.Errorf("message testpb.TestVersion1 does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion1) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "testpb.TestVersion1.x": + x.X = value.Int() + case "testpb.TestVersion1.a": + x.A = value.Message().Interface().(*TestVersion1) + case "testpb.TestVersion1.b": + x.B = value.Message().Interface().(*TestVersion1) + case "testpb.TestVersion1.c": + lv := value.List() + clv := lv.(*_TestVersion1_4_list) + x.C = *clv.list + case "testpb.TestVersion1.d": + lv := value.List() + clv := lv.(*_TestVersion1_5_list) + x.D = *clv.list + case "testpb.TestVersion1.e": + cv := int32(value.Int()) + x.Sum = &TestVersion1_E{E: cv} + case "testpb.TestVersion1.f": + cv := value.Message().Interface().(*TestVersion1) + x.Sum = &TestVersion1_F{F: cv} + case "testpb.TestVersion1.g": + x.G = value.Message().Interface().(*anypb.Any) + case "testpb.TestVersion1.h": + lv := value.List() + clv := lv.(*_TestVersion1_9_list) + x.H = *clv.list + case "testpb.TestVersion1.k": + x.K = value.Message().Interface().(*Customer1) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion1")) + } + panic(fmt.Errorf("message testpb.TestVersion1 does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion1) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.TestVersion1.a": + if x.A == nil { + x.A = new(TestVersion1) + } + return protoreflect.ValueOfMessage(x.A.ProtoReflect()) + case "testpb.TestVersion1.b": + if x.B == nil { + x.B = new(TestVersion1) + } + return protoreflect.ValueOfMessage(x.B.ProtoReflect()) + case "testpb.TestVersion1.c": + if x.C == nil { + x.C = []*TestVersion1{} + } + value := &_TestVersion1_4_list{list: &x.C} + return protoreflect.ValueOfList(value) + case "testpb.TestVersion1.d": + if x.D == nil { + x.D = []*TestVersion1{} + } + value := &_TestVersion1_5_list{list: &x.D} + return protoreflect.ValueOfList(value) + case "testpb.TestVersion1.f": + if x.Sum == nil { + value := &TestVersion1{} + oneofValue := &TestVersion1_F{F: value} + x.Sum = oneofValue + return protoreflect.ValueOfMessage(value.ProtoReflect()) + } + switch m := x.Sum.(type) { + case *TestVersion1_F: + return protoreflect.ValueOfMessage(m.F.ProtoReflect()) + default: + value := &TestVersion1{} + oneofValue := &TestVersion1_F{F: value} + x.Sum = oneofValue + return protoreflect.ValueOfMessage(value.ProtoReflect()) + } + case "testpb.TestVersion1.g": + if x.G == nil { + x.G = new(anypb.Any) + } + return protoreflect.ValueOfMessage(x.G.ProtoReflect()) + case "testpb.TestVersion1.h": + if x.H == nil { + x.H = []*TestVersion1{} + } + value := &_TestVersion1_9_list{list: &x.H} + return protoreflect.ValueOfList(value) + case "testpb.TestVersion1.k": + if x.K == nil { + x.K = new(Customer1) + } + return protoreflect.ValueOfMessage(x.K.ProtoReflect()) + case "testpb.TestVersion1.x": + panic(fmt.Errorf("field x of message testpb.TestVersion1 is not mutable")) + case "testpb.TestVersion1.e": + panic(fmt.Errorf("field e of message testpb.TestVersion1 is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion1")) + } + panic(fmt.Errorf("message testpb.TestVersion1 does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_TestVersion1) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.TestVersion1.x": + return protoreflect.ValueOfInt64(int64(0)) + case "testpb.TestVersion1.a": + m := new(TestVersion1) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "testpb.TestVersion1.b": + m := new(TestVersion1) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "testpb.TestVersion1.c": + list := []*TestVersion1{} + return protoreflect.ValueOfList(&_TestVersion1_4_list{list: &list}) + case "testpb.TestVersion1.d": + list := []*TestVersion1{} + return protoreflect.ValueOfList(&_TestVersion1_5_list{list: &list}) + case "testpb.TestVersion1.e": + return protoreflect.ValueOfInt32(int32(0)) + case "testpb.TestVersion1.f": + value := &TestVersion1{} + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "testpb.TestVersion1.g": + m := new(anypb.Any) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "testpb.TestVersion1.h": + list := []*TestVersion1{} + return protoreflect.ValueOfList(&_TestVersion1_9_list{list: &list}) + case "testpb.TestVersion1.k": + m := new(Customer1) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion1")) + } + panic(fmt.Errorf("message testpb.TestVersion1 does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_TestVersion1) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + case "testpb.TestVersion1.sum": + if x.Sum == nil { + return nil + } + switch x.Sum.(type) { + case *TestVersion1_E: + return x.Descriptor().Fields().ByName("e") + case *TestVersion1_F: + return x.Descriptor().Fields().ByName("f") + } + default: + panic(fmt.Errorf("%s is not a oneof field in testpb.TestVersion1", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_TestVersion1) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion1) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_TestVersion1) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_TestVersion1) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*TestVersion1) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + if x.X != 0 { + n += 1 + runtime.Sov(uint64(x.X)) + } + if x.A != nil { + l = options.Size(x.A) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.B != nil { + l = options.Size(x.B) + n += 1 + l + runtime.Sov(uint64(l)) + } + if len(x.C) > 0 { + for _, e := range x.C { + l = options.Size(e) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + if len(x.D) > 0 { + for _, e := range x.D { + l = options.Size(e) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + switch x := x.Sum.(type) { + case *TestVersion1_E: + if x == nil { + break + } + n += 1 + runtime.Sov(uint64(x.E)) + case *TestVersion1_F: + if x == nil { + break + } + l = options.Size(x.F) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.G != nil { + l = options.Size(x.G) + n += 1 + l + runtime.Sov(uint64(l)) + } + if len(x.H) > 0 { + for _, e := range x.H { + l = options.Size(e) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + if x.K != nil { + l = options.Size(x.K) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*TestVersion1) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + switch x := x.Sum.(type) { + case *TestVersion1_E: + i = runtime.EncodeVarint(dAtA, i, uint64(x.E)) + i-- + dAtA[i] = 0x30 + case *TestVersion1_F: + encoded, err := options.Marshal(x.F) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x3a + } + if x.K != nil { + encoded, err := options.Marshal(x.K) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x62 + } + if len(x.H) > 0 { + for iNdEx := len(x.H) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.H[iNdEx]) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x4a + } + } + if x.G != nil { + encoded, err := options.Marshal(x.G) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x42 + } + if len(x.D) > 0 { + for iNdEx := len(x.D) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.D[iNdEx]) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x2a + } + } + if len(x.C) > 0 { + for iNdEx := len(x.C) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.C[iNdEx]) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x22 + } + } + if x.B != nil { + encoded, err := options.Marshal(x.B) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x1a + } + if x.A != nil { + encoded, err := options.Marshal(x.A) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x12 + } + if x.X != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.X)) + i-- + dAtA[i] = 0x8 + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*TestVersion1) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion1: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion1: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field X", wireType) + } + x.X = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.X |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field A", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.A == nil { + x.A = &TestVersion1{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.A); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field B", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.B == nil { + x.B = &TestVersion1{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.B); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field C", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.C = append(x.C, &TestVersion1{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.C[len(x.C)-1]); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field D", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.D = append(x.D, &TestVersion1{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.D[len(x.D)-1]); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 6: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field E", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + x.Sum = &TestVersion1_E{v} + case 7: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field F", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + v := &TestVersion1{} + if err := options.Unmarshal(dAtA[iNdEx:postIndex], v); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + x.Sum = &TestVersion1_F{v} + iNdEx = postIndex + case 8: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field G", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.G == nil { + x.G = &anypb.Any{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.G); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field H", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.H = append(x.H, &TestVersion1{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.H[len(x.H)-1]); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 12: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field K", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.K == nil { + x.K = &Customer1{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.K); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var _ protoreflect.List = (*_TestVersion2_4_list)(nil) + +type _TestVersion2_4_list struct { + list *[]*TestVersion2 +} + +func (x *_TestVersion2_4_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_TestVersion2_4_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_TestVersion2_4_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*TestVersion2) + (*x.list)[i] = concreteValue +} + +func (x *_TestVersion2_4_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*TestVersion2) + *x.list = append(*x.list, concreteValue) +} + +func (x *_TestVersion2_4_list) AppendMutable() protoreflect.Value { + v := new(TestVersion2) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_TestVersion2_4_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_TestVersion2_4_list) NewElement() protoreflect.Value { + v := new(TestVersion2) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_TestVersion2_4_list) IsValid() bool { + return x.list != nil +} + +var _ protoreflect.List = (*_TestVersion2_5_list)(nil) + +type _TestVersion2_5_list struct { + list *[]*TestVersion2 +} + +func (x *_TestVersion2_5_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_TestVersion2_5_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_TestVersion2_5_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*TestVersion2) + (*x.list)[i] = concreteValue +} + +func (x *_TestVersion2_5_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*TestVersion2) + *x.list = append(*x.list, concreteValue) +} + +func (x *_TestVersion2_5_list) AppendMutable() protoreflect.Value { + v := new(TestVersion2) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_TestVersion2_5_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_TestVersion2_5_list) NewElement() protoreflect.Value { + v := new(TestVersion2) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_TestVersion2_5_list) IsValid() bool { + return x.list != nil +} + +var _ protoreflect.List = (*_TestVersion2_9_list)(nil) + +type _TestVersion2_9_list struct { + list *[]*TestVersion1 +} + +func (x *_TestVersion2_9_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_TestVersion2_9_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_TestVersion2_9_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*TestVersion1) + (*x.list)[i] = concreteValue +} + +func (x *_TestVersion2_9_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*TestVersion1) + *x.list = append(*x.list, concreteValue) +} + +func (x *_TestVersion2_9_list) AppendMutable() protoreflect.Value { + v := new(TestVersion1) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_TestVersion2_9_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_TestVersion2_9_list) NewElement() protoreflect.Value { + v := new(TestVersion1) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_TestVersion2_9_list) IsValid() bool { + return x.list != nil +} + +var ( + md_TestVersion2 protoreflect.MessageDescriptor + fd_TestVersion2_x protoreflect.FieldDescriptor + fd_TestVersion2_a protoreflect.FieldDescriptor + fd_TestVersion2_b protoreflect.FieldDescriptor + fd_TestVersion2_c protoreflect.FieldDescriptor + fd_TestVersion2_d protoreflect.FieldDescriptor + fd_TestVersion2_e protoreflect.FieldDescriptor + fd_TestVersion2_f protoreflect.FieldDescriptor + fd_TestVersion2_g protoreflect.FieldDescriptor + fd_TestVersion2_h protoreflect.FieldDescriptor + fd_TestVersion2_k protoreflect.FieldDescriptor + fd_TestVersion2_new_field protoreflect.FieldDescriptor +) + +func init() { + file_unknonwnproto_proto_init() + md_TestVersion2 = File_unknonwnproto_proto.Messages().ByName("TestVersion2") + fd_TestVersion2_x = md_TestVersion2.Fields().ByName("x") + fd_TestVersion2_a = md_TestVersion2.Fields().ByName("a") + fd_TestVersion2_b = md_TestVersion2.Fields().ByName("b") + fd_TestVersion2_c = md_TestVersion2.Fields().ByName("c") + fd_TestVersion2_d = md_TestVersion2.Fields().ByName("d") + fd_TestVersion2_e = md_TestVersion2.Fields().ByName("e") + fd_TestVersion2_f = md_TestVersion2.Fields().ByName("f") + fd_TestVersion2_g = md_TestVersion2.Fields().ByName("g") + fd_TestVersion2_h = md_TestVersion2.Fields().ByName("h") + fd_TestVersion2_k = md_TestVersion2.Fields().ByName("k") + fd_TestVersion2_new_field = md_TestVersion2.Fields().ByName("new_field") +} + +var _ protoreflect.Message = (*fastReflection_TestVersion2)(nil) + +type fastReflection_TestVersion2 TestVersion2 + +func (x *TestVersion2) ProtoReflect() protoreflect.Message { + return (*fastReflection_TestVersion2)(x) +} + +func (x *TestVersion2) slowProtoReflect() protoreflect.Message { + mi := &file_unknonwnproto_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) +} + +var _fastReflection_TestVersion2_messageType fastReflection_TestVersion2_messageType +var _ protoreflect.MessageType = fastReflection_TestVersion2_messageType{} + +type fastReflection_TestVersion2_messageType struct{} + +func (x fastReflection_TestVersion2_messageType) Zero() protoreflect.Message { + return (*fastReflection_TestVersion2)(nil) +} +func (x fastReflection_TestVersion2_messageType) New() protoreflect.Message { + return new(fastReflection_TestVersion2) +} +func (x fastReflection_TestVersion2_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_TestVersion2 +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_TestVersion2) Descriptor() protoreflect.MessageDescriptor { + return md_TestVersion2 +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_TestVersion2) Type() protoreflect.MessageType { + return _fastReflection_TestVersion2_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_TestVersion2) New() protoreflect.Message { + return new(fastReflection_TestVersion2) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_TestVersion2) Interface() protoreflect.ProtoMessage { + return (*TestVersion2)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_TestVersion2) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.X != int64(0) { + value := protoreflect.ValueOfInt64(x.X) + if !f(fd_TestVersion2_x, value) { + return + } + } + if x.A != nil { + value := protoreflect.ValueOfMessage(x.A.ProtoReflect()) + if !f(fd_TestVersion2_a, value) { + return + } + } + if x.B != nil { + value := protoreflect.ValueOfMessage(x.B.ProtoReflect()) + if !f(fd_TestVersion2_b, value) { + return + } + } + if len(x.C) != 0 { + value := protoreflect.ValueOfList(&_TestVersion2_4_list{list: &x.C}) + if !f(fd_TestVersion2_c, value) { + return + } + } + if len(x.D) != 0 { + value := protoreflect.ValueOfList(&_TestVersion2_5_list{list: &x.D}) + if !f(fd_TestVersion2_d, value) { + return + } + } + if x.Sum != nil { + switch o := x.Sum.(type) { + case *TestVersion2_E: + v := o.E + value := protoreflect.ValueOfInt32(v) + if !f(fd_TestVersion2_e, value) { + return + } + case *TestVersion2_F: + v := o.F + value := protoreflect.ValueOfMessage(v.ProtoReflect()) + if !f(fd_TestVersion2_f, value) { + return + } + } + } + if x.G != nil { + value := protoreflect.ValueOfMessage(x.G.ProtoReflect()) + if !f(fd_TestVersion2_g, value) { + return + } + } + if len(x.H) != 0 { + value := protoreflect.ValueOfList(&_TestVersion2_9_list{list: &x.H}) + if !f(fd_TestVersion2_h, value) { + return + } + } + if x.K != nil { + value := protoreflect.ValueOfMessage(x.K.ProtoReflect()) + if !f(fd_TestVersion2_k, value) { + return + } + } + if x.NewField_ != uint64(0) { + value := protoreflect.ValueOfUint64(x.NewField_) + if !f(fd_TestVersion2_new_field, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_TestVersion2) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "testpb.TestVersion2.x": + return x.X != int64(0) + case "testpb.TestVersion2.a": + return x.A != nil + case "testpb.TestVersion2.b": + return x.B != nil + case "testpb.TestVersion2.c": + return len(x.C) != 0 + case "testpb.TestVersion2.d": + return len(x.D) != 0 + case "testpb.TestVersion2.e": + if x.Sum == nil { + return false + } else if _, ok := x.Sum.(*TestVersion2_E); ok { + return true + } else { + return false + } + case "testpb.TestVersion2.f": + if x.Sum == nil { + return false + } else if _, ok := x.Sum.(*TestVersion2_F); ok { + return true + } else { + return false + } + case "testpb.TestVersion2.g": + return x.G != nil + case "testpb.TestVersion2.h": + return len(x.H) != 0 + case "testpb.TestVersion2.k": + return x.K != nil + case "testpb.TestVersion2.new_field": + return x.NewField_ != uint64(0) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion2")) + } + panic(fmt.Errorf("message testpb.TestVersion2 does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion2) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "testpb.TestVersion2.x": + x.X = int64(0) + case "testpb.TestVersion2.a": + x.A = nil + case "testpb.TestVersion2.b": + x.B = nil + case "testpb.TestVersion2.c": + x.C = nil + case "testpb.TestVersion2.d": + x.D = nil + case "testpb.TestVersion2.e": + x.Sum = nil + case "testpb.TestVersion2.f": + x.Sum = nil + case "testpb.TestVersion2.g": + x.G = nil + case "testpb.TestVersion2.h": + x.H = nil + case "testpb.TestVersion2.k": + x.K = nil + case "testpb.TestVersion2.new_field": + x.NewField_ = uint64(0) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion2")) + } + panic(fmt.Errorf("message testpb.TestVersion2 does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_TestVersion2) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "testpb.TestVersion2.x": + value := x.X + return protoreflect.ValueOfInt64(value) + case "testpb.TestVersion2.a": + value := x.A + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "testpb.TestVersion2.b": + value := x.B + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "testpb.TestVersion2.c": + if len(x.C) == 0 { + return protoreflect.ValueOfList(&_TestVersion2_4_list{}) + } + listValue := &_TestVersion2_4_list{list: &x.C} + return protoreflect.ValueOfList(listValue) + case "testpb.TestVersion2.d": + if len(x.D) == 0 { + return protoreflect.ValueOfList(&_TestVersion2_5_list{}) + } + listValue := &_TestVersion2_5_list{list: &x.D} + return protoreflect.ValueOfList(listValue) + case "testpb.TestVersion2.e": + if x.Sum == nil { + return protoreflect.ValueOfInt32(int32(0)) + } else if v, ok := x.Sum.(*TestVersion2_E); ok { + return protoreflect.ValueOfInt32(v.E) + } else { + return protoreflect.ValueOfInt32(int32(0)) + } + case "testpb.TestVersion2.f": + if x.Sum == nil { + return protoreflect.ValueOfMessage((*TestVersion2)(nil).ProtoReflect()) + } else if v, ok := x.Sum.(*TestVersion2_F); ok { + return protoreflect.ValueOfMessage(v.F.ProtoReflect()) + } else { + return protoreflect.ValueOfMessage((*TestVersion2)(nil).ProtoReflect()) + } + case "testpb.TestVersion2.g": + value := x.G + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "testpb.TestVersion2.h": + if len(x.H) == 0 { + return protoreflect.ValueOfList(&_TestVersion2_9_list{}) + } + listValue := &_TestVersion2_9_list{list: &x.H} + return protoreflect.ValueOfList(listValue) + case "testpb.TestVersion2.k": + value := x.K + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "testpb.TestVersion2.new_field": + value := x.NewField_ + return protoreflect.ValueOfUint64(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion2")) + } + panic(fmt.Errorf("message testpb.TestVersion2 does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion2) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "testpb.TestVersion2.x": + x.X = value.Int() + case "testpb.TestVersion2.a": + x.A = value.Message().Interface().(*TestVersion2) + case "testpb.TestVersion2.b": + x.B = value.Message().Interface().(*TestVersion2) + case "testpb.TestVersion2.c": + lv := value.List() + clv := lv.(*_TestVersion2_4_list) + x.C = *clv.list + case "testpb.TestVersion2.d": + lv := value.List() + clv := lv.(*_TestVersion2_5_list) + x.D = *clv.list + case "testpb.TestVersion2.e": + cv := int32(value.Int()) + x.Sum = &TestVersion2_E{E: cv} + case "testpb.TestVersion2.f": + cv := value.Message().Interface().(*TestVersion2) + x.Sum = &TestVersion2_F{F: cv} + case "testpb.TestVersion2.g": + x.G = value.Message().Interface().(*anypb.Any) + case "testpb.TestVersion2.h": + lv := value.List() + clv := lv.(*_TestVersion2_9_list) + x.H = *clv.list + case "testpb.TestVersion2.k": + x.K = value.Message().Interface().(*Customer1) + case "testpb.TestVersion2.new_field": + x.NewField_ = value.Uint() + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion2")) + } + panic(fmt.Errorf("message testpb.TestVersion2 does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion2) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.TestVersion2.a": + if x.A == nil { + x.A = new(TestVersion2) + } + return protoreflect.ValueOfMessage(x.A.ProtoReflect()) + case "testpb.TestVersion2.b": + if x.B == nil { + x.B = new(TestVersion2) + } + return protoreflect.ValueOfMessage(x.B.ProtoReflect()) + case "testpb.TestVersion2.c": + if x.C == nil { + x.C = []*TestVersion2{} + } + value := &_TestVersion2_4_list{list: &x.C} + return protoreflect.ValueOfList(value) + case "testpb.TestVersion2.d": + if x.D == nil { + x.D = []*TestVersion2{} + } + value := &_TestVersion2_5_list{list: &x.D} + return protoreflect.ValueOfList(value) + case "testpb.TestVersion2.f": + if x.Sum == nil { + value := &TestVersion2{} + oneofValue := &TestVersion2_F{F: value} + x.Sum = oneofValue + return protoreflect.ValueOfMessage(value.ProtoReflect()) + } + switch m := x.Sum.(type) { + case *TestVersion2_F: + return protoreflect.ValueOfMessage(m.F.ProtoReflect()) + default: + value := &TestVersion2{} + oneofValue := &TestVersion2_F{F: value} + x.Sum = oneofValue + return protoreflect.ValueOfMessage(value.ProtoReflect()) + } + case "testpb.TestVersion2.g": + if x.G == nil { + x.G = new(anypb.Any) + } + return protoreflect.ValueOfMessage(x.G.ProtoReflect()) + case "testpb.TestVersion2.h": + if x.H == nil { + x.H = []*TestVersion1{} + } + value := &_TestVersion2_9_list{list: &x.H} + return protoreflect.ValueOfList(value) + case "testpb.TestVersion2.k": + if x.K == nil { + x.K = new(Customer1) + } + return protoreflect.ValueOfMessage(x.K.ProtoReflect()) + case "testpb.TestVersion2.x": + panic(fmt.Errorf("field x of message testpb.TestVersion2 is not mutable")) + case "testpb.TestVersion2.e": + panic(fmt.Errorf("field e of message testpb.TestVersion2 is not mutable")) + case "testpb.TestVersion2.new_field": + panic(fmt.Errorf("field new_field of message testpb.TestVersion2 is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion2")) + } + panic(fmt.Errorf("message testpb.TestVersion2 does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_TestVersion2) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.TestVersion2.x": + return protoreflect.ValueOfInt64(int64(0)) + case "testpb.TestVersion2.a": + m := new(TestVersion2) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "testpb.TestVersion2.b": + m := new(TestVersion2) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "testpb.TestVersion2.c": + list := []*TestVersion2{} + return protoreflect.ValueOfList(&_TestVersion2_4_list{list: &list}) + case "testpb.TestVersion2.d": + list := []*TestVersion2{} + return protoreflect.ValueOfList(&_TestVersion2_5_list{list: &list}) + case "testpb.TestVersion2.e": + return protoreflect.ValueOfInt32(int32(0)) + case "testpb.TestVersion2.f": + value := &TestVersion2{} + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "testpb.TestVersion2.g": + m := new(anypb.Any) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "testpb.TestVersion2.h": + list := []*TestVersion1{} + return protoreflect.ValueOfList(&_TestVersion2_9_list{list: &list}) + case "testpb.TestVersion2.k": + m := new(Customer1) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "testpb.TestVersion2.new_field": + return protoreflect.ValueOfUint64(uint64(0)) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion2")) + } + panic(fmt.Errorf("message testpb.TestVersion2 does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_TestVersion2) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + case "testpb.TestVersion2.sum": + if x.Sum == nil { + return nil + } + switch x.Sum.(type) { + case *TestVersion2_E: + return x.Descriptor().Fields().ByName("e") + case *TestVersion2_F: + return x.Descriptor().Fields().ByName("f") + } + default: + panic(fmt.Errorf("%s is not a oneof field in testpb.TestVersion2", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_TestVersion2) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion2) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_TestVersion2) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_TestVersion2) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*TestVersion2) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + if x.X != 0 { + n += 1 + runtime.Sov(uint64(x.X)) + } + if x.A != nil { + l = options.Size(x.A) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.B != nil { + l = options.Size(x.B) + n += 1 + l + runtime.Sov(uint64(l)) + } + if len(x.C) > 0 { + for _, e := range x.C { + l = options.Size(e) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + if len(x.D) > 0 { + for _, e := range x.D { + l = options.Size(e) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + switch x := x.Sum.(type) { + case *TestVersion2_E: + if x == nil { + break + } + n += 1 + runtime.Sov(uint64(x.E)) + case *TestVersion2_F: + if x == nil { + break + } + l = options.Size(x.F) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.G != nil { + l = options.Size(x.G) + n += 1 + l + runtime.Sov(uint64(l)) + } + if len(x.H) > 0 { + for _, e := range x.H { + l = options.Size(e) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + if x.K != nil { + l = options.Size(x.K) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.NewField_ != 0 { + n += 2 + runtime.Sov(uint64(x.NewField_)) + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*TestVersion2) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + switch x := x.Sum.(type) { + case *TestVersion2_E: + i = runtime.EncodeVarint(dAtA, i, uint64(x.E)) + i-- + dAtA[i] = 0x30 + case *TestVersion2_F: + encoded, err := options.Marshal(x.F) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x3a + } + if x.NewField_ != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.NewField_)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xc8 + } + if x.K != nil { + encoded, err := options.Marshal(x.K) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x62 + } + if len(x.H) > 0 { + for iNdEx := len(x.H) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.H[iNdEx]) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x4a + } + } + if x.G != nil { + encoded, err := options.Marshal(x.G) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x42 + } + if len(x.D) > 0 { + for iNdEx := len(x.D) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.D[iNdEx]) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x2a + } + } + if len(x.C) > 0 { + for iNdEx := len(x.C) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.C[iNdEx]) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x22 + } + } + if x.B != nil { + encoded, err := options.Marshal(x.B) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x1a + } + if x.A != nil { + encoded, err := options.Marshal(x.A) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x12 + } + if x.X != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.X)) + i-- + dAtA[i] = 0x8 + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*TestVersion2) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field X", wireType) + } + x.X = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.X |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field A", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.A == nil { + x.A = &TestVersion2{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.A); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field B", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.B == nil { + x.B = &TestVersion2{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.B); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field C", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.C = append(x.C, &TestVersion2{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.C[len(x.C)-1]); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field D", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.D = append(x.D, &TestVersion2{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.D[len(x.D)-1]); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 6: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field E", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + x.Sum = &TestVersion2_E{v} + case 7: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field F", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + v := &TestVersion2{} + if err := options.Unmarshal(dAtA[iNdEx:postIndex], v); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + x.Sum = &TestVersion2_F{v} + iNdEx = postIndex + case 8: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field G", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.G == nil { + x.G = &anypb.Any{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.G); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field H", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.H = append(x.H, &TestVersion1{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.H[len(x.H)-1]); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 12: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field K", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.K == nil { + x.K = &Customer1{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.K); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 25: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field NewField_", wireType) + } + x.NewField_ = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.NewField_ |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var _ protoreflect.List = (*_TestVersion3_4_list)(nil) + +type _TestVersion3_4_list struct { + list *[]*TestVersion3 +} + +func (x *_TestVersion3_4_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_TestVersion3_4_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_TestVersion3_4_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*TestVersion3) + (*x.list)[i] = concreteValue +} + +func (x *_TestVersion3_4_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*TestVersion3) + *x.list = append(*x.list, concreteValue) +} + +func (x *_TestVersion3_4_list) AppendMutable() protoreflect.Value { + v := new(TestVersion3) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_TestVersion3_4_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_TestVersion3_4_list) NewElement() protoreflect.Value { + v := new(TestVersion3) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_TestVersion3_4_list) IsValid() bool { + return x.list != nil +} + +var _ protoreflect.List = (*_TestVersion3_5_list)(nil) + +type _TestVersion3_5_list struct { + list *[]*TestVersion3 +} + +func (x *_TestVersion3_5_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_TestVersion3_5_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_TestVersion3_5_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*TestVersion3) + (*x.list)[i] = concreteValue +} + +func (x *_TestVersion3_5_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*TestVersion3) + *x.list = append(*x.list, concreteValue) +} + +func (x *_TestVersion3_5_list) AppendMutable() protoreflect.Value { + v := new(TestVersion3) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_TestVersion3_5_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_TestVersion3_5_list) NewElement() protoreflect.Value { + v := new(TestVersion3) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_TestVersion3_5_list) IsValid() bool { + return x.list != nil +} + +var _ protoreflect.List = (*_TestVersion3_9_list)(nil) + +type _TestVersion3_9_list struct { + list *[]*TestVersion1 +} + +func (x *_TestVersion3_9_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_TestVersion3_9_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_TestVersion3_9_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*TestVersion1) + (*x.list)[i] = concreteValue +} + +func (x *_TestVersion3_9_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*TestVersion1) + *x.list = append(*x.list, concreteValue) +} + +func (x *_TestVersion3_9_list) AppendMutable() protoreflect.Value { + v := new(TestVersion1) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_TestVersion3_9_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_TestVersion3_9_list) NewElement() protoreflect.Value { + v := new(TestVersion1) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_TestVersion3_9_list) IsValid() bool { + return x.list != nil +} + +var ( + md_TestVersion3 protoreflect.MessageDescriptor + fd_TestVersion3_x protoreflect.FieldDescriptor + fd_TestVersion3_a protoreflect.FieldDescriptor + fd_TestVersion3_b protoreflect.FieldDescriptor + fd_TestVersion3_c protoreflect.FieldDescriptor + fd_TestVersion3_d protoreflect.FieldDescriptor + fd_TestVersion3_e protoreflect.FieldDescriptor + fd_TestVersion3_f protoreflect.FieldDescriptor + fd_TestVersion3_g protoreflect.FieldDescriptor + fd_TestVersion3_h protoreflect.FieldDescriptor + fd_TestVersion3_k protoreflect.FieldDescriptor + fd_TestVersion3_non_critical_field protoreflect.FieldDescriptor +) + +func init() { + file_unknonwnproto_proto_init() + md_TestVersion3 = File_unknonwnproto_proto.Messages().ByName("TestVersion3") + fd_TestVersion3_x = md_TestVersion3.Fields().ByName("x") + fd_TestVersion3_a = md_TestVersion3.Fields().ByName("a") + fd_TestVersion3_b = md_TestVersion3.Fields().ByName("b") + fd_TestVersion3_c = md_TestVersion3.Fields().ByName("c") + fd_TestVersion3_d = md_TestVersion3.Fields().ByName("d") + fd_TestVersion3_e = md_TestVersion3.Fields().ByName("e") + fd_TestVersion3_f = md_TestVersion3.Fields().ByName("f") + fd_TestVersion3_g = md_TestVersion3.Fields().ByName("g") + fd_TestVersion3_h = md_TestVersion3.Fields().ByName("h") + fd_TestVersion3_k = md_TestVersion3.Fields().ByName("k") + fd_TestVersion3_non_critical_field = md_TestVersion3.Fields().ByName("non_critical_field") +} + +var _ protoreflect.Message = (*fastReflection_TestVersion3)(nil) + +type fastReflection_TestVersion3 TestVersion3 + +func (x *TestVersion3) ProtoReflect() protoreflect.Message { + return (*fastReflection_TestVersion3)(x) +} + +func (x *TestVersion3) slowProtoReflect() protoreflect.Message { + mi := &file_unknonwnproto_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) +} + +var _fastReflection_TestVersion3_messageType fastReflection_TestVersion3_messageType +var _ protoreflect.MessageType = fastReflection_TestVersion3_messageType{} + +type fastReflection_TestVersion3_messageType struct{} + +func (x fastReflection_TestVersion3_messageType) Zero() protoreflect.Message { + return (*fastReflection_TestVersion3)(nil) +} +func (x fastReflection_TestVersion3_messageType) New() protoreflect.Message { + return new(fastReflection_TestVersion3) +} +func (x fastReflection_TestVersion3_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_TestVersion3 +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_TestVersion3) Descriptor() protoreflect.MessageDescriptor { + return md_TestVersion3 +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_TestVersion3) Type() protoreflect.MessageType { + return _fastReflection_TestVersion3_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_TestVersion3) New() protoreflect.Message { + return new(fastReflection_TestVersion3) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_TestVersion3) Interface() protoreflect.ProtoMessage { + return (*TestVersion3)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_TestVersion3) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.X != int64(0) { + value := protoreflect.ValueOfInt64(x.X) + if !f(fd_TestVersion3_x, value) { + return + } + } + if x.A != nil { + value := protoreflect.ValueOfMessage(x.A.ProtoReflect()) + if !f(fd_TestVersion3_a, value) { + return + } + } + if x.B != nil { + value := protoreflect.ValueOfMessage(x.B.ProtoReflect()) + if !f(fd_TestVersion3_b, value) { + return + } + } + if len(x.C) != 0 { + value := protoreflect.ValueOfList(&_TestVersion3_4_list{list: &x.C}) + if !f(fd_TestVersion3_c, value) { + return + } + } + if len(x.D) != 0 { + value := protoreflect.ValueOfList(&_TestVersion3_5_list{list: &x.D}) + if !f(fd_TestVersion3_d, value) { + return + } + } + if x.Sum != nil { + switch o := x.Sum.(type) { + case *TestVersion3_E: + v := o.E + value := protoreflect.ValueOfInt32(v) + if !f(fd_TestVersion3_e, value) { + return + } + case *TestVersion3_F: + v := o.F + value := protoreflect.ValueOfMessage(v.ProtoReflect()) + if !f(fd_TestVersion3_f, value) { + return + } + } + } + if x.G != nil { + value := protoreflect.ValueOfMessage(x.G.ProtoReflect()) + if !f(fd_TestVersion3_g, value) { + return + } + } + if len(x.H) != 0 { + value := protoreflect.ValueOfList(&_TestVersion3_9_list{list: &x.H}) + if !f(fd_TestVersion3_h, value) { + return + } + } + if x.K != nil { + value := protoreflect.ValueOfMessage(x.K.ProtoReflect()) + if !f(fd_TestVersion3_k, value) { + return + } + } + if x.NonCriticalField != "" { + value := protoreflect.ValueOfString(x.NonCriticalField) + if !f(fd_TestVersion3_non_critical_field, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_TestVersion3) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "testpb.TestVersion3.x": + return x.X != int64(0) + case "testpb.TestVersion3.a": + return x.A != nil + case "testpb.TestVersion3.b": + return x.B != nil + case "testpb.TestVersion3.c": + return len(x.C) != 0 + case "testpb.TestVersion3.d": + return len(x.D) != 0 + case "testpb.TestVersion3.e": + if x.Sum == nil { + return false + } else if _, ok := x.Sum.(*TestVersion3_E); ok { + return true + } else { + return false + } + case "testpb.TestVersion3.f": + if x.Sum == nil { + return false + } else if _, ok := x.Sum.(*TestVersion3_F); ok { + return true + } else { + return false + } + case "testpb.TestVersion3.g": + return x.G != nil + case "testpb.TestVersion3.h": + return len(x.H) != 0 + case "testpb.TestVersion3.k": + return x.K != nil + case "testpb.TestVersion3.non_critical_field": + return x.NonCriticalField != "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3")) + } + panic(fmt.Errorf("message testpb.TestVersion3 does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion3) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "testpb.TestVersion3.x": + x.X = int64(0) + case "testpb.TestVersion3.a": + x.A = nil + case "testpb.TestVersion3.b": + x.B = nil + case "testpb.TestVersion3.c": + x.C = nil + case "testpb.TestVersion3.d": + x.D = nil + case "testpb.TestVersion3.e": + x.Sum = nil + case "testpb.TestVersion3.f": + x.Sum = nil + case "testpb.TestVersion3.g": + x.G = nil + case "testpb.TestVersion3.h": + x.H = nil + case "testpb.TestVersion3.k": + x.K = nil + case "testpb.TestVersion3.non_critical_field": + x.NonCriticalField = "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3")) + } + panic(fmt.Errorf("message testpb.TestVersion3 does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_TestVersion3) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "testpb.TestVersion3.x": + value := x.X + return protoreflect.ValueOfInt64(value) + case "testpb.TestVersion3.a": + value := x.A + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "testpb.TestVersion3.b": + value := x.B + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "testpb.TestVersion3.c": + if len(x.C) == 0 { + return protoreflect.ValueOfList(&_TestVersion3_4_list{}) + } + listValue := &_TestVersion3_4_list{list: &x.C} + return protoreflect.ValueOfList(listValue) + case "testpb.TestVersion3.d": + if len(x.D) == 0 { + return protoreflect.ValueOfList(&_TestVersion3_5_list{}) + } + listValue := &_TestVersion3_5_list{list: &x.D} + return protoreflect.ValueOfList(listValue) + case "testpb.TestVersion3.e": + if x.Sum == nil { + return protoreflect.ValueOfInt32(int32(0)) + } else if v, ok := x.Sum.(*TestVersion3_E); ok { + return protoreflect.ValueOfInt32(v.E) + } else { + return protoreflect.ValueOfInt32(int32(0)) + } + case "testpb.TestVersion3.f": + if x.Sum == nil { + return protoreflect.ValueOfMessage((*TestVersion3)(nil).ProtoReflect()) + } else if v, ok := x.Sum.(*TestVersion3_F); ok { + return protoreflect.ValueOfMessage(v.F.ProtoReflect()) + } else { + return protoreflect.ValueOfMessage((*TestVersion3)(nil).ProtoReflect()) + } + case "testpb.TestVersion3.g": + value := x.G + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "testpb.TestVersion3.h": + if len(x.H) == 0 { + return protoreflect.ValueOfList(&_TestVersion3_9_list{}) + } + listValue := &_TestVersion3_9_list{list: &x.H} + return protoreflect.ValueOfList(listValue) + case "testpb.TestVersion3.k": + value := x.K + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "testpb.TestVersion3.non_critical_field": + value := x.NonCriticalField + return protoreflect.ValueOfString(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3")) + } + panic(fmt.Errorf("message testpb.TestVersion3 does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion3) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "testpb.TestVersion3.x": + x.X = value.Int() + case "testpb.TestVersion3.a": + x.A = value.Message().Interface().(*TestVersion3) + case "testpb.TestVersion3.b": + x.B = value.Message().Interface().(*TestVersion3) + case "testpb.TestVersion3.c": + lv := value.List() + clv := lv.(*_TestVersion3_4_list) + x.C = *clv.list + case "testpb.TestVersion3.d": + lv := value.List() + clv := lv.(*_TestVersion3_5_list) + x.D = *clv.list + case "testpb.TestVersion3.e": + cv := int32(value.Int()) + x.Sum = &TestVersion3_E{E: cv} + case "testpb.TestVersion3.f": + cv := value.Message().Interface().(*TestVersion3) + x.Sum = &TestVersion3_F{F: cv} + case "testpb.TestVersion3.g": + x.G = value.Message().Interface().(*anypb.Any) + case "testpb.TestVersion3.h": + lv := value.List() + clv := lv.(*_TestVersion3_9_list) + x.H = *clv.list + case "testpb.TestVersion3.k": + x.K = value.Message().Interface().(*Customer1) + case "testpb.TestVersion3.non_critical_field": + x.NonCriticalField = value.Interface().(string) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3")) + } + panic(fmt.Errorf("message testpb.TestVersion3 does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion3) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.TestVersion3.a": + if x.A == nil { + x.A = new(TestVersion3) + } + return protoreflect.ValueOfMessage(x.A.ProtoReflect()) + case "testpb.TestVersion3.b": + if x.B == nil { + x.B = new(TestVersion3) + } + return protoreflect.ValueOfMessage(x.B.ProtoReflect()) + case "testpb.TestVersion3.c": + if x.C == nil { + x.C = []*TestVersion3{} + } + value := &_TestVersion3_4_list{list: &x.C} + return protoreflect.ValueOfList(value) + case "testpb.TestVersion3.d": + if x.D == nil { + x.D = []*TestVersion3{} + } + value := &_TestVersion3_5_list{list: &x.D} + return protoreflect.ValueOfList(value) + case "testpb.TestVersion3.f": + if x.Sum == nil { + value := &TestVersion3{} + oneofValue := &TestVersion3_F{F: value} + x.Sum = oneofValue + return protoreflect.ValueOfMessage(value.ProtoReflect()) + } + switch m := x.Sum.(type) { + case *TestVersion3_F: + return protoreflect.ValueOfMessage(m.F.ProtoReflect()) + default: + value := &TestVersion3{} + oneofValue := &TestVersion3_F{F: value} + x.Sum = oneofValue + return protoreflect.ValueOfMessage(value.ProtoReflect()) + } + case "testpb.TestVersion3.g": + if x.G == nil { + x.G = new(anypb.Any) + } + return protoreflect.ValueOfMessage(x.G.ProtoReflect()) + case "testpb.TestVersion3.h": + if x.H == nil { + x.H = []*TestVersion1{} + } + value := &_TestVersion3_9_list{list: &x.H} + return protoreflect.ValueOfList(value) + case "testpb.TestVersion3.k": + if x.K == nil { + x.K = new(Customer1) + } + return protoreflect.ValueOfMessage(x.K.ProtoReflect()) + case "testpb.TestVersion3.x": + panic(fmt.Errorf("field x of message testpb.TestVersion3 is not mutable")) + case "testpb.TestVersion3.e": + panic(fmt.Errorf("field e of message testpb.TestVersion3 is not mutable")) + case "testpb.TestVersion3.non_critical_field": + panic(fmt.Errorf("field non_critical_field of message testpb.TestVersion3 is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3")) + } + panic(fmt.Errorf("message testpb.TestVersion3 does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_TestVersion3) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.TestVersion3.x": + return protoreflect.ValueOfInt64(int64(0)) + case "testpb.TestVersion3.a": + m := new(TestVersion3) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "testpb.TestVersion3.b": + m := new(TestVersion3) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "testpb.TestVersion3.c": + list := []*TestVersion3{} + return protoreflect.ValueOfList(&_TestVersion3_4_list{list: &list}) + case "testpb.TestVersion3.d": + list := []*TestVersion3{} + return protoreflect.ValueOfList(&_TestVersion3_5_list{list: &list}) + case "testpb.TestVersion3.e": + return protoreflect.ValueOfInt32(int32(0)) + case "testpb.TestVersion3.f": + value := &TestVersion3{} + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "testpb.TestVersion3.g": + m := new(anypb.Any) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "testpb.TestVersion3.h": + list := []*TestVersion1{} + return protoreflect.ValueOfList(&_TestVersion3_9_list{list: &list}) + case "testpb.TestVersion3.k": + m := new(Customer1) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "testpb.TestVersion3.non_critical_field": + return protoreflect.ValueOfString("") + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3")) + } + panic(fmt.Errorf("message testpb.TestVersion3 does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_TestVersion3) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + case "testpb.TestVersion3.sum": + if x.Sum == nil { + return nil + } + switch x.Sum.(type) { + case *TestVersion3_E: + return x.Descriptor().Fields().ByName("e") + case *TestVersion3_F: + return x.Descriptor().Fields().ByName("f") + } + default: + panic(fmt.Errorf("%s is not a oneof field in testpb.TestVersion3", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_TestVersion3) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion3) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_TestVersion3) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_TestVersion3) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*TestVersion3) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + if x.X != 0 { + n += 1 + runtime.Sov(uint64(x.X)) + } + if x.A != nil { + l = options.Size(x.A) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.B != nil { + l = options.Size(x.B) + n += 1 + l + runtime.Sov(uint64(l)) + } + if len(x.C) > 0 { + for _, e := range x.C { + l = options.Size(e) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + if len(x.D) > 0 { + for _, e := range x.D { + l = options.Size(e) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + switch x := x.Sum.(type) { + case *TestVersion3_E: + if x == nil { + break + } + n += 1 + runtime.Sov(uint64(x.E)) + case *TestVersion3_F: + if x == nil { + break + } + l = options.Size(x.F) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.G != nil { + l = options.Size(x.G) + n += 1 + l + runtime.Sov(uint64(l)) + } + if len(x.H) > 0 { + for _, e := range x.H { + l = options.Size(e) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + if x.K != nil { + l = options.Size(x.K) + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.NonCriticalField) + if l > 0 { + n += 2 + l + runtime.Sov(uint64(l)) + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*TestVersion3) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + switch x := x.Sum.(type) { + case *TestVersion3_E: + i = runtime.EncodeVarint(dAtA, i, uint64(x.E)) + i-- + dAtA[i] = 0x30 + case *TestVersion3_F: + encoded, err := options.Marshal(x.F) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x3a + } + if len(x.NonCriticalField) > 0 { + i -= len(x.NonCriticalField) + copy(dAtA[i:], x.NonCriticalField) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.NonCriticalField))) + i-- + dAtA[i] = 0x40 + i-- + dAtA[i] = 0xba + } + if x.K != nil { + encoded, err := options.Marshal(x.K) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x62 + } + if len(x.H) > 0 { + for iNdEx := len(x.H) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.H[iNdEx]) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x4a + } + } + if x.G != nil { + encoded, err := options.Marshal(x.G) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x42 + } + if len(x.D) > 0 { + for iNdEx := len(x.D) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.D[iNdEx]) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x2a + } + } + if len(x.C) > 0 { + for iNdEx := len(x.C) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.C[iNdEx]) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x22 + } + } + if x.B != nil { + encoded, err := options.Marshal(x.B) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x1a + } + if x.A != nil { + encoded, err := options.Marshal(x.A) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x12 + } + if x.X != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.X)) + i-- + dAtA[i] = 0x8 + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*TestVersion3) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion3: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion3: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field X", wireType) + } + x.X = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.X |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field A", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.A == nil { + x.A = &TestVersion3{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.A); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field B", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.B == nil { + x.B = &TestVersion3{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.B); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field C", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.C = append(x.C, &TestVersion3{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.C[len(x.C)-1]); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field D", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.D = append(x.D, &TestVersion3{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.D[len(x.D)-1]); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 6: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field E", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + x.Sum = &TestVersion3_E{v} + case 7: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field F", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + v := &TestVersion3{} + if err := options.Unmarshal(dAtA[iNdEx:postIndex], v); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + x.Sum = &TestVersion3_F{v} + iNdEx = postIndex + case 8: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field G", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.G == nil { + x.G = &anypb.Any{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.G); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field H", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.H = append(x.H, &TestVersion1{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.H[len(x.H)-1]); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 12: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field K", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.K == nil { + x.K = &Customer1{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.K); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 1031: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field NonCriticalField", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.NonCriticalField = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var _ protoreflect.List = (*_TestVersion3LoneOneOfValue_4_list)(nil) + +type _TestVersion3LoneOneOfValue_4_list struct { + list *[]*TestVersion3 +} + +func (x *_TestVersion3LoneOneOfValue_4_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_TestVersion3LoneOneOfValue_4_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_TestVersion3LoneOneOfValue_4_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*TestVersion3) + (*x.list)[i] = concreteValue +} + +func (x *_TestVersion3LoneOneOfValue_4_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*TestVersion3) + *x.list = append(*x.list, concreteValue) +} + +func (x *_TestVersion3LoneOneOfValue_4_list) AppendMutable() protoreflect.Value { + v := new(TestVersion3) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_TestVersion3LoneOneOfValue_4_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_TestVersion3LoneOneOfValue_4_list) NewElement() protoreflect.Value { + v := new(TestVersion3) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_TestVersion3LoneOneOfValue_4_list) IsValid() bool { + return x.list != nil +} + +var _ protoreflect.List = (*_TestVersion3LoneOneOfValue_5_list)(nil) + +type _TestVersion3LoneOneOfValue_5_list struct { + list *[]*TestVersion3 +} + +func (x *_TestVersion3LoneOneOfValue_5_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_TestVersion3LoneOneOfValue_5_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_TestVersion3LoneOneOfValue_5_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*TestVersion3) + (*x.list)[i] = concreteValue +} + +func (x *_TestVersion3LoneOneOfValue_5_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*TestVersion3) + *x.list = append(*x.list, concreteValue) +} + +func (x *_TestVersion3LoneOneOfValue_5_list) AppendMutable() protoreflect.Value { + v := new(TestVersion3) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_TestVersion3LoneOneOfValue_5_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_TestVersion3LoneOneOfValue_5_list) NewElement() protoreflect.Value { + v := new(TestVersion3) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_TestVersion3LoneOneOfValue_5_list) IsValid() bool { + return x.list != nil +} + +var _ protoreflect.List = (*_TestVersion3LoneOneOfValue_9_list)(nil) + +type _TestVersion3LoneOneOfValue_9_list struct { + list *[]*TestVersion1 +} + +func (x *_TestVersion3LoneOneOfValue_9_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_TestVersion3LoneOneOfValue_9_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_TestVersion3LoneOneOfValue_9_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*TestVersion1) + (*x.list)[i] = concreteValue +} + +func (x *_TestVersion3LoneOneOfValue_9_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*TestVersion1) + *x.list = append(*x.list, concreteValue) +} + +func (x *_TestVersion3LoneOneOfValue_9_list) AppendMutable() protoreflect.Value { + v := new(TestVersion1) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_TestVersion3LoneOneOfValue_9_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_TestVersion3LoneOneOfValue_9_list) NewElement() protoreflect.Value { + v := new(TestVersion1) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_TestVersion3LoneOneOfValue_9_list) IsValid() bool { + return x.list != nil +} + +var ( + md_TestVersion3LoneOneOfValue protoreflect.MessageDescriptor + fd_TestVersion3LoneOneOfValue_x protoreflect.FieldDescriptor + fd_TestVersion3LoneOneOfValue_a protoreflect.FieldDescriptor + fd_TestVersion3LoneOneOfValue_b protoreflect.FieldDescriptor + fd_TestVersion3LoneOneOfValue_c protoreflect.FieldDescriptor + fd_TestVersion3LoneOneOfValue_d protoreflect.FieldDescriptor + fd_TestVersion3LoneOneOfValue_e protoreflect.FieldDescriptor + fd_TestVersion3LoneOneOfValue_g protoreflect.FieldDescriptor + fd_TestVersion3LoneOneOfValue_h protoreflect.FieldDescriptor + fd_TestVersion3LoneOneOfValue_k protoreflect.FieldDescriptor + fd_TestVersion3LoneOneOfValue_non_critical_field protoreflect.FieldDescriptor +) + +func init() { + file_unknonwnproto_proto_init() + md_TestVersion3LoneOneOfValue = File_unknonwnproto_proto.Messages().ByName("TestVersion3LoneOneOfValue") + fd_TestVersion3LoneOneOfValue_x = md_TestVersion3LoneOneOfValue.Fields().ByName("x") + fd_TestVersion3LoneOneOfValue_a = md_TestVersion3LoneOneOfValue.Fields().ByName("a") + fd_TestVersion3LoneOneOfValue_b = md_TestVersion3LoneOneOfValue.Fields().ByName("b") + fd_TestVersion3LoneOneOfValue_c = md_TestVersion3LoneOneOfValue.Fields().ByName("c") + fd_TestVersion3LoneOneOfValue_d = md_TestVersion3LoneOneOfValue.Fields().ByName("d") + fd_TestVersion3LoneOneOfValue_e = md_TestVersion3LoneOneOfValue.Fields().ByName("e") + fd_TestVersion3LoneOneOfValue_g = md_TestVersion3LoneOneOfValue.Fields().ByName("g") + fd_TestVersion3LoneOneOfValue_h = md_TestVersion3LoneOneOfValue.Fields().ByName("h") + fd_TestVersion3LoneOneOfValue_k = md_TestVersion3LoneOneOfValue.Fields().ByName("k") + fd_TestVersion3LoneOneOfValue_non_critical_field = md_TestVersion3LoneOneOfValue.Fields().ByName("non_critical_field") +} + +var _ protoreflect.Message = (*fastReflection_TestVersion3LoneOneOfValue)(nil) + +type fastReflection_TestVersion3LoneOneOfValue TestVersion3LoneOneOfValue + +func (x *TestVersion3LoneOneOfValue) ProtoReflect() protoreflect.Message { + return (*fastReflection_TestVersion3LoneOneOfValue)(x) +} + +func (x *TestVersion3LoneOneOfValue) slowProtoReflect() protoreflect.Message { + mi := &file_unknonwnproto_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) +} + +var _fastReflection_TestVersion3LoneOneOfValue_messageType fastReflection_TestVersion3LoneOneOfValue_messageType +var _ protoreflect.MessageType = fastReflection_TestVersion3LoneOneOfValue_messageType{} + +type fastReflection_TestVersion3LoneOneOfValue_messageType struct{} + +func (x fastReflection_TestVersion3LoneOneOfValue_messageType) Zero() protoreflect.Message { + return (*fastReflection_TestVersion3LoneOneOfValue)(nil) +} +func (x fastReflection_TestVersion3LoneOneOfValue_messageType) New() protoreflect.Message { + return new(fastReflection_TestVersion3LoneOneOfValue) +} +func (x fastReflection_TestVersion3LoneOneOfValue_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_TestVersion3LoneOneOfValue +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_TestVersion3LoneOneOfValue) Descriptor() protoreflect.MessageDescriptor { + return md_TestVersion3LoneOneOfValue +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_TestVersion3LoneOneOfValue) Type() protoreflect.MessageType { + return _fastReflection_TestVersion3LoneOneOfValue_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_TestVersion3LoneOneOfValue) New() protoreflect.Message { + return new(fastReflection_TestVersion3LoneOneOfValue) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_TestVersion3LoneOneOfValue) Interface() protoreflect.ProtoMessage { + return (*TestVersion3LoneOneOfValue)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_TestVersion3LoneOneOfValue) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.X != int64(0) { + value := protoreflect.ValueOfInt64(x.X) + if !f(fd_TestVersion3LoneOneOfValue_x, value) { + return + } + } + if x.A != nil { + value := protoreflect.ValueOfMessage(x.A.ProtoReflect()) + if !f(fd_TestVersion3LoneOneOfValue_a, value) { + return + } + } + if x.B != nil { + value := protoreflect.ValueOfMessage(x.B.ProtoReflect()) + if !f(fd_TestVersion3LoneOneOfValue_b, value) { + return + } + } + if len(x.C) != 0 { + value := protoreflect.ValueOfList(&_TestVersion3LoneOneOfValue_4_list{list: &x.C}) + if !f(fd_TestVersion3LoneOneOfValue_c, value) { + return + } + } + if len(x.D) != 0 { + value := protoreflect.ValueOfList(&_TestVersion3LoneOneOfValue_5_list{list: &x.D}) + if !f(fd_TestVersion3LoneOneOfValue_d, value) { + return + } + } + if x.Sum != nil { + switch o := x.Sum.(type) { + case *TestVersion3LoneOneOfValue_E: + v := o.E + value := protoreflect.ValueOfInt32(v) + if !f(fd_TestVersion3LoneOneOfValue_e, value) { + return + } + } + } + if x.G != nil { + value := protoreflect.ValueOfMessage(x.G.ProtoReflect()) + if !f(fd_TestVersion3LoneOneOfValue_g, value) { + return + } + } + if len(x.H) != 0 { + value := protoreflect.ValueOfList(&_TestVersion3LoneOneOfValue_9_list{list: &x.H}) + if !f(fd_TestVersion3LoneOneOfValue_h, value) { + return + } + } + if x.K != nil { + value := protoreflect.ValueOfMessage(x.K.ProtoReflect()) + if !f(fd_TestVersion3LoneOneOfValue_k, value) { + return + } + } + if x.NonCriticalField != "" { + value := protoreflect.ValueOfString(x.NonCriticalField) + if !f(fd_TestVersion3LoneOneOfValue_non_critical_field, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_TestVersion3LoneOneOfValue) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "testpb.TestVersion3LoneOneOfValue.x": + return x.X != int64(0) + case "testpb.TestVersion3LoneOneOfValue.a": + return x.A != nil + case "testpb.TestVersion3LoneOneOfValue.b": + return x.B != nil + case "testpb.TestVersion3LoneOneOfValue.c": + return len(x.C) != 0 + case "testpb.TestVersion3LoneOneOfValue.d": + return len(x.D) != 0 + case "testpb.TestVersion3LoneOneOfValue.e": + if x.Sum == nil { + return false + } else if _, ok := x.Sum.(*TestVersion3LoneOneOfValue_E); ok { + return true + } else { + return false + } + case "testpb.TestVersion3LoneOneOfValue.g": + return x.G != nil + case "testpb.TestVersion3LoneOneOfValue.h": + return len(x.H) != 0 + case "testpb.TestVersion3LoneOneOfValue.k": + return x.K != nil + case "testpb.TestVersion3LoneOneOfValue.non_critical_field": + return x.NonCriticalField != "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneOneOfValue")) + } + panic(fmt.Errorf("message testpb.TestVersion3LoneOneOfValue does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion3LoneOneOfValue) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "testpb.TestVersion3LoneOneOfValue.x": + x.X = int64(0) + case "testpb.TestVersion3LoneOneOfValue.a": + x.A = nil + case "testpb.TestVersion3LoneOneOfValue.b": + x.B = nil + case "testpb.TestVersion3LoneOneOfValue.c": + x.C = nil + case "testpb.TestVersion3LoneOneOfValue.d": + x.D = nil + case "testpb.TestVersion3LoneOneOfValue.e": + x.Sum = nil + case "testpb.TestVersion3LoneOneOfValue.g": + x.G = nil + case "testpb.TestVersion3LoneOneOfValue.h": + x.H = nil + case "testpb.TestVersion3LoneOneOfValue.k": + x.K = nil + case "testpb.TestVersion3LoneOneOfValue.non_critical_field": + x.NonCriticalField = "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneOneOfValue")) + } + panic(fmt.Errorf("message testpb.TestVersion3LoneOneOfValue does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_TestVersion3LoneOneOfValue) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "testpb.TestVersion3LoneOneOfValue.x": + value := x.X + return protoreflect.ValueOfInt64(value) + case "testpb.TestVersion3LoneOneOfValue.a": + value := x.A + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "testpb.TestVersion3LoneOneOfValue.b": + value := x.B + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "testpb.TestVersion3LoneOneOfValue.c": + if len(x.C) == 0 { + return protoreflect.ValueOfList(&_TestVersion3LoneOneOfValue_4_list{}) + } + listValue := &_TestVersion3LoneOneOfValue_4_list{list: &x.C} + return protoreflect.ValueOfList(listValue) + case "testpb.TestVersion3LoneOneOfValue.d": + if len(x.D) == 0 { + return protoreflect.ValueOfList(&_TestVersion3LoneOneOfValue_5_list{}) + } + listValue := &_TestVersion3LoneOneOfValue_5_list{list: &x.D} + return protoreflect.ValueOfList(listValue) + case "testpb.TestVersion3LoneOneOfValue.e": + if x.Sum == nil { + return protoreflect.ValueOfInt32(int32(0)) + } else if v, ok := x.Sum.(*TestVersion3LoneOneOfValue_E); ok { + return protoreflect.ValueOfInt32(v.E) + } else { + return protoreflect.ValueOfInt32(int32(0)) + } + case "testpb.TestVersion3LoneOneOfValue.g": + value := x.G + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "testpb.TestVersion3LoneOneOfValue.h": + if len(x.H) == 0 { + return protoreflect.ValueOfList(&_TestVersion3LoneOneOfValue_9_list{}) + } + listValue := &_TestVersion3LoneOneOfValue_9_list{list: &x.H} + return protoreflect.ValueOfList(listValue) + case "testpb.TestVersion3LoneOneOfValue.k": + value := x.K + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "testpb.TestVersion3LoneOneOfValue.non_critical_field": + value := x.NonCriticalField + return protoreflect.ValueOfString(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneOneOfValue")) + } + panic(fmt.Errorf("message testpb.TestVersion3LoneOneOfValue does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion3LoneOneOfValue) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "testpb.TestVersion3LoneOneOfValue.x": + x.X = value.Int() + case "testpb.TestVersion3LoneOneOfValue.a": + x.A = value.Message().Interface().(*TestVersion3) + case "testpb.TestVersion3LoneOneOfValue.b": + x.B = value.Message().Interface().(*TestVersion3) + case "testpb.TestVersion3LoneOneOfValue.c": + lv := value.List() + clv := lv.(*_TestVersion3LoneOneOfValue_4_list) + x.C = *clv.list + case "testpb.TestVersion3LoneOneOfValue.d": + lv := value.List() + clv := lv.(*_TestVersion3LoneOneOfValue_5_list) + x.D = *clv.list + case "testpb.TestVersion3LoneOneOfValue.e": + cv := int32(value.Int()) + x.Sum = &TestVersion3LoneOneOfValue_E{E: cv} + case "testpb.TestVersion3LoneOneOfValue.g": + x.G = value.Message().Interface().(*anypb.Any) + case "testpb.TestVersion3LoneOneOfValue.h": + lv := value.List() + clv := lv.(*_TestVersion3LoneOneOfValue_9_list) + x.H = *clv.list + case "testpb.TestVersion3LoneOneOfValue.k": + x.K = value.Message().Interface().(*Customer1) + case "testpb.TestVersion3LoneOneOfValue.non_critical_field": + x.NonCriticalField = value.Interface().(string) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneOneOfValue")) + } + panic(fmt.Errorf("message testpb.TestVersion3LoneOneOfValue does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion3LoneOneOfValue) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.TestVersion3LoneOneOfValue.a": + if x.A == nil { + x.A = new(TestVersion3) + } + return protoreflect.ValueOfMessage(x.A.ProtoReflect()) + case "testpb.TestVersion3LoneOneOfValue.b": + if x.B == nil { + x.B = new(TestVersion3) + } + return protoreflect.ValueOfMessage(x.B.ProtoReflect()) + case "testpb.TestVersion3LoneOneOfValue.c": + if x.C == nil { + x.C = []*TestVersion3{} + } + value := &_TestVersion3LoneOneOfValue_4_list{list: &x.C} + return protoreflect.ValueOfList(value) + case "testpb.TestVersion3LoneOneOfValue.d": + if x.D == nil { + x.D = []*TestVersion3{} + } + value := &_TestVersion3LoneOneOfValue_5_list{list: &x.D} + return protoreflect.ValueOfList(value) + case "testpb.TestVersion3LoneOneOfValue.g": + if x.G == nil { + x.G = new(anypb.Any) + } + return protoreflect.ValueOfMessage(x.G.ProtoReflect()) + case "testpb.TestVersion3LoneOneOfValue.h": + if x.H == nil { + x.H = []*TestVersion1{} + } + value := &_TestVersion3LoneOneOfValue_9_list{list: &x.H} + return protoreflect.ValueOfList(value) + case "testpb.TestVersion3LoneOneOfValue.k": + if x.K == nil { + x.K = new(Customer1) + } + return protoreflect.ValueOfMessage(x.K.ProtoReflect()) + case "testpb.TestVersion3LoneOneOfValue.x": + panic(fmt.Errorf("field x of message testpb.TestVersion3LoneOneOfValue is not mutable")) + case "testpb.TestVersion3LoneOneOfValue.e": + panic(fmt.Errorf("field e of message testpb.TestVersion3LoneOneOfValue is not mutable")) + case "testpb.TestVersion3LoneOneOfValue.non_critical_field": + panic(fmt.Errorf("field non_critical_field of message testpb.TestVersion3LoneOneOfValue is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneOneOfValue")) + } + panic(fmt.Errorf("message testpb.TestVersion3LoneOneOfValue does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_TestVersion3LoneOneOfValue) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.TestVersion3LoneOneOfValue.x": + return protoreflect.ValueOfInt64(int64(0)) + case "testpb.TestVersion3LoneOneOfValue.a": + m := new(TestVersion3) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "testpb.TestVersion3LoneOneOfValue.b": + m := new(TestVersion3) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "testpb.TestVersion3LoneOneOfValue.c": + list := []*TestVersion3{} + return protoreflect.ValueOfList(&_TestVersion3LoneOneOfValue_4_list{list: &list}) + case "testpb.TestVersion3LoneOneOfValue.d": + list := []*TestVersion3{} + return protoreflect.ValueOfList(&_TestVersion3LoneOneOfValue_5_list{list: &list}) + case "testpb.TestVersion3LoneOneOfValue.e": + return protoreflect.ValueOfInt32(int32(0)) + case "testpb.TestVersion3LoneOneOfValue.g": + m := new(anypb.Any) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "testpb.TestVersion3LoneOneOfValue.h": + list := []*TestVersion1{} + return protoreflect.ValueOfList(&_TestVersion3LoneOneOfValue_9_list{list: &list}) + case "testpb.TestVersion3LoneOneOfValue.k": + m := new(Customer1) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "testpb.TestVersion3LoneOneOfValue.non_critical_field": + return protoreflect.ValueOfString("") + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneOneOfValue")) + } + panic(fmt.Errorf("message testpb.TestVersion3LoneOneOfValue does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_TestVersion3LoneOneOfValue) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + case "testpb.TestVersion3LoneOneOfValue.sum": + if x.Sum == nil { + return nil + } + switch x.Sum.(type) { + case *TestVersion3LoneOneOfValue_E: + return x.Descriptor().Fields().ByName("e") + } + default: + panic(fmt.Errorf("%s is not a oneof field in testpb.TestVersion3LoneOneOfValue", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_TestVersion3LoneOneOfValue) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion3LoneOneOfValue) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_TestVersion3LoneOneOfValue) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_TestVersion3LoneOneOfValue) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*TestVersion3LoneOneOfValue) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + if x.X != 0 { + n += 1 + runtime.Sov(uint64(x.X)) + } + if x.A != nil { + l = options.Size(x.A) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.B != nil { + l = options.Size(x.B) + n += 1 + l + runtime.Sov(uint64(l)) + } + if len(x.C) > 0 { + for _, e := range x.C { + l = options.Size(e) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + if len(x.D) > 0 { + for _, e := range x.D { + l = options.Size(e) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + switch x := x.Sum.(type) { + case *TestVersion3LoneOneOfValue_E: + if x == nil { + break + } + n += 1 + runtime.Sov(uint64(x.E)) + } + if x.G != nil { + l = options.Size(x.G) + n += 1 + l + runtime.Sov(uint64(l)) + } + if len(x.H) > 0 { + for _, e := range x.H { + l = options.Size(e) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + if x.K != nil { + l = options.Size(x.K) + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.NonCriticalField) + if l > 0 { + n += 2 + l + runtime.Sov(uint64(l)) + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*TestVersion3LoneOneOfValue) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + switch x := x.Sum.(type) { + case *TestVersion3LoneOneOfValue_E: + i = runtime.EncodeVarint(dAtA, i, uint64(x.E)) + i-- + dAtA[i] = 0x30 + } + if len(x.NonCriticalField) > 0 { + i -= len(x.NonCriticalField) + copy(dAtA[i:], x.NonCriticalField) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.NonCriticalField))) + i-- + dAtA[i] = 0x40 + i-- + dAtA[i] = 0xba + } + if x.K != nil { + encoded, err := options.Marshal(x.K) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x62 + } + if len(x.H) > 0 { + for iNdEx := len(x.H) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.H[iNdEx]) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x4a + } + } + if x.G != nil { + encoded, err := options.Marshal(x.G) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x42 + } + if len(x.D) > 0 { + for iNdEx := len(x.D) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.D[iNdEx]) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x2a + } + } + if len(x.C) > 0 { + for iNdEx := len(x.C) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.C[iNdEx]) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x22 + } + } + if x.B != nil { + encoded, err := options.Marshal(x.B) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x1a + } + if x.A != nil { + encoded, err := options.Marshal(x.A) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x12 + } + if x.X != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.X)) + i-- + dAtA[i] = 0x8 + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*TestVersion3LoneOneOfValue) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion3LoneOneOfValue: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion3LoneOneOfValue: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field X", wireType) + } + x.X = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.X |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field A", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.A == nil { + x.A = &TestVersion3{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.A); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field B", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.B == nil { + x.B = &TestVersion3{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.B); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field C", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.C = append(x.C, &TestVersion3{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.C[len(x.C)-1]); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field D", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.D = append(x.D, &TestVersion3{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.D[len(x.D)-1]); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 6: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field E", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + x.Sum = &TestVersion3LoneOneOfValue_E{v} + case 8: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field G", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.G == nil { + x.G = &anypb.Any{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.G); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field H", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.H = append(x.H, &TestVersion1{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.H[len(x.H)-1]); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 12: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field K", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.K == nil { + x.K = &Customer1{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.K); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 1031: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field NonCriticalField", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.NonCriticalField = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var _ protoreflect.List = (*_TestVersion3LoneNesting_4_list)(nil) + +type _TestVersion3LoneNesting_4_list struct { + list *[]*TestVersion3 +} + +func (x *_TestVersion3LoneNesting_4_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_TestVersion3LoneNesting_4_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_TestVersion3LoneNesting_4_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*TestVersion3) + (*x.list)[i] = concreteValue +} + +func (x *_TestVersion3LoneNesting_4_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*TestVersion3) + *x.list = append(*x.list, concreteValue) +} + +func (x *_TestVersion3LoneNesting_4_list) AppendMutable() protoreflect.Value { + v := new(TestVersion3) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_TestVersion3LoneNesting_4_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_TestVersion3LoneNesting_4_list) NewElement() protoreflect.Value { + v := new(TestVersion3) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_TestVersion3LoneNesting_4_list) IsValid() bool { + return x.list != nil +} + +var _ protoreflect.List = (*_TestVersion3LoneNesting_5_list)(nil) + +type _TestVersion3LoneNesting_5_list struct { + list *[]*TestVersion3 +} + +func (x *_TestVersion3LoneNesting_5_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_TestVersion3LoneNesting_5_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_TestVersion3LoneNesting_5_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*TestVersion3) + (*x.list)[i] = concreteValue +} + +func (x *_TestVersion3LoneNesting_5_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*TestVersion3) + *x.list = append(*x.list, concreteValue) +} + +func (x *_TestVersion3LoneNesting_5_list) AppendMutable() protoreflect.Value { + v := new(TestVersion3) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_TestVersion3LoneNesting_5_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_TestVersion3LoneNesting_5_list) NewElement() protoreflect.Value { + v := new(TestVersion3) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_TestVersion3LoneNesting_5_list) IsValid() bool { + return x.list != nil +} + +var _ protoreflect.List = (*_TestVersion3LoneNesting_9_list)(nil) + +type _TestVersion3LoneNesting_9_list struct { + list *[]*TestVersion1 +} + +func (x *_TestVersion3LoneNesting_9_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_TestVersion3LoneNesting_9_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_TestVersion3LoneNesting_9_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*TestVersion1) + (*x.list)[i] = concreteValue +} + +func (x *_TestVersion3LoneNesting_9_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*TestVersion1) + *x.list = append(*x.list, concreteValue) +} + +func (x *_TestVersion3LoneNesting_9_list) AppendMutable() protoreflect.Value { + v := new(TestVersion1) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_TestVersion3LoneNesting_9_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_TestVersion3LoneNesting_9_list) NewElement() protoreflect.Value { + v := new(TestVersion1) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_TestVersion3LoneNesting_9_list) IsValid() bool { + return x.list != nil +} + +var ( + md_TestVersion3LoneNesting protoreflect.MessageDescriptor + fd_TestVersion3LoneNesting_x protoreflect.FieldDescriptor + fd_TestVersion3LoneNesting_a protoreflect.FieldDescriptor + fd_TestVersion3LoneNesting_b protoreflect.FieldDescriptor + fd_TestVersion3LoneNesting_c protoreflect.FieldDescriptor + fd_TestVersion3LoneNesting_d protoreflect.FieldDescriptor + fd_TestVersion3LoneNesting_f protoreflect.FieldDescriptor + fd_TestVersion3LoneNesting_g protoreflect.FieldDescriptor + fd_TestVersion3LoneNesting_h protoreflect.FieldDescriptor + fd_TestVersion3LoneNesting_k protoreflect.FieldDescriptor + fd_TestVersion3LoneNesting_non_critical_field protoreflect.FieldDescriptor + fd_TestVersion3LoneNesting_inner1 protoreflect.FieldDescriptor + fd_TestVersion3LoneNesting_inner2 protoreflect.FieldDescriptor +) + +func init() { + file_unknonwnproto_proto_init() + md_TestVersion3LoneNesting = File_unknonwnproto_proto.Messages().ByName("TestVersion3LoneNesting") + fd_TestVersion3LoneNesting_x = md_TestVersion3LoneNesting.Fields().ByName("x") + fd_TestVersion3LoneNesting_a = md_TestVersion3LoneNesting.Fields().ByName("a") + fd_TestVersion3LoneNesting_b = md_TestVersion3LoneNesting.Fields().ByName("b") + fd_TestVersion3LoneNesting_c = md_TestVersion3LoneNesting.Fields().ByName("c") + fd_TestVersion3LoneNesting_d = md_TestVersion3LoneNesting.Fields().ByName("d") + fd_TestVersion3LoneNesting_f = md_TestVersion3LoneNesting.Fields().ByName("f") + fd_TestVersion3LoneNesting_g = md_TestVersion3LoneNesting.Fields().ByName("g") + fd_TestVersion3LoneNesting_h = md_TestVersion3LoneNesting.Fields().ByName("h") + fd_TestVersion3LoneNesting_k = md_TestVersion3LoneNesting.Fields().ByName("k") + fd_TestVersion3LoneNesting_non_critical_field = md_TestVersion3LoneNesting.Fields().ByName("non_critical_field") + fd_TestVersion3LoneNesting_inner1 = md_TestVersion3LoneNesting.Fields().ByName("inner1") + fd_TestVersion3LoneNesting_inner2 = md_TestVersion3LoneNesting.Fields().ByName("inner2") +} + +var _ protoreflect.Message = (*fastReflection_TestVersion3LoneNesting)(nil) + +type fastReflection_TestVersion3LoneNesting TestVersion3LoneNesting + +func (x *TestVersion3LoneNesting) ProtoReflect() protoreflect.Message { + return (*fastReflection_TestVersion3LoneNesting)(x) +} + +func (x *TestVersion3LoneNesting) slowProtoReflect() protoreflect.Message { + mi := &file_unknonwnproto_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) +} + +var _fastReflection_TestVersion3LoneNesting_messageType fastReflection_TestVersion3LoneNesting_messageType +var _ protoreflect.MessageType = fastReflection_TestVersion3LoneNesting_messageType{} + +type fastReflection_TestVersion3LoneNesting_messageType struct{} + +func (x fastReflection_TestVersion3LoneNesting_messageType) Zero() protoreflect.Message { + return (*fastReflection_TestVersion3LoneNesting)(nil) +} +func (x fastReflection_TestVersion3LoneNesting_messageType) New() protoreflect.Message { + return new(fastReflection_TestVersion3LoneNesting) +} +func (x fastReflection_TestVersion3LoneNesting_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_TestVersion3LoneNesting +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_TestVersion3LoneNesting) Descriptor() protoreflect.MessageDescriptor { + return md_TestVersion3LoneNesting +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_TestVersion3LoneNesting) Type() protoreflect.MessageType { + return _fastReflection_TestVersion3LoneNesting_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_TestVersion3LoneNesting) New() protoreflect.Message { + return new(fastReflection_TestVersion3LoneNesting) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_TestVersion3LoneNesting) Interface() protoreflect.ProtoMessage { + return (*TestVersion3LoneNesting)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_TestVersion3LoneNesting) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.X != int64(0) { + value := protoreflect.ValueOfInt64(x.X) + if !f(fd_TestVersion3LoneNesting_x, value) { + return + } + } + if x.A != nil { + value := protoreflect.ValueOfMessage(x.A.ProtoReflect()) + if !f(fd_TestVersion3LoneNesting_a, value) { + return + } + } + if x.B != nil { + value := protoreflect.ValueOfMessage(x.B.ProtoReflect()) + if !f(fd_TestVersion3LoneNesting_b, value) { + return + } + } + if len(x.C) != 0 { + value := protoreflect.ValueOfList(&_TestVersion3LoneNesting_4_list{list: &x.C}) + if !f(fd_TestVersion3LoneNesting_c, value) { + return + } + } + if len(x.D) != 0 { + value := protoreflect.ValueOfList(&_TestVersion3LoneNesting_5_list{list: &x.D}) + if !f(fd_TestVersion3LoneNesting_d, value) { + return + } + } + if x.Sum != nil { + switch o := x.Sum.(type) { + case *TestVersion3LoneNesting_F: + v := o.F + value := protoreflect.ValueOfMessage(v.ProtoReflect()) + if !f(fd_TestVersion3LoneNesting_f, value) { + return + } + } + } + if x.G != nil { + value := protoreflect.ValueOfMessage(x.G.ProtoReflect()) + if !f(fd_TestVersion3LoneNesting_g, value) { + return + } + } + if len(x.H) != 0 { + value := protoreflect.ValueOfList(&_TestVersion3LoneNesting_9_list{list: &x.H}) + if !f(fd_TestVersion3LoneNesting_h, value) { + return + } + } + if x.K != nil { + value := protoreflect.ValueOfMessage(x.K.ProtoReflect()) + if !f(fd_TestVersion3LoneNesting_k, value) { + return + } + } + if x.NonCriticalField != "" { + value := protoreflect.ValueOfString(x.NonCriticalField) + if !f(fd_TestVersion3LoneNesting_non_critical_field, value) { + return + } + } + if x.Inner1 != nil { + value := protoreflect.ValueOfMessage(x.Inner1.ProtoReflect()) + if !f(fd_TestVersion3LoneNesting_inner1, value) { + return + } + } + if x.Inner2 != nil { + value := protoreflect.ValueOfMessage(x.Inner2.ProtoReflect()) + if !f(fd_TestVersion3LoneNesting_inner2, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_TestVersion3LoneNesting) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "testpb.TestVersion3LoneNesting.x": + return x.X != int64(0) + case "testpb.TestVersion3LoneNesting.a": + return x.A != nil + case "testpb.TestVersion3LoneNesting.b": + return x.B != nil + case "testpb.TestVersion3LoneNesting.c": + return len(x.C) != 0 + case "testpb.TestVersion3LoneNesting.d": + return len(x.D) != 0 + case "testpb.TestVersion3LoneNesting.f": + if x.Sum == nil { + return false + } else if _, ok := x.Sum.(*TestVersion3LoneNesting_F); ok { + return true + } else { + return false + } + case "testpb.TestVersion3LoneNesting.g": + return x.G != nil + case "testpb.TestVersion3LoneNesting.h": + return len(x.H) != 0 + case "testpb.TestVersion3LoneNesting.k": + return x.K != nil + case "testpb.TestVersion3LoneNesting.non_critical_field": + return x.NonCriticalField != "" + case "testpb.TestVersion3LoneNesting.inner1": + return x.Inner1 != nil + case "testpb.TestVersion3LoneNesting.inner2": + return x.Inner2 != nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting")) + } + panic(fmt.Errorf("message testpb.TestVersion3LoneNesting does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion3LoneNesting) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "testpb.TestVersion3LoneNesting.x": + x.X = int64(0) + case "testpb.TestVersion3LoneNesting.a": + x.A = nil + case "testpb.TestVersion3LoneNesting.b": + x.B = nil + case "testpb.TestVersion3LoneNesting.c": + x.C = nil + case "testpb.TestVersion3LoneNesting.d": + x.D = nil + case "testpb.TestVersion3LoneNesting.f": + x.Sum = nil + case "testpb.TestVersion3LoneNesting.g": + x.G = nil + case "testpb.TestVersion3LoneNesting.h": + x.H = nil + case "testpb.TestVersion3LoneNesting.k": + x.K = nil + case "testpb.TestVersion3LoneNesting.non_critical_field": + x.NonCriticalField = "" + case "testpb.TestVersion3LoneNesting.inner1": + x.Inner1 = nil + case "testpb.TestVersion3LoneNesting.inner2": + x.Inner2 = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting")) + } + panic(fmt.Errorf("message testpb.TestVersion3LoneNesting does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_TestVersion3LoneNesting) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "testpb.TestVersion3LoneNesting.x": + value := x.X + return protoreflect.ValueOfInt64(value) + case "testpb.TestVersion3LoneNesting.a": + value := x.A + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "testpb.TestVersion3LoneNesting.b": + value := x.B + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "testpb.TestVersion3LoneNesting.c": + if len(x.C) == 0 { + return protoreflect.ValueOfList(&_TestVersion3LoneNesting_4_list{}) + } + listValue := &_TestVersion3LoneNesting_4_list{list: &x.C} + return protoreflect.ValueOfList(listValue) + case "testpb.TestVersion3LoneNesting.d": + if len(x.D) == 0 { + return protoreflect.ValueOfList(&_TestVersion3LoneNesting_5_list{}) + } + listValue := &_TestVersion3LoneNesting_5_list{list: &x.D} + return protoreflect.ValueOfList(listValue) + case "testpb.TestVersion3LoneNesting.f": + if x.Sum == nil { + return protoreflect.ValueOfMessage((*TestVersion3LoneNesting)(nil).ProtoReflect()) + } else if v, ok := x.Sum.(*TestVersion3LoneNesting_F); ok { + return protoreflect.ValueOfMessage(v.F.ProtoReflect()) + } else { + return protoreflect.ValueOfMessage((*TestVersion3LoneNesting)(nil).ProtoReflect()) + } + case "testpb.TestVersion3LoneNesting.g": + value := x.G + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "testpb.TestVersion3LoneNesting.h": + if len(x.H) == 0 { + return protoreflect.ValueOfList(&_TestVersion3LoneNesting_9_list{}) + } + listValue := &_TestVersion3LoneNesting_9_list{list: &x.H} + return protoreflect.ValueOfList(listValue) + case "testpb.TestVersion3LoneNesting.k": + value := x.K + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "testpb.TestVersion3LoneNesting.non_critical_field": + value := x.NonCriticalField + return protoreflect.ValueOfString(value) + case "testpb.TestVersion3LoneNesting.inner1": + value := x.Inner1 + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "testpb.TestVersion3LoneNesting.inner2": + value := x.Inner2 + return protoreflect.ValueOfMessage(value.ProtoReflect()) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting")) + } + panic(fmt.Errorf("message testpb.TestVersion3LoneNesting does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion3LoneNesting) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "testpb.TestVersion3LoneNesting.x": + x.X = value.Int() + case "testpb.TestVersion3LoneNesting.a": + x.A = value.Message().Interface().(*TestVersion3) + case "testpb.TestVersion3LoneNesting.b": + x.B = value.Message().Interface().(*TestVersion3) + case "testpb.TestVersion3LoneNesting.c": + lv := value.List() + clv := lv.(*_TestVersion3LoneNesting_4_list) + x.C = *clv.list + case "testpb.TestVersion3LoneNesting.d": + lv := value.List() + clv := lv.(*_TestVersion3LoneNesting_5_list) + x.D = *clv.list + case "testpb.TestVersion3LoneNesting.f": + cv := value.Message().Interface().(*TestVersion3LoneNesting) + x.Sum = &TestVersion3LoneNesting_F{F: cv} + case "testpb.TestVersion3LoneNesting.g": + x.G = value.Message().Interface().(*anypb.Any) + case "testpb.TestVersion3LoneNesting.h": + lv := value.List() + clv := lv.(*_TestVersion3LoneNesting_9_list) + x.H = *clv.list + case "testpb.TestVersion3LoneNesting.k": + x.K = value.Message().Interface().(*Customer1) + case "testpb.TestVersion3LoneNesting.non_critical_field": + x.NonCriticalField = value.Interface().(string) + case "testpb.TestVersion3LoneNesting.inner1": + x.Inner1 = value.Message().Interface().(*TestVersion3LoneNesting_Inner1) + case "testpb.TestVersion3LoneNesting.inner2": + x.Inner2 = value.Message().Interface().(*TestVersion3LoneNesting_Inner2) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting")) + } + panic(fmt.Errorf("message testpb.TestVersion3LoneNesting does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion3LoneNesting) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.TestVersion3LoneNesting.a": + if x.A == nil { + x.A = new(TestVersion3) + } + return protoreflect.ValueOfMessage(x.A.ProtoReflect()) + case "testpb.TestVersion3LoneNesting.b": + if x.B == nil { + x.B = new(TestVersion3) + } + return protoreflect.ValueOfMessage(x.B.ProtoReflect()) + case "testpb.TestVersion3LoneNesting.c": + if x.C == nil { + x.C = []*TestVersion3{} + } + value := &_TestVersion3LoneNesting_4_list{list: &x.C} + return protoreflect.ValueOfList(value) + case "testpb.TestVersion3LoneNesting.d": + if x.D == nil { + x.D = []*TestVersion3{} + } + value := &_TestVersion3LoneNesting_5_list{list: &x.D} + return protoreflect.ValueOfList(value) + case "testpb.TestVersion3LoneNesting.f": + if x.Sum == nil { + value := &TestVersion3LoneNesting{} + oneofValue := &TestVersion3LoneNesting_F{F: value} + x.Sum = oneofValue + return protoreflect.ValueOfMessage(value.ProtoReflect()) + } + switch m := x.Sum.(type) { + case *TestVersion3LoneNesting_F: + return protoreflect.ValueOfMessage(m.F.ProtoReflect()) + default: + value := &TestVersion3LoneNesting{} + oneofValue := &TestVersion3LoneNesting_F{F: value} + x.Sum = oneofValue + return protoreflect.ValueOfMessage(value.ProtoReflect()) + } + case "testpb.TestVersion3LoneNesting.g": + if x.G == nil { + x.G = new(anypb.Any) + } + return protoreflect.ValueOfMessage(x.G.ProtoReflect()) + case "testpb.TestVersion3LoneNesting.h": + if x.H == nil { + x.H = []*TestVersion1{} + } + value := &_TestVersion3LoneNesting_9_list{list: &x.H} + return protoreflect.ValueOfList(value) + case "testpb.TestVersion3LoneNesting.k": + if x.K == nil { + x.K = new(Customer1) + } + return protoreflect.ValueOfMessage(x.K.ProtoReflect()) + case "testpb.TestVersion3LoneNesting.inner1": + if x.Inner1 == nil { + x.Inner1 = new(TestVersion3LoneNesting_Inner1) + } + return protoreflect.ValueOfMessage(x.Inner1.ProtoReflect()) + case "testpb.TestVersion3LoneNesting.inner2": + if x.Inner2 == nil { + x.Inner2 = new(TestVersion3LoneNesting_Inner2) + } + return protoreflect.ValueOfMessage(x.Inner2.ProtoReflect()) + case "testpb.TestVersion3LoneNesting.x": + panic(fmt.Errorf("field x of message testpb.TestVersion3LoneNesting is not mutable")) + case "testpb.TestVersion3LoneNesting.non_critical_field": + panic(fmt.Errorf("field non_critical_field of message testpb.TestVersion3LoneNesting is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting")) + } + panic(fmt.Errorf("message testpb.TestVersion3LoneNesting does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_TestVersion3LoneNesting) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.TestVersion3LoneNesting.x": + return protoreflect.ValueOfInt64(int64(0)) + case "testpb.TestVersion3LoneNesting.a": + m := new(TestVersion3) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "testpb.TestVersion3LoneNesting.b": + m := new(TestVersion3) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "testpb.TestVersion3LoneNesting.c": + list := []*TestVersion3{} + return protoreflect.ValueOfList(&_TestVersion3LoneNesting_4_list{list: &list}) + case "testpb.TestVersion3LoneNesting.d": + list := []*TestVersion3{} + return protoreflect.ValueOfList(&_TestVersion3LoneNesting_5_list{list: &list}) + case "testpb.TestVersion3LoneNesting.f": + value := &TestVersion3LoneNesting{} + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "testpb.TestVersion3LoneNesting.g": + m := new(anypb.Any) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "testpb.TestVersion3LoneNesting.h": + list := []*TestVersion1{} + return protoreflect.ValueOfList(&_TestVersion3LoneNesting_9_list{list: &list}) + case "testpb.TestVersion3LoneNesting.k": + m := new(Customer1) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "testpb.TestVersion3LoneNesting.non_critical_field": + return protoreflect.ValueOfString("") + case "testpb.TestVersion3LoneNesting.inner1": + m := new(TestVersion3LoneNesting_Inner1) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "testpb.TestVersion3LoneNesting.inner2": + m := new(TestVersion3LoneNesting_Inner2) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting")) + } + panic(fmt.Errorf("message testpb.TestVersion3LoneNesting does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_TestVersion3LoneNesting) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + case "testpb.TestVersion3LoneNesting.sum": + if x.Sum == nil { + return nil + } + switch x.Sum.(type) { + case *TestVersion3LoneNesting_F: + return x.Descriptor().Fields().ByName("f") + } + default: + panic(fmt.Errorf("%s is not a oneof field in testpb.TestVersion3LoneNesting", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_TestVersion3LoneNesting) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion3LoneNesting) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_TestVersion3LoneNesting) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_TestVersion3LoneNesting) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*TestVersion3LoneNesting) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + if x.X != 0 { + n += 1 + runtime.Sov(uint64(x.X)) + } + if x.A != nil { + l = options.Size(x.A) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.B != nil { + l = options.Size(x.B) + n += 1 + l + runtime.Sov(uint64(l)) + } + if len(x.C) > 0 { + for _, e := range x.C { + l = options.Size(e) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + if len(x.D) > 0 { + for _, e := range x.D { + l = options.Size(e) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + switch x := x.Sum.(type) { + case *TestVersion3LoneNesting_F: + if x == nil { + break + } + l = options.Size(x.F) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.G != nil { + l = options.Size(x.G) + n += 1 + l + runtime.Sov(uint64(l)) + } + if len(x.H) > 0 { + for _, e := range x.H { + l = options.Size(e) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + if x.K != nil { + l = options.Size(x.K) + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.NonCriticalField) + if l > 0 { + n += 2 + l + runtime.Sov(uint64(l)) + } + if x.Inner1 != nil { + l = options.Size(x.Inner1) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.Inner2 != nil { + l = options.Size(x.Inner2) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*TestVersion3LoneNesting) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + switch x := x.Sum.(type) { + case *TestVersion3LoneNesting_F: + encoded, err := options.Marshal(x.F) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x3a + } + if len(x.NonCriticalField) > 0 { + i -= len(x.NonCriticalField) + copy(dAtA[i:], x.NonCriticalField) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.NonCriticalField))) + i-- + dAtA[i] = 0x40 + i-- + dAtA[i] = 0xba + } + if x.Inner2 != nil { + encoded, err := options.Marshal(x.Inner2) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x7a + } + if x.Inner1 != nil { + encoded, err := options.Marshal(x.Inner1) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x72 + } + if x.K != nil { + encoded, err := options.Marshal(x.K) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x62 + } + if len(x.H) > 0 { + for iNdEx := len(x.H) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.H[iNdEx]) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x4a + } + } + if x.G != nil { + encoded, err := options.Marshal(x.G) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x42 + } + if len(x.D) > 0 { + for iNdEx := len(x.D) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.D[iNdEx]) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x2a + } + } + if len(x.C) > 0 { + for iNdEx := len(x.C) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.C[iNdEx]) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x22 + } + } + if x.B != nil { + encoded, err := options.Marshal(x.B) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x1a + } + if x.A != nil { + encoded, err := options.Marshal(x.A) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x12 + } + if x.X != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.X)) + i-- + dAtA[i] = 0x8 + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*TestVersion3LoneNesting) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion3LoneNesting: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion3LoneNesting: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field X", wireType) + } + x.X = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.X |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field A", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.A == nil { + x.A = &TestVersion3{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.A); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field B", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.B == nil { + x.B = &TestVersion3{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.B); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field C", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.C = append(x.C, &TestVersion3{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.C[len(x.C)-1]); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field D", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.D = append(x.D, &TestVersion3{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.D[len(x.D)-1]); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field F", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + v := &TestVersion3LoneNesting{} + if err := options.Unmarshal(dAtA[iNdEx:postIndex], v); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + x.Sum = &TestVersion3LoneNesting_F{v} + iNdEx = postIndex + case 8: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field G", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.G == nil { + x.G = &anypb.Any{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.G); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field H", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.H = append(x.H, &TestVersion1{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.H[len(x.H)-1]); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 12: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field K", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.K == nil { + x.K = &Customer1{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.K); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 1031: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field NonCriticalField", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.NonCriticalField = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 14: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Inner1", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.Inner1 == nil { + x.Inner1 = &TestVersion3LoneNesting_Inner1{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Inner1); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 15: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Inner2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.Inner2 == nil { + x.Inner2 = &TestVersion3LoneNesting_Inner2{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Inner2); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var ( + md_TestVersion3LoneNesting_Inner1 protoreflect.MessageDescriptor + fd_TestVersion3LoneNesting_Inner1_id protoreflect.FieldDescriptor + fd_TestVersion3LoneNesting_Inner1_name protoreflect.FieldDescriptor + fd_TestVersion3LoneNesting_Inner1_inner protoreflect.FieldDescriptor +) + +func init() { + file_unknonwnproto_proto_init() + md_TestVersion3LoneNesting_Inner1 = File_unknonwnproto_proto.Messages().ByName("TestVersion3LoneNesting").Messages().ByName("Inner1") + fd_TestVersion3LoneNesting_Inner1_id = md_TestVersion3LoneNesting_Inner1.Fields().ByName("id") + fd_TestVersion3LoneNesting_Inner1_name = md_TestVersion3LoneNesting_Inner1.Fields().ByName("name") + fd_TestVersion3LoneNesting_Inner1_inner = md_TestVersion3LoneNesting_Inner1.Fields().ByName("inner") +} + +var _ protoreflect.Message = (*fastReflection_TestVersion3LoneNesting_Inner1)(nil) + +type fastReflection_TestVersion3LoneNesting_Inner1 TestVersion3LoneNesting_Inner1 + +func (x *TestVersion3LoneNesting_Inner1) ProtoReflect() protoreflect.Message { + return (*fastReflection_TestVersion3LoneNesting_Inner1)(x) +} + +func (x *TestVersion3LoneNesting_Inner1) slowProtoReflect() protoreflect.Message { + mi := &file_unknonwnproto_proto_msgTypes[25] + 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) +} + +var _fastReflection_TestVersion3LoneNesting_Inner1_messageType fastReflection_TestVersion3LoneNesting_Inner1_messageType +var _ protoreflect.MessageType = fastReflection_TestVersion3LoneNesting_Inner1_messageType{} + +type fastReflection_TestVersion3LoneNesting_Inner1_messageType struct{} + +func (x fastReflection_TestVersion3LoneNesting_Inner1_messageType) Zero() protoreflect.Message { + return (*fastReflection_TestVersion3LoneNesting_Inner1)(nil) +} +func (x fastReflection_TestVersion3LoneNesting_Inner1_messageType) New() protoreflect.Message { + return new(fastReflection_TestVersion3LoneNesting_Inner1) +} +func (x fastReflection_TestVersion3LoneNesting_Inner1_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_TestVersion3LoneNesting_Inner1 +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_TestVersion3LoneNesting_Inner1) Descriptor() protoreflect.MessageDescriptor { + return md_TestVersion3LoneNesting_Inner1 +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_TestVersion3LoneNesting_Inner1) Type() protoreflect.MessageType { + return _fastReflection_TestVersion3LoneNesting_Inner1_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_TestVersion3LoneNesting_Inner1) New() protoreflect.Message { + return new(fastReflection_TestVersion3LoneNesting_Inner1) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_TestVersion3LoneNesting_Inner1) Interface() protoreflect.ProtoMessage { + return (*TestVersion3LoneNesting_Inner1)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_TestVersion3LoneNesting_Inner1) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Id != int64(0) { + value := protoreflect.ValueOfInt64(x.Id) + if !f(fd_TestVersion3LoneNesting_Inner1_id, value) { + return + } + } + if x.Name != "" { + value := protoreflect.ValueOfString(x.Name) + if !f(fd_TestVersion3LoneNesting_Inner1_name, value) { + return + } + } + if x.Inner != nil { + value := protoreflect.ValueOfMessage(x.Inner.ProtoReflect()) + if !f(fd_TestVersion3LoneNesting_Inner1_inner, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_TestVersion3LoneNesting_Inner1) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "testpb.TestVersion3LoneNesting.Inner1.id": + return x.Id != int64(0) + case "testpb.TestVersion3LoneNesting.Inner1.name": + return x.Name != "" + case "testpb.TestVersion3LoneNesting.Inner1.inner": + return x.Inner != nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting.Inner1")) + } + panic(fmt.Errorf("message testpb.TestVersion3LoneNesting.Inner1 does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion3LoneNesting_Inner1) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "testpb.TestVersion3LoneNesting.Inner1.id": + x.Id = int64(0) + case "testpb.TestVersion3LoneNesting.Inner1.name": + x.Name = "" + case "testpb.TestVersion3LoneNesting.Inner1.inner": + x.Inner = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting.Inner1")) + } + panic(fmt.Errorf("message testpb.TestVersion3LoneNesting.Inner1 does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_TestVersion3LoneNesting_Inner1) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "testpb.TestVersion3LoneNesting.Inner1.id": + value := x.Id + return protoreflect.ValueOfInt64(value) + case "testpb.TestVersion3LoneNesting.Inner1.name": + value := x.Name + return protoreflect.ValueOfString(value) + case "testpb.TestVersion3LoneNesting.Inner1.inner": + value := x.Inner + return protoreflect.ValueOfMessage(value.ProtoReflect()) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting.Inner1")) + } + panic(fmt.Errorf("message testpb.TestVersion3LoneNesting.Inner1 does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion3LoneNesting_Inner1) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "testpb.TestVersion3LoneNesting.Inner1.id": + x.Id = value.Int() + case "testpb.TestVersion3LoneNesting.Inner1.name": + x.Name = value.Interface().(string) + case "testpb.TestVersion3LoneNesting.Inner1.inner": + x.Inner = value.Message().Interface().(*TestVersion3LoneNesting_Inner1_InnerInner) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting.Inner1")) + } + panic(fmt.Errorf("message testpb.TestVersion3LoneNesting.Inner1 does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion3LoneNesting_Inner1) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.TestVersion3LoneNesting.Inner1.inner": + if x.Inner == nil { + x.Inner = new(TestVersion3LoneNesting_Inner1_InnerInner) + } + return protoreflect.ValueOfMessage(x.Inner.ProtoReflect()) + case "testpb.TestVersion3LoneNesting.Inner1.id": + panic(fmt.Errorf("field id of message testpb.TestVersion3LoneNesting.Inner1 is not mutable")) + case "testpb.TestVersion3LoneNesting.Inner1.name": + panic(fmt.Errorf("field name of message testpb.TestVersion3LoneNesting.Inner1 is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting.Inner1")) + } + panic(fmt.Errorf("message testpb.TestVersion3LoneNesting.Inner1 does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_TestVersion3LoneNesting_Inner1) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.TestVersion3LoneNesting.Inner1.id": + return protoreflect.ValueOfInt64(int64(0)) + case "testpb.TestVersion3LoneNesting.Inner1.name": + return protoreflect.ValueOfString("") + case "testpb.TestVersion3LoneNesting.Inner1.inner": + m := new(TestVersion3LoneNesting_Inner1_InnerInner) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting.Inner1")) + } + panic(fmt.Errorf("message testpb.TestVersion3LoneNesting.Inner1 does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_TestVersion3LoneNesting_Inner1) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in testpb.TestVersion3LoneNesting.Inner1", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_TestVersion3LoneNesting_Inner1) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion3LoneNesting_Inner1) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_TestVersion3LoneNesting_Inner1) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_TestVersion3LoneNesting_Inner1) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*TestVersion3LoneNesting_Inner1) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + if x.Id != 0 { + n += 1 + runtime.Sov(uint64(x.Id)) + } + l = len(x.Name) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.Inner != nil { + l = options.Size(x.Inner) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*TestVersion3LoneNesting_Inner1) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if x.Inner != nil { + encoded, err := options.Marshal(x.Inner) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x1a + } + if len(x.Name) > 0 { + i -= len(x.Name) + copy(dAtA[i:], x.Name) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Name))) + i-- + dAtA[i] = 0x12 + } + if x.Id != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.Id)) + i-- + dAtA[i] = 0x8 + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*TestVersion3LoneNesting_Inner1) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion3LoneNesting_Inner1: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion3LoneNesting_Inner1: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + x.Id = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.Id |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.Inner == nil { + x.Inner = &TestVersion3LoneNesting_Inner1_InnerInner{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Inner); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var ( + md_TestVersion3LoneNesting_Inner1_InnerInner protoreflect.MessageDescriptor + fd_TestVersion3LoneNesting_Inner1_InnerInner_id protoreflect.FieldDescriptor + fd_TestVersion3LoneNesting_Inner1_InnerInner_city protoreflect.FieldDescriptor +) + +func init() { + file_unknonwnproto_proto_init() + md_TestVersion3LoneNesting_Inner1_InnerInner = File_unknonwnproto_proto.Messages().ByName("TestVersion3LoneNesting").Messages().ByName("Inner1").Messages().ByName("InnerInner") + fd_TestVersion3LoneNesting_Inner1_InnerInner_id = md_TestVersion3LoneNesting_Inner1_InnerInner.Fields().ByName("id") + fd_TestVersion3LoneNesting_Inner1_InnerInner_city = md_TestVersion3LoneNesting_Inner1_InnerInner.Fields().ByName("city") +} + +var _ protoreflect.Message = (*fastReflection_TestVersion3LoneNesting_Inner1_InnerInner)(nil) + +type fastReflection_TestVersion3LoneNesting_Inner1_InnerInner TestVersion3LoneNesting_Inner1_InnerInner + +func (x *TestVersion3LoneNesting_Inner1_InnerInner) ProtoReflect() protoreflect.Message { + return (*fastReflection_TestVersion3LoneNesting_Inner1_InnerInner)(x) +} + +func (x *TestVersion3LoneNesting_Inner1_InnerInner) slowProtoReflect() protoreflect.Message { + mi := &file_unknonwnproto_proto_msgTypes[27] + 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) +} + +var _fastReflection_TestVersion3LoneNesting_Inner1_InnerInner_messageType fastReflection_TestVersion3LoneNesting_Inner1_InnerInner_messageType +var _ protoreflect.MessageType = fastReflection_TestVersion3LoneNesting_Inner1_InnerInner_messageType{} + +type fastReflection_TestVersion3LoneNesting_Inner1_InnerInner_messageType struct{} + +func (x fastReflection_TestVersion3LoneNesting_Inner1_InnerInner_messageType) Zero() protoreflect.Message { + return (*fastReflection_TestVersion3LoneNesting_Inner1_InnerInner)(nil) +} +func (x fastReflection_TestVersion3LoneNesting_Inner1_InnerInner_messageType) New() protoreflect.Message { + return new(fastReflection_TestVersion3LoneNesting_Inner1_InnerInner) +} +func (x fastReflection_TestVersion3LoneNesting_Inner1_InnerInner_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_TestVersion3LoneNesting_Inner1_InnerInner +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_TestVersion3LoneNesting_Inner1_InnerInner) Descriptor() protoreflect.MessageDescriptor { + return md_TestVersion3LoneNesting_Inner1_InnerInner +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_TestVersion3LoneNesting_Inner1_InnerInner) Type() protoreflect.MessageType { + return _fastReflection_TestVersion3LoneNesting_Inner1_InnerInner_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_TestVersion3LoneNesting_Inner1_InnerInner) New() protoreflect.Message { + return new(fastReflection_TestVersion3LoneNesting_Inner1_InnerInner) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_TestVersion3LoneNesting_Inner1_InnerInner) Interface() protoreflect.ProtoMessage { + return (*TestVersion3LoneNesting_Inner1_InnerInner)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_TestVersion3LoneNesting_Inner1_InnerInner) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Id != "" { + value := protoreflect.ValueOfString(x.Id) + if !f(fd_TestVersion3LoneNesting_Inner1_InnerInner_id, value) { + return + } + } + if x.City != "" { + value := protoreflect.ValueOfString(x.City) + if !f(fd_TestVersion3LoneNesting_Inner1_InnerInner_city, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_TestVersion3LoneNesting_Inner1_InnerInner) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "testpb.TestVersion3LoneNesting.Inner1.InnerInner.id": + return x.Id != "" + case "testpb.TestVersion3LoneNesting.Inner1.InnerInner.city": + return x.City != "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting.Inner1.InnerInner")) + } + panic(fmt.Errorf("message testpb.TestVersion3LoneNesting.Inner1.InnerInner does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion3LoneNesting_Inner1_InnerInner) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "testpb.TestVersion3LoneNesting.Inner1.InnerInner.id": + x.Id = "" + case "testpb.TestVersion3LoneNesting.Inner1.InnerInner.city": + x.City = "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting.Inner1.InnerInner")) + } + panic(fmt.Errorf("message testpb.TestVersion3LoneNesting.Inner1.InnerInner does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_TestVersion3LoneNesting_Inner1_InnerInner) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "testpb.TestVersion3LoneNesting.Inner1.InnerInner.id": + value := x.Id + return protoreflect.ValueOfString(value) + case "testpb.TestVersion3LoneNesting.Inner1.InnerInner.city": + value := x.City + return protoreflect.ValueOfString(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting.Inner1.InnerInner")) + } + panic(fmt.Errorf("message testpb.TestVersion3LoneNesting.Inner1.InnerInner does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion3LoneNesting_Inner1_InnerInner) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "testpb.TestVersion3LoneNesting.Inner1.InnerInner.id": + x.Id = value.Interface().(string) + case "testpb.TestVersion3LoneNesting.Inner1.InnerInner.city": + x.City = value.Interface().(string) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting.Inner1.InnerInner")) + } + panic(fmt.Errorf("message testpb.TestVersion3LoneNesting.Inner1.InnerInner does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion3LoneNesting_Inner1_InnerInner) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.TestVersion3LoneNesting.Inner1.InnerInner.id": + panic(fmt.Errorf("field id of message testpb.TestVersion3LoneNesting.Inner1.InnerInner is not mutable")) + case "testpb.TestVersion3LoneNesting.Inner1.InnerInner.city": + panic(fmt.Errorf("field city of message testpb.TestVersion3LoneNesting.Inner1.InnerInner is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting.Inner1.InnerInner")) + } + panic(fmt.Errorf("message testpb.TestVersion3LoneNesting.Inner1.InnerInner does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_TestVersion3LoneNesting_Inner1_InnerInner) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.TestVersion3LoneNesting.Inner1.InnerInner.id": + return protoreflect.ValueOfString("") + case "testpb.TestVersion3LoneNesting.Inner1.InnerInner.city": + return protoreflect.ValueOfString("") + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting.Inner1.InnerInner")) + } + panic(fmt.Errorf("message testpb.TestVersion3LoneNesting.Inner1.InnerInner does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_TestVersion3LoneNesting_Inner1_InnerInner) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in testpb.TestVersion3LoneNesting.Inner1.InnerInner", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_TestVersion3LoneNesting_Inner1_InnerInner) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion3LoneNesting_Inner1_InnerInner) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_TestVersion3LoneNesting_Inner1_InnerInner) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_TestVersion3LoneNesting_Inner1_InnerInner) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*TestVersion3LoneNesting_Inner1_InnerInner) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + l = len(x.Id) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.City) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*TestVersion3LoneNesting_Inner1_InnerInner) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if len(x.City) > 0 { + i -= len(x.City) + copy(dAtA[i:], x.City) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.City))) + i-- + dAtA[i] = 0x12 + } + if len(x.Id) > 0 { + i -= len(x.Id) + copy(dAtA[i:], x.Id) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Id))) + i-- + dAtA[i] = 0xa + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*TestVersion3LoneNesting_Inner1_InnerInner) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion3LoneNesting_Inner1_InnerInner: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion3LoneNesting_Inner1_InnerInner: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Id = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field City", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.City = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var ( + md_TestVersion3LoneNesting_Inner2 protoreflect.MessageDescriptor + fd_TestVersion3LoneNesting_Inner2_id protoreflect.FieldDescriptor + fd_TestVersion3LoneNesting_Inner2_country protoreflect.FieldDescriptor + fd_TestVersion3LoneNesting_Inner2_inner protoreflect.FieldDescriptor +) + +func init() { + file_unknonwnproto_proto_init() + md_TestVersion3LoneNesting_Inner2 = File_unknonwnproto_proto.Messages().ByName("TestVersion3LoneNesting").Messages().ByName("Inner2") + fd_TestVersion3LoneNesting_Inner2_id = md_TestVersion3LoneNesting_Inner2.Fields().ByName("id") + fd_TestVersion3LoneNesting_Inner2_country = md_TestVersion3LoneNesting_Inner2.Fields().ByName("country") + fd_TestVersion3LoneNesting_Inner2_inner = md_TestVersion3LoneNesting_Inner2.Fields().ByName("inner") +} + +var _ protoreflect.Message = (*fastReflection_TestVersion3LoneNesting_Inner2)(nil) + +type fastReflection_TestVersion3LoneNesting_Inner2 TestVersion3LoneNesting_Inner2 + +func (x *TestVersion3LoneNesting_Inner2) ProtoReflect() protoreflect.Message { + return (*fastReflection_TestVersion3LoneNesting_Inner2)(x) +} + +func (x *TestVersion3LoneNesting_Inner2) slowProtoReflect() protoreflect.Message { + mi := &file_unknonwnproto_proto_msgTypes[26] + 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) +} + +var _fastReflection_TestVersion3LoneNesting_Inner2_messageType fastReflection_TestVersion3LoneNesting_Inner2_messageType +var _ protoreflect.MessageType = fastReflection_TestVersion3LoneNesting_Inner2_messageType{} + +type fastReflection_TestVersion3LoneNesting_Inner2_messageType struct{} + +func (x fastReflection_TestVersion3LoneNesting_Inner2_messageType) Zero() protoreflect.Message { + return (*fastReflection_TestVersion3LoneNesting_Inner2)(nil) +} +func (x fastReflection_TestVersion3LoneNesting_Inner2_messageType) New() protoreflect.Message { + return new(fastReflection_TestVersion3LoneNesting_Inner2) +} +func (x fastReflection_TestVersion3LoneNesting_Inner2_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_TestVersion3LoneNesting_Inner2 +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_TestVersion3LoneNesting_Inner2) Descriptor() protoreflect.MessageDescriptor { + return md_TestVersion3LoneNesting_Inner2 +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_TestVersion3LoneNesting_Inner2) Type() protoreflect.MessageType { + return _fastReflection_TestVersion3LoneNesting_Inner2_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_TestVersion3LoneNesting_Inner2) New() protoreflect.Message { + return new(fastReflection_TestVersion3LoneNesting_Inner2) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_TestVersion3LoneNesting_Inner2) Interface() protoreflect.ProtoMessage { + return (*TestVersion3LoneNesting_Inner2)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_TestVersion3LoneNesting_Inner2) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Id != "" { + value := protoreflect.ValueOfString(x.Id) + if !f(fd_TestVersion3LoneNesting_Inner2_id, value) { + return + } + } + if x.Country != "" { + value := protoreflect.ValueOfString(x.Country) + if !f(fd_TestVersion3LoneNesting_Inner2_country, value) { + return + } + } + if x.Inner != nil { + value := protoreflect.ValueOfMessage(x.Inner.ProtoReflect()) + if !f(fd_TestVersion3LoneNesting_Inner2_inner, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_TestVersion3LoneNesting_Inner2) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "testpb.TestVersion3LoneNesting.Inner2.id": + return x.Id != "" + case "testpb.TestVersion3LoneNesting.Inner2.country": + return x.Country != "" + case "testpb.TestVersion3LoneNesting.Inner2.inner": + return x.Inner != nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting.Inner2")) + } + panic(fmt.Errorf("message testpb.TestVersion3LoneNesting.Inner2 does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion3LoneNesting_Inner2) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "testpb.TestVersion3LoneNesting.Inner2.id": + x.Id = "" + case "testpb.TestVersion3LoneNesting.Inner2.country": + x.Country = "" + case "testpb.TestVersion3LoneNesting.Inner2.inner": + x.Inner = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting.Inner2")) + } + panic(fmt.Errorf("message testpb.TestVersion3LoneNesting.Inner2 does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_TestVersion3LoneNesting_Inner2) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "testpb.TestVersion3LoneNesting.Inner2.id": + value := x.Id + return protoreflect.ValueOfString(value) + case "testpb.TestVersion3LoneNesting.Inner2.country": + value := x.Country + return protoreflect.ValueOfString(value) + case "testpb.TestVersion3LoneNesting.Inner2.inner": + value := x.Inner + return protoreflect.ValueOfMessage(value.ProtoReflect()) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting.Inner2")) + } + panic(fmt.Errorf("message testpb.TestVersion3LoneNesting.Inner2 does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion3LoneNesting_Inner2) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "testpb.TestVersion3LoneNesting.Inner2.id": + x.Id = value.Interface().(string) + case "testpb.TestVersion3LoneNesting.Inner2.country": + x.Country = value.Interface().(string) + case "testpb.TestVersion3LoneNesting.Inner2.inner": + x.Inner = value.Message().Interface().(*TestVersion3LoneNesting_Inner2_InnerInner) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting.Inner2")) + } + panic(fmt.Errorf("message testpb.TestVersion3LoneNesting.Inner2 does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion3LoneNesting_Inner2) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.TestVersion3LoneNesting.Inner2.inner": + if x.Inner == nil { + x.Inner = new(TestVersion3LoneNesting_Inner2_InnerInner) + } + return protoreflect.ValueOfMessage(x.Inner.ProtoReflect()) + case "testpb.TestVersion3LoneNesting.Inner2.id": + panic(fmt.Errorf("field id of message testpb.TestVersion3LoneNesting.Inner2 is not mutable")) + case "testpb.TestVersion3LoneNesting.Inner2.country": + panic(fmt.Errorf("field country of message testpb.TestVersion3LoneNesting.Inner2 is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting.Inner2")) + } + panic(fmt.Errorf("message testpb.TestVersion3LoneNesting.Inner2 does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_TestVersion3LoneNesting_Inner2) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.TestVersion3LoneNesting.Inner2.id": + return protoreflect.ValueOfString("") + case "testpb.TestVersion3LoneNesting.Inner2.country": + return protoreflect.ValueOfString("") + case "testpb.TestVersion3LoneNesting.Inner2.inner": + m := new(TestVersion3LoneNesting_Inner2_InnerInner) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting.Inner2")) + } + panic(fmt.Errorf("message testpb.TestVersion3LoneNesting.Inner2 does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_TestVersion3LoneNesting_Inner2) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in testpb.TestVersion3LoneNesting.Inner2", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_TestVersion3LoneNesting_Inner2) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion3LoneNesting_Inner2) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_TestVersion3LoneNesting_Inner2) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_TestVersion3LoneNesting_Inner2) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*TestVersion3LoneNesting_Inner2) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + l = len(x.Id) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Country) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.Inner != nil { + l = options.Size(x.Inner) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*TestVersion3LoneNesting_Inner2) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if x.Inner != nil { + encoded, err := options.Marshal(x.Inner) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x1a + } + if len(x.Country) > 0 { + i -= len(x.Country) + copy(dAtA[i:], x.Country) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Country))) + i-- + dAtA[i] = 0x12 + } + if len(x.Id) > 0 { + i -= len(x.Id) + copy(dAtA[i:], x.Id) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Id))) + i-- + dAtA[i] = 0xa + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*TestVersion3LoneNesting_Inner2) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion3LoneNesting_Inner2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion3LoneNesting_Inner2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Id = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Country", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Country = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.Inner == nil { + x.Inner = &TestVersion3LoneNesting_Inner2_InnerInner{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Inner); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var ( + md_TestVersion3LoneNesting_Inner2_InnerInner protoreflect.MessageDescriptor + fd_TestVersion3LoneNesting_Inner2_InnerInner_id protoreflect.FieldDescriptor + fd_TestVersion3LoneNesting_Inner2_InnerInner_city protoreflect.FieldDescriptor +) + +func init() { + file_unknonwnproto_proto_init() + md_TestVersion3LoneNesting_Inner2_InnerInner = File_unknonwnproto_proto.Messages().ByName("TestVersion3LoneNesting").Messages().ByName("Inner2").Messages().ByName("InnerInner") + fd_TestVersion3LoneNesting_Inner2_InnerInner_id = md_TestVersion3LoneNesting_Inner2_InnerInner.Fields().ByName("id") + fd_TestVersion3LoneNesting_Inner2_InnerInner_city = md_TestVersion3LoneNesting_Inner2_InnerInner.Fields().ByName("city") +} + +var _ protoreflect.Message = (*fastReflection_TestVersion3LoneNesting_Inner2_InnerInner)(nil) + +type fastReflection_TestVersion3LoneNesting_Inner2_InnerInner TestVersion3LoneNesting_Inner2_InnerInner + +func (x *TestVersion3LoneNesting_Inner2_InnerInner) ProtoReflect() protoreflect.Message { + return (*fastReflection_TestVersion3LoneNesting_Inner2_InnerInner)(x) +} + +func (x *TestVersion3LoneNesting_Inner2_InnerInner) slowProtoReflect() protoreflect.Message { + mi := &file_unknonwnproto_proto_msgTypes[28] + 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) +} + +var _fastReflection_TestVersion3LoneNesting_Inner2_InnerInner_messageType fastReflection_TestVersion3LoneNesting_Inner2_InnerInner_messageType +var _ protoreflect.MessageType = fastReflection_TestVersion3LoneNesting_Inner2_InnerInner_messageType{} + +type fastReflection_TestVersion3LoneNesting_Inner2_InnerInner_messageType struct{} + +func (x fastReflection_TestVersion3LoneNesting_Inner2_InnerInner_messageType) Zero() protoreflect.Message { + return (*fastReflection_TestVersion3LoneNesting_Inner2_InnerInner)(nil) +} +func (x fastReflection_TestVersion3LoneNesting_Inner2_InnerInner_messageType) New() protoreflect.Message { + return new(fastReflection_TestVersion3LoneNesting_Inner2_InnerInner) +} +func (x fastReflection_TestVersion3LoneNesting_Inner2_InnerInner_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_TestVersion3LoneNesting_Inner2_InnerInner +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_TestVersion3LoneNesting_Inner2_InnerInner) Descriptor() protoreflect.MessageDescriptor { + return md_TestVersion3LoneNesting_Inner2_InnerInner +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_TestVersion3LoneNesting_Inner2_InnerInner) Type() protoreflect.MessageType { + return _fastReflection_TestVersion3LoneNesting_Inner2_InnerInner_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_TestVersion3LoneNesting_Inner2_InnerInner) New() protoreflect.Message { + return new(fastReflection_TestVersion3LoneNesting_Inner2_InnerInner) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_TestVersion3LoneNesting_Inner2_InnerInner) Interface() protoreflect.ProtoMessage { + return (*TestVersion3LoneNesting_Inner2_InnerInner)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_TestVersion3LoneNesting_Inner2_InnerInner) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Id != "" { + value := protoreflect.ValueOfString(x.Id) + if !f(fd_TestVersion3LoneNesting_Inner2_InnerInner_id, value) { + return + } + } + if x.City != "" { + value := protoreflect.ValueOfString(x.City) + if !f(fd_TestVersion3LoneNesting_Inner2_InnerInner_city, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_TestVersion3LoneNesting_Inner2_InnerInner) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "testpb.TestVersion3LoneNesting.Inner2.InnerInner.id": + return x.Id != "" + case "testpb.TestVersion3LoneNesting.Inner2.InnerInner.city": + return x.City != "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting.Inner2.InnerInner")) + } + panic(fmt.Errorf("message testpb.TestVersion3LoneNesting.Inner2.InnerInner does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion3LoneNesting_Inner2_InnerInner) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "testpb.TestVersion3LoneNesting.Inner2.InnerInner.id": + x.Id = "" + case "testpb.TestVersion3LoneNesting.Inner2.InnerInner.city": + x.City = "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting.Inner2.InnerInner")) + } + panic(fmt.Errorf("message testpb.TestVersion3LoneNesting.Inner2.InnerInner does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_TestVersion3LoneNesting_Inner2_InnerInner) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "testpb.TestVersion3LoneNesting.Inner2.InnerInner.id": + value := x.Id + return protoreflect.ValueOfString(value) + case "testpb.TestVersion3LoneNesting.Inner2.InnerInner.city": + value := x.City + return protoreflect.ValueOfString(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting.Inner2.InnerInner")) + } + panic(fmt.Errorf("message testpb.TestVersion3LoneNesting.Inner2.InnerInner does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion3LoneNesting_Inner2_InnerInner) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "testpb.TestVersion3LoneNesting.Inner2.InnerInner.id": + x.Id = value.Interface().(string) + case "testpb.TestVersion3LoneNesting.Inner2.InnerInner.city": + x.City = value.Interface().(string) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting.Inner2.InnerInner")) + } + panic(fmt.Errorf("message testpb.TestVersion3LoneNesting.Inner2.InnerInner does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion3LoneNesting_Inner2_InnerInner) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.TestVersion3LoneNesting.Inner2.InnerInner.id": + panic(fmt.Errorf("field id of message testpb.TestVersion3LoneNesting.Inner2.InnerInner is not mutable")) + case "testpb.TestVersion3LoneNesting.Inner2.InnerInner.city": + panic(fmt.Errorf("field city of message testpb.TestVersion3LoneNesting.Inner2.InnerInner is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting.Inner2.InnerInner")) + } + panic(fmt.Errorf("message testpb.TestVersion3LoneNesting.Inner2.InnerInner does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_TestVersion3LoneNesting_Inner2_InnerInner) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.TestVersion3LoneNesting.Inner2.InnerInner.id": + return protoreflect.ValueOfString("") + case "testpb.TestVersion3LoneNesting.Inner2.InnerInner.city": + return protoreflect.ValueOfString("") + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting.Inner2.InnerInner")) + } + panic(fmt.Errorf("message testpb.TestVersion3LoneNesting.Inner2.InnerInner does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_TestVersion3LoneNesting_Inner2_InnerInner) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in testpb.TestVersion3LoneNesting.Inner2.InnerInner", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_TestVersion3LoneNesting_Inner2_InnerInner) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion3LoneNesting_Inner2_InnerInner) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_TestVersion3LoneNesting_Inner2_InnerInner) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_TestVersion3LoneNesting_Inner2_InnerInner) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*TestVersion3LoneNesting_Inner2_InnerInner) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + l = len(x.Id) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.City) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*TestVersion3LoneNesting_Inner2_InnerInner) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if len(x.City) > 0 { + i -= len(x.City) + copy(dAtA[i:], x.City) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.City))) + i-- + dAtA[i] = 0x12 + } + if len(x.Id) > 0 { + i -= len(x.Id) + copy(dAtA[i:], x.Id) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Id))) + i-- + dAtA[i] = 0xa + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*TestVersion3LoneNesting_Inner2_InnerInner) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion3LoneNesting_Inner2_InnerInner: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion3LoneNesting_Inner2_InnerInner: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Id = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field City", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.City = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var _ protoreflect.List = (*_TestVersion4LoneNesting_4_list)(nil) + +type _TestVersion4LoneNesting_4_list struct { + list *[]*TestVersion3 +} + +func (x *_TestVersion4LoneNesting_4_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_TestVersion4LoneNesting_4_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_TestVersion4LoneNesting_4_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*TestVersion3) + (*x.list)[i] = concreteValue +} + +func (x *_TestVersion4LoneNesting_4_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*TestVersion3) + *x.list = append(*x.list, concreteValue) +} + +func (x *_TestVersion4LoneNesting_4_list) AppendMutable() protoreflect.Value { + v := new(TestVersion3) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_TestVersion4LoneNesting_4_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_TestVersion4LoneNesting_4_list) NewElement() protoreflect.Value { + v := new(TestVersion3) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_TestVersion4LoneNesting_4_list) IsValid() bool { + return x.list != nil +} + +var _ protoreflect.List = (*_TestVersion4LoneNesting_5_list)(nil) + +type _TestVersion4LoneNesting_5_list struct { + list *[]*TestVersion3 +} + +func (x *_TestVersion4LoneNesting_5_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_TestVersion4LoneNesting_5_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_TestVersion4LoneNesting_5_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*TestVersion3) + (*x.list)[i] = concreteValue +} + +func (x *_TestVersion4LoneNesting_5_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*TestVersion3) + *x.list = append(*x.list, concreteValue) +} + +func (x *_TestVersion4LoneNesting_5_list) AppendMutable() protoreflect.Value { + v := new(TestVersion3) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_TestVersion4LoneNesting_5_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_TestVersion4LoneNesting_5_list) NewElement() protoreflect.Value { + v := new(TestVersion3) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_TestVersion4LoneNesting_5_list) IsValid() bool { + return x.list != nil +} + +var _ protoreflect.List = (*_TestVersion4LoneNesting_9_list)(nil) + +type _TestVersion4LoneNesting_9_list struct { + list *[]*TestVersion1 +} + +func (x *_TestVersion4LoneNesting_9_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_TestVersion4LoneNesting_9_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_TestVersion4LoneNesting_9_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*TestVersion1) + (*x.list)[i] = concreteValue +} + +func (x *_TestVersion4LoneNesting_9_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*TestVersion1) + *x.list = append(*x.list, concreteValue) +} + +func (x *_TestVersion4LoneNesting_9_list) AppendMutable() protoreflect.Value { + v := new(TestVersion1) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_TestVersion4LoneNesting_9_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_TestVersion4LoneNesting_9_list) NewElement() protoreflect.Value { + v := new(TestVersion1) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_TestVersion4LoneNesting_9_list) IsValid() bool { + return x.list != nil +} + +var ( + md_TestVersion4LoneNesting protoreflect.MessageDescriptor + fd_TestVersion4LoneNesting_x protoreflect.FieldDescriptor + fd_TestVersion4LoneNesting_a protoreflect.FieldDescriptor + fd_TestVersion4LoneNesting_b protoreflect.FieldDescriptor + fd_TestVersion4LoneNesting_c protoreflect.FieldDescriptor + fd_TestVersion4LoneNesting_d protoreflect.FieldDescriptor + fd_TestVersion4LoneNesting_f protoreflect.FieldDescriptor + fd_TestVersion4LoneNesting_g protoreflect.FieldDescriptor + fd_TestVersion4LoneNesting_h protoreflect.FieldDescriptor + fd_TestVersion4LoneNesting_k protoreflect.FieldDescriptor + fd_TestVersion4LoneNesting_non_critical_field protoreflect.FieldDescriptor + fd_TestVersion4LoneNesting_inner1 protoreflect.FieldDescriptor + fd_TestVersion4LoneNesting_inner2 protoreflect.FieldDescriptor +) + +func init() { + file_unknonwnproto_proto_init() + md_TestVersion4LoneNesting = File_unknonwnproto_proto.Messages().ByName("TestVersion4LoneNesting") + fd_TestVersion4LoneNesting_x = md_TestVersion4LoneNesting.Fields().ByName("x") + fd_TestVersion4LoneNesting_a = md_TestVersion4LoneNesting.Fields().ByName("a") + fd_TestVersion4LoneNesting_b = md_TestVersion4LoneNesting.Fields().ByName("b") + fd_TestVersion4LoneNesting_c = md_TestVersion4LoneNesting.Fields().ByName("c") + fd_TestVersion4LoneNesting_d = md_TestVersion4LoneNesting.Fields().ByName("d") + fd_TestVersion4LoneNesting_f = md_TestVersion4LoneNesting.Fields().ByName("f") + fd_TestVersion4LoneNesting_g = md_TestVersion4LoneNesting.Fields().ByName("g") + fd_TestVersion4LoneNesting_h = md_TestVersion4LoneNesting.Fields().ByName("h") + fd_TestVersion4LoneNesting_k = md_TestVersion4LoneNesting.Fields().ByName("k") + fd_TestVersion4LoneNesting_non_critical_field = md_TestVersion4LoneNesting.Fields().ByName("non_critical_field") + fd_TestVersion4LoneNesting_inner1 = md_TestVersion4LoneNesting.Fields().ByName("inner1") + fd_TestVersion4LoneNesting_inner2 = md_TestVersion4LoneNesting.Fields().ByName("inner2") +} + +var _ protoreflect.Message = (*fastReflection_TestVersion4LoneNesting)(nil) + +type fastReflection_TestVersion4LoneNesting TestVersion4LoneNesting + +func (x *TestVersion4LoneNesting) ProtoReflect() protoreflect.Message { + return (*fastReflection_TestVersion4LoneNesting)(x) +} + +func (x *TestVersion4LoneNesting) slowProtoReflect() protoreflect.Message { + mi := &file_unknonwnproto_proto_msgTypes[16] + 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) +} + +var _fastReflection_TestVersion4LoneNesting_messageType fastReflection_TestVersion4LoneNesting_messageType +var _ protoreflect.MessageType = fastReflection_TestVersion4LoneNesting_messageType{} + +type fastReflection_TestVersion4LoneNesting_messageType struct{} + +func (x fastReflection_TestVersion4LoneNesting_messageType) Zero() protoreflect.Message { + return (*fastReflection_TestVersion4LoneNesting)(nil) +} +func (x fastReflection_TestVersion4LoneNesting_messageType) New() protoreflect.Message { + return new(fastReflection_TestVersion4LoneNesting) +} +func (x fastReflection_TestVersion4LoneNesting_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_TestVersion4LoneNesting +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_TestVersion4LoneNesting) Descriptor() protoreflect.MessageDescriptor { + return md_TestVersion4LoneNesting +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_TestVersion4LoneNesting) Type() protoreflect.MessageType { + return _fastReflection_TestVersion4LoneNesting_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_TestVersion4LoneNesting) New() protoreflect.Message { + return new(fastReflection_TestVersion4LoneNesting) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_TestVersion4LoneNesting) Interface() protoreflect.ProtoMessage { + return (*TestVersion4LoneNesting)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_TestVersion4LoneNesting) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.X != int64(0) { + value := protoreflect.ValueOfInt64(x.X) + if !f(fd_TestVersion4LoneNesting_x, value) { + return + } + } + if x.A != nil { + value := protoreflect.ValueOfMessage(x.A.ProtoReflect()) + if !f(fd_TestVersion4LoneNesting_a, value) { + return + } + } + if x.B != nil { + value := protoreflect.ValueOfMessage(x.B.ProtoReflect()) + if !f(fd_TestVersion4LoneNesting_b, value) { + return + } + } + if len(x.C) != 0 { + value := protoreflect.ValueOfList(&_TestVersion4LoneNesting_4_list{list: &x.C}) + if !f(fd_TestVersion4LoneNesting_c, value) { + return + } + } + if len(x.D) != 0 { + value := protoreflect.ValueOfList(&_TestVersion4LoneNesting_5_list{list: &x.D}) + if !f(fd_TestVersion4LoneNesting_d, value) { + return + } + } + if x.Sum != nil { + switch o := x.Sum.(type) { + case *TestVersion4LoneNesting_F: + v := o.F + value := protoreflect.ValueOfMessage(v.ProtoReflect()) + if !f(fd_TestVersion4LoneNesting_f, value) { + return + } + } + } + if x.G != nil { + value := protoreflect.ValueOfMessage(x.G.ProtoReflect()) + if !f(fd_TestVersion4LoneNesting_g, value) { + return + } + } + if len(x.H) != 0 { + value := protoreflect.ValueOfList(&_TestVersion4LoneNesting_9_list{list: &x.H}) + if !f(fd_TestVersion4LoneNesting_h, value) { + return + } + } + if x.K != nil { + value := protoreflect.ValueOfMessage(x.K.ProtoReflect()) + if !f(fd_TestVersion4LoneNesting_k, value) { + return + } + } + if x.NonCriticalField != "" { + value := protoreflect.ValueOfString(x.NonCriticalField) + if !f(fd_TestVersion4LoneNesting_non_critical_field, value) { + return + } + } + if x.Inner1 != nil { + value := protoreflect.ValueOfMessage(x.Inner1.ProtoReflect()) + if !f(fd_TestVersion4LoneNesting_inner1, value) { + return + } + } + if x.Inner2 != nil { + value := protoreflect.ValueOfMessage(x.Inner2.ProtoReflect()) + if !f(fd_TestVersion4LoneNesting_inner2, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_TestVersion4LoneNesting) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "testpb.TestVersion4LoneNesting.x": + return x.X != int64(0) + case "testpb.TestVersion4LoneNesting.a": + return x.A != nil + case "testpb.TestVersion4LoneNesting.b": + return x.B != nil + case "testpb.TestVersion4LoneNesting.c": + return len(x.C) != 0 + case "testpb.TestVersion4LoneNesting.d": + return len(x.D) != 0 + case "testpb.TestVersion4LoneNesting.f": + if x.Sum == nil { + return false + } else if _, ok := x.Sum.(*TestVersion4LoneNesting_F); ok { + return true + } else { + return false + } + case "testpb.TestVersion4LoneNesting.g": + return x.G != nil + case "testpb.TestVersion4LoneNesting.h": + return len(x.H) != 0 + case "testpb.TestVersion4LoneNesting.k": + return x.K != nil + case "testpb.TestVersion4LoneNesting.non_critical_field": + return x.NonCriticalField != "" + case "testpb.TestVersion4LoneNesting.inner1": + return x.Inner1 != nil + case "testpb.TestVersion4LoneNesting.inner2": + return x.Inner2 != nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting")) + } + panic(fmt.Errorf("message testpb.TestVersion4LoneNesting does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion4LoneNesting) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "testpb.TestVersion4LoneNesting.x": + x.X = int64(0) + case "testpb.TestVersion4LoneNesting.a": + x.A = nil + case "testpb.TestVersion4LoneNesting.b": + x.B = nil + case "testpb.TestVersion4LoneNesting.c": + x.C = nil + case "testpb.TestVersion4LoneNesting.d": + x.D = nil + case "testpb.TestVersion4LoneNesting.f": + x.Sum = nil + case "testpb.TestVersion4LoneNesting.g": + x.G = nil + case "testpb.TestVersion4LoneNesting.h": + x.H = nil + case "testpb.TestVersion4LoneNesting.k": + x.K = nil + case "testpb.TestVersion4LoneNesting.non_critical_field": + x.NonCriticalField = "" + case "testpb.TestVersion4LoneNesting.inner1": + x.Inner1 = nil + case "testpb.TestVersion4LoneNesting.inner2": + x.Inner2 = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting")) + } + panic(fmt.Errorf("message testpb.TestVersion4LoneNesting does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_TestVersion4LoneNesting) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "testpb.TestVersion4LoneNesting.x": + value := x.X + return protoreflect.ValueOfInt64(value) + case "testpb.TestVersion4LoneNesting.a": + value := x.A + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "testpb.TestVersion4LoneNesting.b": + value := x.B + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "testpb.TestVersion4LoneNesting.c": + if len(x.C) == 0 { + return protoreflect.ValueOfList(&_TestVersion4LoneNesting_4_list{}) + } + listValue := &_TestVersion4LoneNesting_4_list{list: &x.C} + return protoreflect.ValueOfList(listValue) + case "testpb.TestVersion4LoneNesting.d": + if len(x.D) == 0 { + return protoreflect.ValueOfList(&_TestVersion4LoneNesting_5_list{}) + } + listValue := &_TestVersion4LoneNesting_5_list{list: &x.D} + return protoreflect.ValueOfList(listValue) + case "testpb.TestVersion4LoneNesting.f": + if x.Sum == nil { + return protoreflect.ValueOfMessage((*TestVersion3LoneNesting)(nil).ProtoReflect()) + } else if v, ok := x.Sum.(*TestVersion4LoneNesting_F); ok { + return protoreflect.ValueOfMessage(v.F.ProtoReflect()) + } else { + return protoreflect.ValueOfMessage((*TestVersion3LoneNesting)(nil).ProtoReflect()) + } + case "testpb.TestVersion4LoneNesting.g": + value := x.G + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "testpb.TestVersion4LoneNesting.h": + if len(x.H) == 0 { + return protoreflect.ValueOfList(&_TestVersion4LoneNesting_9_list{}) + } + listValue := &_TestVersion4LoneNesting_9_list{list: &x.H} + return protoreflect.ValueOfList(listValue) + case "testpb.TestVersion4LoneNesting.k": + value := x.K + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "testpb.TestVersion4LoneNesting.non_critical_field": + value := x.NonCriticalField + return protoreflect.ValueOfString(value) + case "testpb.TestVersion4LoneNesting.inner1": + value := x.Inner1 + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "testpb.TestVersion4LoneNesting.inner2": + value := x.Inner2 + return protoreflect.ValueOfMessage(value.ProtoReflect()) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting")) + } + panic(fmt.Errorf("message testpb.TestVersion4LoneNesting does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion4LoneNesting) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "testpb.TestVersion4LoneNesting.x": + x.X = value.Int() + case "testpb.TestVersion4LoneNesting.a": + x.A = value.Message().Interface().(*TestVersion3) + case "testpb.TestVersion4LoneNesting.b": + x.B = value.Message().Interface().(*TestVersion3) + case "testpb.TestVersion4LoneNesting.c": + lv := value.List() + clv := lv.(*_TestVersion4LoneNesting_4_list) + x.C = *clv.list + case "testpb.TestVersion4LoneNesting.d": + lv := value.List() + clv := lv.(*_TestVersion4LoneNesting_5_list) + x.D = *clv.list + case "testpb.TestVersion4LoneNesting.f": + cv := value.Message().Interface().(*TestVersion3LoneNesting) + x.Sum = &TestVersion4LoneNesting_F{F: cv} + case "testpb.TestVersion4LoneNesting.g": + x.G = value.Message().Interface().(*anypb.Any) + case "testpb.TestVersion4LoneNesting.h": + lv := value.List() + clv := lv.(*_TestVersion4LoneNesting_9_list) + x.H = *clv.list + case "testpb.TestVersion4LoneNesting.k": + x.K = value.Message().Interface().(*Customer1) + case "testpb.TestVersion4LoneNesting.non_critical_field": + x.NonCriticalField = value.Interface().(string) + case "testpb.TestVersion4LoneNesting.inner1": + x.Inner1 = value.Message().Interface().(*TestVersion4LoneNesting_Inner1) + case "testpb.TestVersion4LoneNesting.inner2": + x.Inner2 = value.Message().Interface().(*TestVersion4LoneNesting_Inner2) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting")) + } + panic(fmt.Errorf("message testpb.TestVersion4LoneNesting does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion4LoneNesting) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.TestVersion4LoneNesting.a": + if x.A == nil { + x.A = new(TestVersion3) + } + return protoreflect.ValueOfMessage(x.A.ProtoReflect()) + case "testpb.TestVersion4LoneNesting.b": + if x.B == nil { + x.B = new(TestVersion3) + } + return protoreflect.ValueOfMessage(x.B.ProtoReflect()) + case "testpb.TestVersion4LoneNesting.c": + if x.C == nil { + x.C = []*TestVersion3{} + } + value := &_TestVersion4LoneNesting_4_list{list: &x.C} + return protoreflect.ValueOfList(value) + case "testpb.TestVersion4LoneNesting.d": + if x.D == nil { + x.D = []*TestVersion3{} + } + value := &_TestVersion4LoneNesting_5_list{list: &x.D} + return protoreflect.ValueOfList(value) + case "testpb.TestVersion4LoneNesting.f": + if x.Sum == nil { + value := &TestVersion3LoneNesting{} + oneofValue := &TestVersion4LoneNesting_F{F: value} + x.Sum = oneofValue + return protoreflect.ValueOfMessage(value.ProtoReflect()) + } + switch m := x.Sum.(type) { + case *TestVersion4LoneNesting_F: + return protoreflect.ValueOfMessage(m.F.ProtoReflect()) + default: + value := &TestVersion3LoneNesting{} + oneofValue := &TestVersion4LoneNesting_F{F: value} + x.Sum = oneofValue + return protoreflect.ValueOfMessage(value.ProtoReflect()) + } + case "testpb.TestVersion4LoneNesting.g": + if x.G == nil { + x.G = new(anypb.Any) + } + return protoreflect.ValueOfMessage(x.G.ProtoReflect()) + case "testpb.TestVersion4LoneNesting.h": + if x.H == nil { + x.H = []*TestVersion1{} + } + value := &_TestVersion4LoneNesting_9_list{list: &x.H} + return protoreflect.ValueOfList(value) + case "testpb.TestVersion4LoneNesting.k": + if x.K == nil { + x.K = new(Customer1) + } + return protoreflect.ValueOfMessage(x.K.ProtoReflect()) + case "testpb.TestVersion4LoneNesting.inner1": + if x.Inner1 == nil { + x.Inner1 = new(TestVersion4LoneNesting_Inner1) + } + return protoreflect.ValueOfMessage(x.Inner1.ProtoReflect()) + case "testpb.TestVersion4LoneNesting.inner2": + if x.Inner2 == nil { + x.Inner2 = new(TestVersion4LoneNesting_Inner2) + } + return protoreflect.ValueOfMessage(x.Inner2.ProtoReflect()) + case "testpb.TestVersion4LoneNesting.x": + panic(fmt.Errorf("field x of message testpb.TestVersion4LoneNesting is not mutable")) + case "testpb.TestVersion4LoneNesting.non_critical_field": + panic(fmt.Errorf("field non_critical_field of message testpb.TestVersion4LoneNesting is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting")) + } + panic(fmt.Errorf("message testpb.TestVersion4LoneNesting does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_TestVersion4LoneNesting) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.TestVersion4LoneNesting.x": + return protoreflect.ValueOfInt64(int64(0)) + case "testpb.TestVersion4LoneNesting.a": + m := new(TestVersion3) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "testpb.TestVersion4LoneNesting.b": + m := new(TestVersion3) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "testpb.TestVersion4LoneNesting.c": + list := []*TestVersion3{} + return protoreflect.ValueOfList(&_TestVersion4LoneNesting_4_list{list: &list}) + case "testpb.TestVersion4LoneNesting.d": + list := []*TestVersion3{} + return protoreflect.ValueOfList(&_TestVersion4LoneNesting_5_list{list: &list}) + case "testpb.TestVersion4LoneNesting.f": + value := &TestVersion3LoneNesting{} + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "testpb.TestVersion4LoneNesting.g": + m := new(anypb.Any) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "testpb.TestVersion4LoneNesting.h": + list := []*TestVersion1{} + return protoreflect.ValueOfList(&_TestVersion4LoneNesting_9_list{list: &list}) + case "testpb.TestVersion4LoneNesting.k": + m := new(Customer1) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "testpb.TestVersion4LoneNesting.non_critical_field": + return protoreflect.ValueOfString("") + case "testpb.TestVersion4LoneNesting.inner1": + m := new(TestVersion4LoneNesting_Inner1) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "testpb.TestVersion4LoneNesting.inner2": + m := new(TestVersion4LoneNesting_Inner2) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting")) + } + panic(fmt.Errorf("message testpb.TestVersion4LoneNesting does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_TestVersion4LoneNesting) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + case "testpb.TestVersion4LoneNesting.sum": + if x.Sum == nil { + return nil + } + switch x.Sum.(type) { + case *TestVersion4LoneNesting_F: + return x.Descriptor().Fields().ByName("f") + } + default: + panic(fmt.Errorf("%s is not a oneof field in testpb.TestVersion4LoneNesting", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_TestVersion4LoneNesting) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion4LoneNesting) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_TestVersion4LoneNesting) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_TestVersion4LoneNesting) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*TestVersion4LoneNesting) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + if x.X != 0 { + n += 1 + runtime.Sov(uint64(x.X)) + } + if x.A != nil { + l = options.Size(x.A) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.B != nil { + l = options.Size(x.B) + n += 1 + l + runtime.Sov(uint64(l)) + } + if len(x.C) > 0 { + for _, e := range x.C { + l = options.Size(e) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + if len(x.D) > 0 { + for _, e := range x.D { + l = options.Size(e) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + switch x := x.Sum.(type) { + case *TestVersion4LoneNesting_F: + if x == nil { + break + } + l = options.Size(x.F) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.G != nil { + l = options.Size(x.G) + n += 1 + l + runtime.Sov(uint64(l)) + } + if len(x.H) > 0 { + for _, e := range x.H { + l = options.Size(e) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + if x.K != nil { + l = options.Size(x.K) + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.NonCriticalField) + if l > 0 { + n += 2 + l + runtime.Sov(uint64(l)) + } + if x.Inner1 != nil { + l = options.Size(x.Inner1) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.Inner2 != nil { + l = options.Size(x.Inner2) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*TestVersion4LoneNesting) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + switch x := x.Sum.(type) { + case *TestVersion4LoneNesting_F: + encoded, err := options.Marshal(x.F) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x3a + } + if len(x.NonCriticalField) > 0 { + i -= len(x.NonCriticalField) + copy(dAtA[i:], x.NonCriticalField) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.NonCriticalField))) + i-- + dAtA[i] = 0x40 + i-- + dAtA[i] = 0xba + } + if x.Inner2 != nil { + encoded, err := options.Marshal(x.Inner2) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x7a + } + if x.Inner1 != nil { + encoded, err := options.Marshal(x.Inner1) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x72 + } + if x.K != nil { + encoded, err := options.Marshal(x.K) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x62 + } + if len(x.H) > 0 { + for iNdEx := len(x.H) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.H[iNdEx]) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x4a + } + } + if x.G != nil { + encoded, err := options.Marshal(x.G) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x42 + } + if len(x.D) > 0 { + for iNdEx := len(x.D) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.D[iNdEx]) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x2a + } + } + if len(x.C) > 0 { + for iNdEx := len(x.C) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.C[iNdEx]) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x22 + } + } + if x.B != nil { + encoded, err := options.Marshal(x.B) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x1a + } + if x.A != nil { + encoded, err := options.Marshal(x.A) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x12 + } + if x.X != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.X)) + i-- + dAtA[i] = 0x8 + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*TestVersion4LoneNesting) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion4LoneNesting: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion4LoneNesting: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field X", wireType) + } + x.X = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.X |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field A", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.A == nil { + x.A = &TestVersion3{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.A); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field B", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.B == nil { + x.B = &TestVersion3{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.B); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field C", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.C = append(x.C, &TestVersion3{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.C[len(x.C)-1]); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field D", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.D = append(x.D, &TestVersion3{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.D[len(x.D)-1]); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field F", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + v := &TestVersion3LoneNesting{} + if err := options.Unmarshal(dAtA[iNdEx:postIndex], v); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + x.Sum = &TestVersion4LoneNesting_F{v} + iNdEx = postIndex + case 8: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field G", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.G == nil { + x.G = &anypb.Any{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.G); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field H", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.H = append(x.H, &TestVersion1{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.H[len(x.H)-1]); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 12: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field K", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.K == nil { + x.K = &Customer1{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.K); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 1031: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field NonCriticalField", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.NonCriticalField = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 14: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Inner1", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.Inner1 == nil { + x.Inner1 = &TestVersion4LoneNesting_Inner1{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Inner1); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 15: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Inner2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.Inner2 == nil { + x.Inner2 = &TestVersion4LoneNesting_Inner2{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Inner2); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var ( + md_TestVersion4LoneNesting_Inner1 protoreflect.MessageDescriptor + fd_TestVersion4LoneNesting_Inner1_id protoreflect.FieldDescriptor + fd_TestVersion4LoneNesting_Inner1_name protoreflect.FieldDescriptor + fd_TestVersion4LoneNesting_Inner1_inner protoreflect.FieldDescriptor +) + +func init() { + file_unknonwnproto_proto_init() + md_TestVersion4LoneNesting_Inner1 = File_unknonwnproto_proto.Messages().ByName("TestVersion4LoneNesting").Messages().ByName("Inner1") + fd_TestVersion4LoneNesting_Inner1_id = md_TestVersion4LoneNesting_Inner1.Fields().ByName("id") + fd_TestVersion4LoneNesting_Inner1_name = md_TestVersion4LoneNesting_Inner1.Fields().ByName("name") + fd_TestVersion4LoneNesting_Inner1_inner = md_TestVersion4LoneNesting_Inner1.Fields().ByName("inner") +} + +var _ protoreflect.Message = (*fastReflection_TestVersion4LoneNesting_Inner1)(nil) + +type fastReflection_TestVersion4LoneNesting_Inner1 TestVersion4LoneNesting_Inner1 + +func (x *TestVersion4LoneNesting_Inner1) ProtoReflect() protoreflect.Message { + return (*fastReflection_TestVersion4LoneNesting_Inner1)(x) +} + +func (x *TestVersion4LoneNesting_Inner1) slowProtoReflect() protoreflect.Message { + mi := &file_unknonwnproto_proto_msgTypes[29] + 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) +} + +var _fastReflection_TestVersion4LoneNesting_Inner1_messageType fastReflection_TestVersion4LoneNesting_Inner1_messageType +var _ protoreflect.MessageType = fastReflection_TestVersion4LoneNesting_Inner1_messageType{} + +type fastReflection_TestVersion4LoneNesting_Inner1_messageType struct{} + +func (x fastReflection_TestVersion4LoneNesting_Inner1_messageType) Zero() protoreflect.Message { + return (*fastReflection_TestVersion4LoneNesting_Inner1)(nil) +} +func (x fastReflection_TestVersion4LoneNesting_Inner1_messageType) New() protoreflect.Message { + return new(fastReflection_TestVersion4LoneNesting_Inner1) +} +func (x fastReflection_TestVersion4LoneNesting_Inner1_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_TestVersion4LoneNesting_Inner1 +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_TestVersion4LoneNesting_Inner1) Descriptor() protoreflect.MessageDescriptor { + return md_TestVersion4LoneNesting_Inner1 +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_TestVersion4LoneNesting_Inner1) Type() protoreflect.MessageType { + return _fastReflection_TestVersion4LoneNesting_Inner1_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_TestVersion4LoneNesting_Inner1) New() protoreflect.Message { + return new(fastReflection_TestVersion4LoneNesting_Inner1) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_TestVersion4LoneNesting_Inner1) Interface() protoreflect.ProtoMessage { + return (*TestVersion4LoneNesting_Inner1)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_TestVersion4LoneNesting_Inner1) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Id != int64(0) { + value := protoreflect.ValueOfInt64(x.Id) + if !f(fd_TestVersion4LoneNesting_Inner1_id, value) { + return + } + } + if x.Name != "" { + value := protoreflect.ValueOfString(x.Name) + if !f(fd_TestVersion4LoneNesting_Inner1_name, value) { + return + } + } + if x.Inner != nil { + value := protoreflect.ValueOfMessage(x.Inner.ProtoReflect()) + if !f(fd_TestVersion4LoneNesting_Inner1_inner, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_TestVersion4LoneNesting_Inner1) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "testpb.TestVersion4LoneNesting.Inner1.id": + return x.Id != int64(0) + case "testpb.TestVersion4LoneNesting.Inner1.name": + return x.Name != "" + case "testpb.TestVersion4LoneNesting.Inner1.inner": + return x.Inner != nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting.Inner1")) + } + panic(fmt.Errorf("message testpb.TestVersion4LoneNesting.Inner1 does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion4LoneNesting_Inner1) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "testpb.TestVersion4LoneNesting.Inner1.id": + x.Id = int64(0) + case "testpb.TestVersion4LoneNesting.Inner1.name": + x.Name = "" + case "testpb.TestVersion4LoneNesting.Inner1.inner": + x.Inner = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting.Inner1")) + } + panic(fmt.Errorf("message testpb.TestVersion4LoneNesting.Inner1 does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_TestVersion4LoneNesting_Inner1) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "testpb.TestVersion4LoneNesting.Inner1.id": + value := x.Id + return protoreflect.ValueOfInt64(value) + case "testpb.TestVersion4LoneNesting.Inner1.name": + value := x.Name + return protoreflect.ValueOfString(value) + case "testpb.TestVersion4LoneNesting.Inner1.inner": + value := x.Inner + return protoreflect.ValueOfMessage(value.ProtoReflect()) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting.Inner1")) + } + panic(fmt.Errorf("message testpb.TestVersion4LoneNesting.Inner1 does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion4LoneNesting_Inner1) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "testpb.TestVersion4LoneNesting.Inner1.id": + x.Id = value.Int() + case "testpb.TestVersion4LoneNesting.Inner1.name": + x.Name = value.Interface().(string) + case "testpb.TestVersion4LoneNesting.Inner1.inner": + x.Inner = value.Message().Interface().(*TestVersion4LoneNesting_Inner1_InnerInner) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting.Inner1")) + } + panic(fmt.Errorf("message testpb.TestVersion4LoneNesting.Inner1 does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion4LoneNesting_Inner1) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.TestVersion4LoneNesting.Inner1.inner": + if x.Inner == nil { + x.Inner = new(TestVersion4LoneNesting_Inner1_InnerInner) + } + return protoreflect.ValueOfMessage(x.Inner.ProtoReflect()) + case "testpb.TestVersion4LoneNesting.Inner1.id": + panic(fmt.Errorf("field id of message testpb.TestVersion4LoneNesting.Inner1 is not mutable")) + case "testpb.TestVersion4LoneNesting.Inner1.name": + panic(fmt.Errorf("field name of message testpb.TestVersion4LoneNesting.Inner1 is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting.Inner1")) + } + panic(fmt.Errorf("message testpb.TestVersion4LoneNesting.Inner1 does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_TestVersion4LoneNesting_Inner1) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.TestVersion4LoneNesting.Inner1.id": + return protoreflect.ValueOfInt64(int64(0)) + case "testpb.TestVersion4LoneNesting.Inner1.name": + return protoreflect.ValueOfString("") + case "testpb.TestVersion4LoneNesting.Inner1.inner": + m := new(TestVersion4LoneNesting_Inner1_InnerInner) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting.Inner1")) + } + panic(fmt.Errorf("message testpb.TestVersion4LoneNesting.Inner1 does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_TestVersion4LoneNesting_Inner1) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in testpb.TestVersion4LoneNesting.Inner1", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_TestVersion4LoneNesting_Inner1) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion4LoneNesting_Inner1) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_TestVersion4LoneNesting_Inner1) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_TestVersion4LoneNesting_Inner1) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*TestVersion4LoneNesting_Inner1) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + if x.Id != 0 { + n += 1 + runtime.Sov(uint64(x.Id)) + } + l = len(x.Name) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.Inner != nil { + l = options.Size(x.Inner) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*TestVersion4LoneNesting_Inner1) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if x.Inner != nil { + encoded, err := options.Marshal(x.Inner) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x1a + } + if len(x.Name) > 0 { + i -= len(x.Name) + copy(dAtA[i:], x.Name) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Name))) + i-- + dAtA[i] = 0x12 + } + if x.Id != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.Id)) + i-- + dAtA[i] = 0x8 + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*TestVersion4LoneNesting_Inner1) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion4LoneNesting_Inner1: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion4LoneNesting_Inner1: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + x.Id = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.Id |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.Inner == nil { + x.Inner = &TestVersion4LoneNesting_Inner1_InnerInner{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Inner); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var ( + md_TestVersion4LoneNesting_Inner1_InnerInner protoreflect.MessageDescriptor + fd_TestVersion4LoneNesting_Inner1_InnerInner_id protoreflect.FieldDescriptor + fd_TestVersion4LoneNesting_Inner1_InnerInner_city protoreflect.FieldDescriptor +) + +func init() { + file_unknonwnproto_proto_init() + md_TestVersion4LoneNesting_Inner1_InnerInner = File_unknonwnproto_proto.Messages().ByName("TestVersion4LoneNesting").Messages().ByName("Inner1").Messages().ByName("InnerInner") + fd_TestVersion4LoneNesting_Inner1_InnerInner_id = md_TestVersion4LoneNesting_Inner1_InnerInner.Fields().ByName("id") + fd_TestVersion4LoneNesting_Inner1_InnerInner_city = md_TestVersion4LoneNesting_Inner1_InnerInner.Fields().ByName("city") +} + +var _ protoreflect.Message = (*fastReflection_TestVersion4LoneNesting_Inner1_InnerInner)(nil) + +type fastReflection_TestVersion4LoneNesting_Inner1_InnerInner TestVersion4LoneNesting_Inner1_InnerInner + +func (x *TestVersion4LoneNesting_Inner1_InnerInner) ProtoReflect() protoreflect.Message { + return (*fastReflection_TestVersion4LoneNesting_Inner1_InnerInner)(x) +} + +func (x *TestVersion4LoneNesting_Inner1_InnerInner) slowProtoReflect() protoreflect.Message { + mi := &file_unknonwnproto_proto_msgTypes[31] + 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) +} + +var _fastReflection_TestVersion4LoneNesting_Inner1_InnerInner_messageType fastReflection_TestVersion4LoneNesting_Inner1_InnerInner_messageType +var _ protoreflect.MessageType = fastReflection_TestVersion4LoneNesting_Inner1_InnerInner_messageType{} + +type fastReflection_TestVersion4LoneNesting_Inner1_InnerInner_messageType struct{} + +func (x fastReflection_TestVersion4LoneNesting_Inner1_InnerInner_messageType) Zero() protoreflect.Message { + return (*fastReflection_TestVersion4LoneNesting_Inner1_InnerInner)(nil) +} +func (x fastReflection_TestVersion4LoneNesting_Inner1_InnerInner_messageType) New() protoreflect.Message { + return new(fastReflection_TestVersion4LoneNesting_Inner1_InnerInner) +} +func (x fastReflection_TestVersion4LoneNesting_Inner1_InnerInner_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_TestVersion4LoneNesting_Inner1_InnerInner +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_TestVersion4LoneNesting_Inner1_InnerInner) Descriptor() protoreflect.MessageDescriptor { + return md_TestVersion4LoneNesting_Inner1_InnerInner +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_TestVersion4LoneNesting_Inner1_InnerInner) Type() protoreflect.MessageType { + return _fastReflection_TestVersion4LoneNesting_Inner1_InnerInner_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_TestVersion4LoneNesting_Inner1_InnerInner) New() protoreflect.Message { + return new(fastReflection_TestVersion4LoneNesting_Inner1_InnerInner) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_TestVersion4LoneNesting_Inner1_InnerInner) Interface() protoreflect.ProtoMessage { + return (*TestVersion4LoneNesting_Inner1_InnerInner)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_TestVersion4LoneNesting_Inner1_InnerInner) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Id != int64(0) { + value := protoreflect.ValueOfInt64(x.Id) + if !f(fd_TestVersion4LoneNesting_Inner1_InnerInner_id, value) { + return + } + } + if x.City != "" { + value := protoreflect.ValueOfString(x.City) + if !f(fd_TestVersion4LoneNesting_Inner1_InnerInner_city, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_TestVersion4LoneNesting_Inner1_InnerInner) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "testpb.TestVersion4LoneNesting.Inner1.InnerInner.id": + return x.Id != int64(0) + case "testpb.TestVersion4LoneNesting.Inner1.InnerInner.city": + return x.City != "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting.Inner1.InnerInner")) + } + panic(fmt.Errorf("message testpb.TestVersion4LoneNesting.Inner1.InnerInner does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion4LoneNesting_Inner1_InnerInner) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "testpb.TestVersion4LoneNesting.Inner1.InnerInner.id": + x.Id = int64(0) + case "testpb.TestVersion4LoneNesting.Inner1.InnerInner.city": + x.City = "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting.Inner1.InnerInner")) + } + panic(fmt.Errorf("message testpb.TestVersion4LoneNesting.Inner1.InnerInner does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_TestVersion4LoneNesting_Inner1_InnerInner) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "testpb.TestVersion4LoneNesting.Inner1.InnerInner.id": + value := x.Id + return protoreflect.ValueOfInt64(value) + case "testpb.TestVersion4LoneNesting.Inner1.InnerInner.city": + value := x.City + return protoreflect.ValueOfString(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting.Inner1.InnerInner")) + } + panic(fmt.Errorf("message testpb.TestVersion4LoneNesting.Inner1.InnerInner does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion4LoneNesting_Inner1_InnerInner) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "testpb.TestVersion4LoneNesting.Inner1.InnerInner.id": + x.Id = value.Int() + case "testpb.TestVersion4LoneNesting.Inner1.InnerInner.city": + x.City = value.Interface().(string) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting.Inner1.InnerInner")) + } + panic(fmt.Errorf("message testpb.TestVersion4LoneNesting.Inner1.InnerInner does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion4LoneNesting_Inner1_InnerInner) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.TestVersion4LoneNesting.Inner1.InnerInner.id": + panic(fmt.Errorf("field id of message testpb.TestVersion4LoneNesting.Inner1.InnerInner is not mutable")) + case "testpb.TestVersion4LoneNesting.Inner1.InnerInner.city": + panic(fmt.Errorf("field city of message testpb.TestVersion4LoneNesting.Inner1.InnerInner is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting.Inner1.InnerInner")) + } + panic(fmt.Errorf("message testpb.TestVersion4LoneNesting.Inner1.InnerInner does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_TestVersion4LoneNesting_Inner1_InnerInner) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.TestVersion4LoneNesting.Inner1.InnerInner.id": + return protoreflect.ValueOfInt64(int64(0)) + case "testpb.TestVersion4LoneNesting.Inner1.InnerInner.city": + return protoreflect.ValueOfString("") + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting.Inner1.InnerInner")) + } + panic(fmt.Errorf("message testpb.TestVersion4LoneNesting.Inner1.InnerInner does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_TestVersion4LoneNesting_Inner1_InnerInner) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in testpb.TestVersion4LoneNesting.Inner1.InnerInner", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_TestVersion4LoneNesting_Inner1_InnerInner) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion4LoneNesting_Inner1_InnerInner) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_TestVersion4LoneNesting_Inner1_InnerInner) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_TestVersion4LoneNesting_Inner1_InnerInner) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*TestVersion4LoneNesting_Inner1_InnerInner) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + if x.Id != 0 { + n += 1 + runtime.Sov(uint64(x.Id)) + } + l = len(x.City) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*TestVersion4LoneNesting_Inner1_InnerInner) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if len(x.City) > 0 { + i -= len(x.City) + copy(dAtA[i:], x.City) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.City))) + i-- + dAtA[i] = 0x12 + } + if x.Id != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.Id)) + i-- + dAtA[i] = 0x8 + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*TestVersion4LoneNesting_Inner1_InnerInner) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion4LoneNesting_Inner1_InnerInner: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion4LoneNesting_Inner1_InnerInner: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + x.Id = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.Id |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field City", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.City = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var ( + md_TestVersion4LoneNesting_Inner2 protoreflect.MessageDescriptor + fd_TestVersion4LoneNesting_Inner2_id protoreflect.FieldDescriptor + fd_TestVersion4LoneNesting_Inner2_country protoreflect.FieldDescriptor + fd_TestVersion4LoneNesting_Inner2_inner protoreflect.FieldDescriptor +) + +func init() { + file_unknonwnproto_proto_init() + md_TestVersion4LoneNesting_Inner2 = File_unknonwnproto_proto.Messages().ByName("TestVersion4LoneNesting").Messages().ByName("Inner2") + fd_TestVersion4LoneNesting_Inner2_id = md_TestVersion4LoneNesting_Inner2.Fields().ByName("id") + fd_TestVersion4LoneNesting_Inner2_country = md_TestVersion4LoneNesting_Inner2.Fields().ByName("country") + fd_TestVersion4LoneNesting_Inner2_inner = md_TestVersion4LoneNesting_Inner2.Fields().ByName("inner") +} + +var _ protoreflect.Message = (*fastReflection_TestVersion4LoneNesting_Inner2)(nil) + +type fastReflection_TestVersion4LoneNesting_Inner2 TestVersion4LoneNesting_Inner2 + +func (x *TestVersion4LoneNesting_Inner2) ProtoReflect() protoreflect.Message { + return (*fastReflection_TestVersion4LoneNesting_Inner2)(x) +} + +func (x *TestVersion4LoneNesting_Inner2) slowProtoReflect() protoreflect.Message { + mi := &file_unknonwnproto_proto_msgTypes[30] + 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) +} + +var _fastReflection_TestVersion4LoneNesting_Inner2_messageType fastReflection_TestVersion4LoneNesting_Inner2_messageType +var _ protoreflect.MessageType = fastReflection_TestVersion4LoneNesting_Inner2_messageType{} + +type fastReflection_TestVersion4LoneNesting_Inner2_messageType struct{} + +func (x fastReflection_TestVersion4LoneNesting_Inner2_messageType) Zero() protoreflect.Message { + return (*fastReflection_TestVersion4LoneNesting_Inner2)(nil) +} +func (x fastReflection_TestVersion4LoneNesting_Inner2_messageType) New() protoreflect.Message { + return new(fastReflection_TestVersion4LoneNesting_Inner2) +} +func (x fastReflection_TestVersion4LoneNesting_Inner2_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_TestVersion4LoneNesting_Inner2 +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_TestVersion4LoneNesting_Inner2) Descriptor() protoreflect.MessageDescriptor { + return md_TestVersion4LoneNesting_Inner2 +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_TestVersion4LoneNesting_Inner2) Type() protoreflect.MessageType { + return _fastReflection_TestVersion4LoneNesting_Inner2_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_TestVersion4LoneNesting_Inner2) New() protoreflect.Message { + return new(fastReflection_TestVersion4LoneNesting_Inner2) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_TestVersion4LoneNesting_Inner2) Interface() protoreflect.ProtoMessage { + return (*TestVersion4LoneNesting_Inner2)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_TestVersion4LoneNesting_Inner2) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Id != "" { + value := protoreflect.ValueOfString(x.Id) + if !f(fd_TestVersion4LoneNesting_Inner2_id, value) { + return + } + } + if x.Country != "" { + value := protoreflect.ValueOfString(x.Country) + if !f(fd_TestVersion4LoneNesting_Inner2_country, value) { + return + } + } + if x.Inner != nil { + value := protoreflect.ValueOfMessage(x.Inner.ProtoReflect()) + if !f(fd_TestVersion4LoneNesting_Inner2_inner, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_TestVersion4LoneNesting_Inner2) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "testpb.TestVersion4LoneNesting.Inner2.id": + return x.Id != "" + case "testpb.TestVersion4LoneNesting.Inner2.country": + return x.Country != "" + case "testpb.TestVersion4LoneNesting.Inner2.inner": + return x.Inner != nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting.Inner2")) + } + panic(fmt.Errorf("message testpb.TestVersion4LoneNesting.Inner2 does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion4LoneNesting_Inner2) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "testpb.TestVersion4LoneNesting.Inner2.id": + x.Id = "" + case "testpb.TestVersion4LoneNesting.Inner2.country": + x.Country = "" + case "testpb.TestVersion4LoneNesting.Inner2.inner": + x.Inner = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting.Inner2")) + } + panic(fmt.Errorf("message testpb.TestVersion4LoneNesting.Inner2 does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_TestVersion4LoneNesting_Inner2) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "testpb.TestVersion4LoneNesting.Inner2.id": + value := x.Id + return protoreflect.ValueOfString(value) + case "testpb.TestVersion4LoneNesting.Inner2.country": + value := x.Country + return protoreflect.ValueOfString(value) + case "testpb.TestVersion4LoneNesting.Inner2.inner": + value := x.Inner + return protoreflect.ValueOfMessage(value.ProtoReflect()) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting.Inner2")) + } + panic(fmt.Errorf("message testpb.TestVersion4LoneNesting.Inner2 does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion4LoneNesting_Inner2) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "testpb.TestVersion4LoneNesting.Inner2.id": + x.Id = value.Interface().(string) + case "testpb.TestVersion4LoneNesting.Inner2.country": + x.Country = value.Interface().(string) + case "testpb.TestVersion4LoneNesting.Inner2.inner": + x.Inner = value.Message().Interface().(*TestVersion4LoneNesting_Inner2_InnerInner) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting.Inner2")) + } + panic(fmt.Errorf("message testpb.TestVersion4LoneNesting.Inner2 does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion4LoneNesting_Inner2) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.TestVersion4LoneNesting.Inner2.inner": + if x.Inner == nil { + x.Inner = new(TestVersion4LoneNesting_Inner2_InnerInner) + } + return protoreflect.ValueOfMessage(x.Inner.ProtoReflect()) + case "testpb.TestVersion4LoneNesting.Inner2.id": + panic(fmt.Errorf("field id of message testpb.TestVersion4LoneNesting.Inner2 is not mutable")) + case "testpb.TestVersion4LoneNesting.Inner2.country": + panic(fmt.Errorf("field country of message testpb.TestVersion4LoneNesting.Inner2 is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting.Inner2")) + } + panic(fmt.Errorf("message testpb.TestVersion4LoneNesting.Inner2 does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_TestVersion4LoneNesting_Inner2) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.TestVersion4LoneNesting.Inner2.id": + return protoreflect.ValueOfString("") + case "testpb.TestVersion4LoneNesting.Inner2.country": + return protoreflect.ValueOfString("") + case "testpb.TestVersion4LoneNesting.Inner2.inner": + m := new(TestVersion4LoneNesting_Inner2_InnerInner) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting.Inner2")) + } + panic(fmt.Errorf("message testpb.TestVersion4LoneNesting.Inner2 does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_TestVersion4LoneNesting_Inner2) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in testpb.TestVersion4LoneNesting.Inner2", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_TestVersion4LoneNesting_Inner2) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion4LoneNesting_Inner2) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_TestVersion4LoneNesting_Inner2) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_TestVersion4LoneNesting_Inner2) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*TestVersion4LoneNesting_Inner2) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + l = len(x.Id) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Country) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.Inner != nil { + l = options.Size(x.Inner) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*TestVersion4LoneNesting_Inner2) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if x.Inner != nil { + encoded, err := options.Marshal(x.Inner) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x1a + } + if len(x.Country) > 0 { + i -= len(x.Country) + copy(dAtA[i:], x.Country) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Country))) + i-- + dAtA[i] = 0x12 + } + if len(x.Id) > 0 { + i -= len(x.Id) + copy(dAtA[i:], x.Id) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Id))) + i-- + dAtA[i] = 0xa + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*TestVersion4LoneNesting_Inner2) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion4LoneNesting_Inner2: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion4LoneNesting_Inner2: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Id = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Country", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Country = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.Inner == nil { + x.Inner = &TestVersion4LoneNesting_Inner2_InnerInner{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Inner); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var ( + md_TestVersion4LoneNesting_Inner2_InnerInner protoreflect.MessageDescriptor + fd_TestVersion4LoneNesting_Inner2_InnerInner_id protoreflect.FieldDescriptor + fd_TestVersion4LoneNesting_Inner2_InnerInner_value protoreflect.FieldDescriptor +) + +func init() { + file_unknonwnproto_proto_init() + md_TestVersion4LoneNesting_Inner2_InnerInner = File_unknonwnproto_proto.Messages().ByName("TestVersion4LoneNesting").Messages().ByName("Inner2").Messages().ByName("InnerInner") + fd_TestVersion4LoneNesting_Inner2_InnerInner_id = md_TestVersion4LoneNesting_Inner2_InnerInner.Fields().ByName("id") + fd_TestVersion4LoneNesting_Inner2_InnerInner_value = md_TestVersion4LoneNesting_Inner2_InnerInner.Fields().ByName("value") +} + +var _ protoreflect.Message = (*fastReflection_TestVersion4LoneNesting_Inner2_InnerInner)(nil) + +type fastReflection_TestVersion4LoneNesting_Inner2_InnerInner TestVersion4LoneNesting_Inner2_InnerInner + +func (x *TestVersion4LoneNesting_Inner2_InnerInner) ProtoReflect() protoreflect.Message { + return (*fastReflection_TestVersion4LoneNesting_Inner2_InnerInner)(x) +} + +func (x *TestVersion4LoneNesting_Inner2_InnerInner) slowProtoReflect() protoreflect.Message { + mi := &file_unknonwnproto_proto_msgTypes[32] + 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) +} + +var _fastReflection_TestVersion4LoneNesting_Inner2_InnerInner_messageType fastReflection_TestVersion4LoneNesting_Inner2_InnerInner_messageType +var _ protoreflect.MessageType = fastReflection_TestVersion4LoneNesting_Inner2_InnerInner_messageType{} + +type fastReflection_TestVersion4LoneNesting_Inner2_InnerInner_messageType struct{} + +func (x fastReflection_TestVersion4LoneNesting_Inner2_InnerInner_messageType) Zero() protoreflect.Message { + return (*fastReflection_TestVersion4LoneNesting_Inner2_InnerInner)(nil) +} +func (x fastReflection_TestVersion4LoneNesting_Inner2_InnerInner_messageType) New() protoreflect.Message { + return new(fastReflection_TestVersion4LoneNesting_Inner2_InnerInner) +} +func (x fastReflection_TestVersion4LoneNesting_Inner2_InnerInner_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_TestVersion4LoneNesting_Inner2_InnerInner +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_TestVersion4LoneNesting_Inner2_InnerInner) Descriptor() protoreflect.MessageDescriptor { + return md_TestVersion4LoneNesting_Inner2_InnerInner +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_TestVersion4LoneNesting_Inner2_InnerInner) Type() protoreflect.MessageType { + return _fastReflection_TestVersion4LoneNesting_Inner2_InnerInner_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_TestVersion4LoneNesting_Inner2_InnerInner) New() protoreflect.Message { + return new(fastReflection_TestVersion4LoneNesting_Inner2_InnerInner) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_TestVersion4LoneNesting_Inner2_InnerInner) Interface() protoreflect.ProtoMessage { + return (*TestVersion4LoneNesting_Inner2_InnerInner)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_TestVersion4LoneNesting_Inner2_InnerInner) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Id != "" { + value := protoreflect.ValueOfString(x.Id) + if !f(fd_TestVersion4LoneNesting_Inner2_InnerInner_id, value) { + return + } + } + if x.Value != int64(0) { + value := protoreflect.ValueOfInt64(x.Value) + if !f(fd_TestVersion4LoneNesting_Inner2_InnerInner_value, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_TestVersion4LoneNesting_Inner2_InnerInner) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "testpb.TestVersion4LoneNesting.Inner2.InnerInner.id": + return x.Id != "" + case "testpb.TestVersion4LoneNesting.Inner2.InnerInner.value": + return x.Value != int64(0) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting.Inner2.InnerInner")) + } + panic(fmt.Errorf("message testpb.TestVersion4LoneNesting.Inner2.InnerInner does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion4LoneNesting_Inner2_InnerInner) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "testpb.TestVersion4LoneNesting.Inner2.InnerInner.id": + x.Id = "" + case "testpb.TestVersion4LoneNesting.Inner2.InnerInner.value": + x.Value = int64(0) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting.Inner2.InnerInner")) + } + panic(fmt.Errorf("message testpb.TestVersion4LoneNesting.Inner2.InnerInner does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_TestVersion4LoneNesting_Inner2_InnerInner) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "testpb.TestVersion4LoneNesting.Inner2.InnerInner.id": + value := x.Id + return protoreflect.ValueOfString(value) + case "testpb.TestVersion4LoneNesting.Inner2.InnerInner.value": + value := x.Value + return protoreflect.ValueOfInt64(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting.Inner2.InnerInner")) + } + panic(fmt.Errorf("message testpb.TestVersion4LoneNesting.Inner2.InnerInner does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion4LoneNesting_Inner2_InnerInner) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "testpb.TestVersion4LoneNesting.Inner2.InnerInner.id": + x.Id = value.Interface().(string) + case "testpb.TestVersion4LoneNesting.Inner2.InnerInner.value": + x.Value = value.Int() + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting.Inner2.InnerInner")) + } + panic(fmt.Errorf("message testpb.TestVersion4LoneNesting.Inner2.InnerInner does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion4LoneNesting_Inner2_InnerInner) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.TestVersion4LoneNesting.Inner2.InnerInner.id": + panic(fmt.Errorf("field id of message testpb.TestVersion4LoneNesting.Inner2.InnerInner is not mutable")) + case "testpb.TestVersion4LoneNesting.Inner2.InnerInner.value": + panic(fmt.Errorf("field value of message testpb.TestVersion4LoneNesting.Inner2.InnerInner is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting.Inner2.InnerInner")) + } + panic(fmt.Errorf("message testpb.TestVersion4LoneNesting.Inner2.InnerInner does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_TestVersion4LoneNesting_Inner2_InnerInner) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.TestVersion4LoneNesting.Inner2.InnerInner.id": + return protoreflect.ValueOfString("") + case "testpb.TestVersion4LoneNesting.Inner2.InnerInner.value": + return protoreflect.ValueOfInt64(int64(0)) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting.Inner2.InnerInner")) + } + panic(fmt.Errorf("message testpb.TestVersion4LoneNesting.Inner2.InnerInner does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_TestVersion4LoneNesting_Inner2_InnerInner) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in testpb.TestVersion4LoneNesting.Inner2.InnerInner", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_TestVersion4LoneNesting_Inner2_InnerInner) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersion4LoneNesting_Inner2_InnerInner) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_TestVersion4LoneNesting_Inner2_InnerInner) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_TestVersion4LoneNesting_Inner2_InnerInner) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*TestVersion4LoneNesting_Inner2_InnerInner) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + l = len(x.Id) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.Value != 0 { + n += 1 + runtime.Sov(uint64(x.Value)) + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*TestVersion4LoneNesting_Inner2_InnerInner) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if x.Value != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.Value)) + i-- + dAtA[i] = 0x10 + } + if len(x.Id) > 0 { + i -= len(x.Id) + copy(dAtA[i:], x.Id) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Id))) + i-- + dAtA[i] = 0xa + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*TestVersion4LoneNesting_Inner2_InnerInner) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion4LoneNesting_Inner2_InnerInner: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion4LoneNesting_Inner2_InnerInner: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Id = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + x.Value = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.Value |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var _ protoreflect.List = (*_TestVersionFD1_9_list)(nil) + +type _TestVersionFD1_9_list struct { + list *[]*TestVersion1 +} + +func (x *_TestVersionFD1_9_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_TestVersionFD1_9_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_TestVersionFD1_9_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*TestVersion1) + (*x.list)[i] = concreteValue +} + +func (x *_TestVersionFD1_9_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*TestVersion1) + *x.list = append(*x.list, concreteValue) +} + +func (x *_TestVersionFD1_9_list) AppendMutable() protoreflect.Value { + v := new(TestVersion1) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_TestVersionFD1_9_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_TestVersionFD1_9_list) NewElement() protoreflect.Value { + v := new(TestVersion1) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_TestVersionFD1_9_list) IsValid() bool { + return x.list != nil +} + +var ( + md_TestVersionFD1 protoreflect.MessageDescriptor + fd_TestVersionFD1_x protoreflect.FieldDescriptor + fd_TestVersionFD1_a protoreflect.FieldDescriptor + fd_TestVersionFD1_e protoreflect.FieldDescriptor + fd_TestVersionFD1_f protoreflect.FieldDescriptor + fd_TestVersionFD1_g protoreflect.FieldDescriptor + fd_TestVersionFD1_h protoreflect.FieldDescriptor +) + +func init() { + file_unknonwnproto_proto_init() + md_TestVersionFD1 = File_unknonwnproto_proto.Messages().ByName("TestVersionFD1") + fd_TestVersionFD1_x = md_TestVersionFD1.Fields().ByName("x") + fd_TestVersionFD1_a = md_TestVersionFD1.Fields().ByName("a") + fd_TestVersionFD1_e = md_TestVersionFD1.Fields().ByName("e") + fd_TestVersionFD1_f = md_TestVersionFD1.Fields().ByName("f") + fd_TestVersionFD1_g = md_TestVersionFD1.Fields().ByName("g") + fd_TestVersionFD1_h = md_TestVersionFD1.Fields().ByName("h") +} + +var _ protoreflect.Message = (*fastReflection_TestVersionFD1)(nil) + +type fastReflection_TestVersionFD1 TestVersionFD1 + +func (x *TestVersionFD1) ProtoReflect() protoreflect.Message { + return (*fastReflection_TestVersionFD1)(x) +} + +func (x *TestVersionFD1) slowProtoReflect() protoreflect.Message { + mi := &file_unknonwnproto_proto_msgTypes[17] + 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) +} + +var _fastReflection_TestVersionFD1_messageType fastReflection_TestVersionFD1_messageType +var _ protoreflect.MessageType = fastReflection_TestVersionFD1_messageType{} + +type fastReflection_TestVersionFD1_messageType struct{} + +func (x fastReflection_TestVersionFD1_messageType) Zero() protoreflect.Message { + return (*fastReflection_TestVersionFD1)(nil) +} +func (x fastReflection_TestVersionFD1_messageType) New() protoreflect.Message { + return new(fastReflection_TestVersionFD1) +} +func (x fastReflection_TestVersionFD1_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_TestVersionFD1 +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_TestVersionFD1) Descriptor() protoreflect.MessageDescriptor { + return md_TestVersionFD1 +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_TestVersionFD1) Type() protoreflect.MessageType { + return _fastReflection_TestVersionFD1_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_TestVersionFD1) New() protoreflect.Message { + return new(fastReflection_TestVersionFD1) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_TestVersionFD1) Interface() protoreflect.ProtoMessage { + return (*TestVersionFD1)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_TestVersionFD1) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.X != int64(0) { + value := protoreflect.ValueOfInt64(x.X) + if !f(fd_TestVersionFD1_x, value) { + return + } + } + if x.A != nil { + value := protoreflect.ValueOfMessage(x.A.ProtoReflect()) + if !f(fd_TestVersionFD1_a, value) { + return + } + } + if x.Sum != nil { + switch o := x.Sum.(type) { + case *TestVersionFD1_E: + v := o.E + value := protoreflect.ValueOfInt32(v) + if !f(fd_TestVersionFD1_e, value) { + return + } + case *TestVersionFD1_F: + v := o.F + value := protoreflect.ValueOfMessage(v.ProtoReflect()) + if !f(fd_TestVersionFD1_f, value) { + return + } + } + } + if x.G != nil { + value := protoreflect.ValueOfMessage(x.G.ProtoReflect()) + if !f(fd_TestVersionFD1_g, value) { + return + } + } + if len(x.H) != 0 { + value := protoreflect.ValueOfList(&_TestVersionFD1_9_list{list: &x.H}) + if !f(fd_TestVersionFD1_h, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_TestVersionFD1) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "testpb.TestVersionFD1.x": + return x.X != int64(0) + case "testpb.TestVersionFD1.a": + return x.A != nil + case "testpb.TestVersionFD1.e": + if x.Sum == nil { + return false + } else if _, ok := x.Sum.(*TestVersionFD1_E); ok { + return true + } else { + return false + } + case "testpb.TestVersionFD1.f": + if x.Sum == nil { + return false + } else if _, ok := x.Sum.(*TestVersionFD1_F); ok { + return true + } else { + return false + } + case "testpb.TestVersionFD1.g": + return x.G != nil + case "testpb.TestVersionFD1.h": + return len(x.H) != 0 + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersionFD1")) + } + panic(fmt.Errorf("message testpb.TestVersionFD1 does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersionFD1) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "testpb.TestVersionFD1.x": + x.X = int64(0) + case "testpb.TestVersionFD1.a": + x.A = nil + case "testpb.TestVersionFD1.e": + x.Sum = nil + case "testpb.TestVersionFD1.f": + x.Sum = nil + case "testpb.TestVersionFD1.g": + x.G = nil + case "testpb.TestVersionFD1.h": + x.H = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersionFD1")) + } + panic(fmt.Errorf("message testpb.TestVersionFD1 does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_TestVersionFD1) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "testpb.TestVersionFD1.x": + value := x.X + return protoreflect.ValueOfInt64(value) + case "testpb.TestVersionFD1.a": + value := x.A + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "testpb.TestVersionFD1.e": + if x.Sum == nil { + return protoreflect.ValueOfInt32(int32(0)) + } else if v, ok := x.Sum.(*TestVersionFD1_E); ok { + return protoreflect.ValueOfInt32(v.E) + } else { + return protoreflect.ValueOfInt32(int32(0)) + } + case "testpb.TestVersionFD1.f": + if x.Sum == nil { + return protoreflect.ValueOfMessage((*TestVersion1)(nil).ProtoReflect()) + } else if v, ok := x.Sum.(*TestVersionFD1_F); ok { + return protoreflect.ValueOfMessage(v.F.ProtoReflect()) + } else { + return protoreflect.ValueOfMessage((*TestVersion1)(nil).ProtoReflect()) + } + case "testpb.TestVersionFD1.g": + value := x.G + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "testpb.TestVersionFD1.h": + if len(x.H) == 0 { + return protoreflect.ValueOfList(&_TestVersionFD1_9_list{}) + } + listValue := &_TestVersionFD1_9_list{list: &x.H} + return protoreflect.ValueOfList(listValue) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersionFD1")) + } + panic(fmt.Errorf("message testpb.TestVersionFD1 does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersionFD1) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "testpb.TestVersionFD1.x": + x.X = value.Int() + case "testpb.TestVersionFD1.a": + x.A = value.Message().Interface().(*TestVersion1) + case "testpb.TestVersionFD1.e": + cv := int32(value.Int()) + x.Sum = &TestVersionFD1_E{E: cv} + case "testpb.TestVersionFD1.f": + cv := value.Message().Interface().(*TestVersion1) + x.Sum = &TestVersionFD1_F{F: cv} + case "testpb.TestVersionFD1.g": + x.G = value.Message().Interface().(*anypb.Any) + case "testpb.TestVersionFD1.h": + lv := value.List() + clv := lv.(*_TestVersionFD1_9_list) + x.H = *clv.list + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersionFD1")) + } + panic(fmt.Errorf("message testpb.TestVersionFD1 does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersionFD1) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.TestVersionFD1.a": + if x.A == nil { + x.A = new(TestVersion1) + } + return protoreflect.ValueOfMessage(x.A.ProtoReflect()) + case "testpb.TestVersionFD1.f": + if x.Sum == nil { + value := &TestVersion1{} + oneofValue := &TestVersionFD1_F{F: value} + x.Sum = oneofValue + return protoreflect.ValueOfMessage(value.ProtoReflect()) + } + switch m := x.Sum.(type) { + case *TestVersionFD1_F: + return protoreflect.ValueOfMessage(m.F.ProtoReflect()) + default: + value := &TestVersion1{} + oneofValue := &TestVersionFD1_F{F: value} + x.Sum = oneofValue + return protoreflect.ValueOfMessage(value.ProtoReflect()) + } + case "testpb.TestVersionFD1.g": + if x.G == nil { + x.G = new(anypb.Any) + } + return protoreflect.ValueOfMessage(x.G.ProtoReflect()) + case "testpb.TestVersionFD1.h": + if x.H == nil { + x.H = []*TestVersion1{} + } + value := &_TestVersionFD1_9_list{list: &x.H} + return protoreflect.ValueOfList(value) + case "testpb.TestVersionFD1.x": + panic(fmt.Errorf("field x of message testpb.TestVersionFD1 is not mutable")) + case "testpb.TestVersionFD1.e": + panic(fmt.Errorf("field e of message testpb.TestVersionFD1 is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersionFD1")) + } + panic(fmt.Errorf("message testpb.TestVersionFD1 does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_TestVersionFD1) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.TestVersionFD1.x": + return protoreflect.ValueOfInt64(int64(0)) + case "testpb.TestVersionFD1.a": + m := new(TestVersion1) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "testpb.TestVersionFD1.e": + return protoreflect.ValueOfInt32(int32(0)) + case "testpb.TestVersionFD1.f": + value := &TestVersion1{} + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "testpb.TestVersionFD1.g": + m := new(anypb.Any) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "testpb.TestVersionFD1.h": + list := []*TestVersion1{} + return protoreflect.ValueOfList(&_TestVersionFD1_9_list{list: &list}) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersionFD1")) + } + panic(fmt.Errorf("message testpb.TestVersionFD1 does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_TestVersionFD1) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + case "testpb.TestVersionFD1.sum": + if x.Sum == nil { + return nil + } + switch x.Sum.(type) { + case *TestVersionFD1_E: + return x.Descriptor().Fields().ByName("e") + case *TestVersionFD1_F: + return x.Descriptor().Fields().ByName("f") + } + default: + panic(fmt.Errorf("%s is not a oneof field in testpb.TestVersionFD1", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_TestVersionFD1) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersionFD1) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_TestVersionFD1) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_TestVersionFD1) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*TestVersionFD1) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + if x.X != 0 { + n += 1 + runtime.Sov(uint64(x.X)) + } + if x.A != nil { + l = options.Size(x.A) + n += 1 + l + runtime.Sov(uint64(l)) + } + switch x := x.Sum.(type) { + case *TestVersionFD1_E: + if x == nil { + break + } + n += 1 + runtime.Sov(uint64(x.E)) + case *TestVersionFD1_F: + if x == nil { + break + } + l = options.Size(x.F) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.G != nil { + l = options.Size(x.G) + n += 1 + l + runtime.Sov(uint64(l)) + } + if len(x.H) > 0 { + for _, e := range x.H { + l = options.Size(e) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*TestVersionFD1) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + switch x := x.Sum.(type) { + case *TestVersionFD1_E: + i = runtime.EncodeVarint(dAtA, i, uint64(x.E)) + i-- + dAtA[i] = 0x30 + case *TestVersionFD1_F: + encoded, err := options.Marshal(x.F) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x3a + } + if len(x.H) > 0 { + for iNdEx := len(x.H) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.H[iNdEx]) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x4a + } + } + if x.G != nil { + encoded, err := options.Marshal(x.G) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x42 + } + if x.A != nil { + encoded, err := options.Marshal(x.A) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x12 + } + if x.X != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.X)) + i-- + dAtA[i] = 0x8 + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*TestVersionFD1) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersionFD1: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersionFD1: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field X", wireType) + } + x.X = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.X |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field A", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.A == nil { + x.A = &TestVersion1{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.A); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 6: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field E", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + x.Sum = &TestVersionFD1_E{v} + case 7: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field F", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + v := &TestVersion1{} + if err := options.Unmarshal(dAtA[iNdEx:postIndex], v); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + x.Sum = &TestVersionFD1_F{v} + iNdEx = postIndex + case 8: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field G", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.G == nil { + x.G = &anypb.Any{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.G); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field H", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.H = append(x.H, &TestVersion1{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.H[len(x.H)-1]); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var _ protoreflect.List = (*_TestVersionFD1WithExtraAny_9_list)(nil) + +type _TestVersionFD1WithExtraAny_9_list struct { + list *[]*TestVersion1 +} + +func (x *_TestVersionFD1WithExtraAny_9_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_TestVersionFD1WithExtraAny_9_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_TestVersionFD1WithExtraAny_9_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*TestVersion1) + (*x.list)[i] = concreteValue +} + +func (x *_TestVersionFD1WithExtraAny_9_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*TestVersion1) + *x.list = append(*x.list, concreteValue) +} + +func (x *_TestVersionFD1WithExtraAny_9_list) AppendMutable() protoreflect.Value { + v := new(TestVersion1) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_TestVersionFD1WithExtraAny_9_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_TestVersionFD1WithExtraAny_9_list) NewElement() protoreflect.Value { + v := new(TestVersion1) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_TestVersionFD1WithExtraAny_9_list) IsValid() bool { + return x.list != nil +} + +var ( + md_TestVersionFD1WithExtraAny protoreflect.MessageDescriptor + fd_TestVersionFD1WithExtraAny_x protoreflect.FieldDescriptor + fd_TestVersionFD1WithExtraAny_a protoreflect.FieldDescriptor + fd_TestVersionFD1WithExtraAny_e protoreflect.FieldDescriptor + fd_TestVersionFD1WithExtraAny_f protoreflect.FieldDescriptor + fd_TestVersionFD1WithExtraAny_g protoreflect.FieldDescriptor + fd_TestVersionFD1WithExtraAny_h protoreflect.FieldDescriptor +) + +func init() { + file_unknonwnproto_proto_init() + md_TestVersionFD1WithExtraAny = File_unknonwnproto_proto.Messages().ByName("TestVersionFD1WithExtraAny") + fd_TestVersionFD1WithExtraAny_x = md_TestVersionFD1WithExtraAny.Fields().ByName("x") + fd_TestVersionFD1WithExtraAny_a = md_TestVersionFD1WithExtraAny.Fields().ByName("a") + fd_TestVersionFD1WithExtraAny_e = md_TestVersionFD1WithExtraAny.Fields().ByName("e") + fd_TestVersionFD1WithExtraAny_f = md_TestVersionFD1WithExtraAny.Fields().ByName("f") + fd_TestVersionFD1WithExtraAny_g = md_TestVersionFD1WithExtraAny.Fields().ByName("g") + fd_TestVersionFD1WithExtraAny_h = md_TestVersionFD1WithExtraAny.Fields().ByName("h") +} + +var _ protoreflect.Message = (*fastReflection_TestVersionFD1WithExtraAny)(nil) + +type fastReflection_TestVersionFD1WithExtraAny TestVersionFD1WithExtraAny + +func (x *TestVersionFD1WithExtraAny) ProtoReflect() protoreflect.Message { + return (*fastReflection_TestVersionFD1WithExtraAny)(x) +} + +func (x *TestVersionFD1WithExtraAny) slowProtoReflect() protoreflect.Message { + mi := &file_unknonwnproto_proto_msgTypes[18] + 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) +} + +var _fastReflection_TestVersionFD1WithExtraAny_messageType fastReflection_TestVersionFD1WithExtraAny_messageType +var _ protoreflect.MessageType = fastReflection_TestVersionFD1WithExtraAny_messageType{} + +type fastReflection_TestVersionFD1WithExtraAny_messageType struct{} + +func (x fastReflection_TestVersionFD1WithExtraAny_messageType) Zero() protoreflect.Message { + return (*fastReflection_TestVersionFD1WithExtraAny)(nil) +} +func (x fastReflection_TestVersionFD1WithExtraAny_messageType) New() protoreflect.Message { + return new(fastReflection_TestVersionFD1WithExtraAny) +} +func (x fastReflection_TestVersionFD1WithExtraAny_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_TestVersionFD1WithExtraAny +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_TestVersionFD1WithExtraAny) Descriptor() protoreflect.MessageDescriptor { + return md_TestVersionFD1WithExtraAny +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_TestVersionFD1WithExtraAny) Type() protoreflect.MessageType { + return _fastReflection_TestVersionFD1WithExtraAny_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_TestVersionFD1WithExtraAny) New() protoreflect.Message { + return new(fastReflection_TestVersionFD1WithExtraAny) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_TestVersionFD1WithExtraAny) Interface() protoreflect.ProtoMessage { + return (*TestVersionFD1WithExtraAny)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_TestVersionFD1WithExtraAny) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.X != int64(0) { + value := protoreflect.ValueOfInt64(x.X) + if !f(fd_TestVersionFD1WithExtraAny_x, value) { + return + } + } + if x.A != nil { + value := protoreflect.ValueOfMessage(x.A.ProtoReflect()) + if !f(fd_TestVersionFD1WithExtraAny_a, value) { + return + } + } + if x.Sum != nil { + switch o := x.Sum.(type) { + case *TestVersionFD1WithExtraAny_E: + v := o.E + value := protoreflect.ValueOfInt32(v) + if !f(fd_TestVersionFD1WithExtraAny_e, value) { + return + } + case *TestVersionFD1WithExtraAny_F: + v := o.F + value := protoreflect.ValueOfMessage(v.ProtoReflect()) + if !f(fd_TestVersionFD1WithExtraAny_f, value) { + return + } + } + } + if x.G != nil { + value := protoreflect.ValueOfMessage(x.G.ProtoReflect()) + if !f(fd_TestVersionFD1WithExtraAny_g, value) { + return + } + } + if len(x.H) != 0 { + value := protoreflect.ValueOfList(&_TestVersionFD1WithExtraAny_9_list{list: &x.H}) + if !f(fd_TestVersionFD1WithExtraAny_h, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_TestVersionFD1WithExtraAny) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "testpb.TestVersionFD1WithExtraAny.x": + return x.X != int64(0) + case "testpb.TestVersionFD1WithExtraAny.a": + return x.A != nil + case "testpb.TestVersionFD1WithExtraAny.e": + if x.Sum == nil { + return false + } else if _, ok := x.Sum.(*TestVersionFD1WithExtraAny_E); ok { + return true + } else { + return false + } + case "testpb.TestVersionFD1WithExtraAny.f": + if x.Sum == nil { + return false + } else if _, ok := x.Sum.(*TestVersionFD1WithExtraAny_F); ok { + return true + } else { + return false + } + case "testpb.TestVersionFD1WithExtraAny.g": + return x.G != nil + case "testpb.TestVersionFD1WithExtraAny.h": + return len(x.H) != 0 + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersionFD1WithExtraAny")) + } + panic(fmt.Errorf("message testpb.TestVersionFD1WithExtraAny does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersionFD1WithExtraAny) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "testpb.TestVersionFD1WithExtraAny.x": + x.X = int64(0) + case "testpb.TestVersionFD1WithExtraAny.a": + x.A = nil + case "testpb.TestVersionFD1WithExtraAny.e": + x.Sum = nil + case "testpb.TestVersionFD1WithExtraAny.f": + x.Sum = nil + case "testpb.TestVersionFD1WithExtraAny.g": + x.G = nil + case "testpb.TestVersionFD1WithExtraAny.h": + x.H = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersionFD1WithExtraAny")) + } + panic(fmt.Errorf("message testpb.TestVersionFD1WithExtraAny does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_TestVersionFD1WithExtraAny) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "testpb.TestVersionFD1WithExtraAny.x": + value := x.X + return protoreflect.ValueOfInt64(value) + case "testpb.TestVersionFD1WithExtraAny.a": + value := x.A + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "testpb.TestVersionFD1WithExtraAny.e": + if x.Sum == nil { + return protoreflect.ValueOfInt32(int32(0)) + } else if v, ok := x.Sum.(*TestVersionFD1WithExtraAny_E); ok { + return protoreflect.ValueOfInt32(v.E) + } else { + return protoreflect.ValueOfInt32(int32(0)) + } + case "testpb.TestVersionFD1WithExtraAny.f": + if x.Sum == nil { + return protoreflect.ValueOfMessage((*TestVersion1)(nil).ProtoReflect()) + } else if v, ok := x.Sum.(*TestVersionFD1WithExtraAny_F); ok { + return protoreflect.ValueOfMessage(v.F.ProtoReflect()) + } else { + return protoreflect.ValueOfMessage((*TestVersion1)(nil).ProtoReflect()) + } + case "testpb.TestVersionFD1WithExtraAny.g": + value := x.G + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "testpb.TestVersionFD1WithExtraAny.h": + if len(x.H) == 0 { + return protoreflect.ValueOfList(&_TestVersionFD1WithExtraAny_9_list{}) + } + listValue := &_TestVersionFD1WithExtraAny_9_list{list: &x.H} + return protoreflect.ValueOfList(listValue) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersionFD1WithExtraAny")) + } + panic(fmt.Errorf("message testpb.TestVersionFD1WithExtraAny does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersionFD1WithExtraAny) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "testpb.TestVersionFD1WithExtraAny.x": + x.X = value.Int() + case "testpb.TestVersionFD1WithExtraAny.a": + x.A = value.Message().Interface().(*TestVersion1) + case "testpb.TestVersionFD1WithExtraAny.e": + cv := int32(value.Int()) + x.Sum = &TestVersionFD1WithExtraAny_E{E: cv} + case "testpb.TestVersionFD1WithExtraAny.f": + cv := value.Message().Interface().(*TestVersion1) + x.Sum = &TestVersionFD1WithExtraAny_F{F: cv} + case "testpb.TestVersionFD1WithExtraAny.g": + x.G = value.Message().Interface().(*AnyWithExtra) + case "testpb.TestVersionFD1WithExtraAny.h": + lv := value.List() + clv := lv.(*_TestVersionFD1WithExtraAny_9_list) + x.H = *clv.list + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersionFD1WithExtraAny")) + } + panic(fmt.Errorf("message testpb.TestVersionFD1WithExtraAny does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersionFD1WithExtraAny) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.TestVersionFD1WithExtraAny.a": + if x.A == nil { + x.A = new(TestVersion1) + } + return protoreflect.ValueOfMessage(x.A.ProtoReflect()) + case "testpb.TestVersionFD1WithExtraAny.f": + if x.Sum == nil { + value := &TestVersion1{} + oneofValue := &TestVersionFD1WithExtraAny_F{F: value} + x.Sum = oneofValue + return protoreflect.ValueOfMessage(value.ProtoReflect()) + } + switch m := x.Sum.(type) { + case *TestVersionFD1WithExtraAny_F: + return protoreflect.ValueOfMessage(m.F.ProtoReflect()) + default: + value := &TestVersion1{} + oneofValue := &TestVersionFD1WithExtraAny_F{F: value} + x.Sum = oneofValue + return protoreflect.ValueOfMessage(value.ProtoReflect()) + } + case "testpb.TestVersionFD1WithExtraAny.g": + if x.G == nil { + x.G = new(AnyWithExtra) + } + return protoreflect.ValueOfMessage(x.G.ProtoReflect()) + case "testpb.TestVersionFD1WithExtraAny.h": + if x.H == nil { + x.H = []*TestVersion1{} + } + value := &_TestVersionFD1WithExtraAny_9_list{list: &x.H} + return protoreflect.ValueOfList(value) + case "testpb.TestVersionFD1WithExtraAny.x": + panic(fmt.Errorf("field x of message testpb.TestVersionFD1WithExtraAny is not mutable")) + case "testpb.TestVersionFD1WithExtraAny.e": + panic(fmt.Errorf("field e of message testpb.TestVersionFD1WithExtraAny is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersionFD1WithExtraAny")) + } + panic(fmt.Errorf("message testpb.TestVersionFD1WithExtraAny does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_TestVersionFD1WithExtraAny) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.TestVersionFD1WithExtraAny.x": + return protoreflect.ValueOfInt64(int64(0)) + case "testpb.TestVersionFD1WithExtraAny.a": + m := new(TestVersion1) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "testpb.TestVersionFD1WithExtraAny.e": + return protoreflect.ValueOfInt32(int32(0)) + case "testpb.TestVersionFD1WithExtraAny.f": + value := &TestVersion1{} + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "testpb.TestVersionFD1WithExtraAny.g": + m := new(AnyWithExtra) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "testpb.TestVersionFD1WithExtraAny.h": + list := []*TestVersion1{} + return protoreflect.ValueOfList(&_TestVersionFD1WithExtraAny_9_list{list: &list}) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersionFD1WithExtraAny")) + } + panic(fmt.Errorf("message testpb.TestVersionFD1WithExtraAny does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_TestVersionFD1WithExtraAny) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + case "testpb.TestVersionFD1WithExtraAny.sum": + if x.Sum == nil { + return nil + } + switch x.Sum.(type) { + case *TestVersionFD1WithExtraAny_E: + return x.Descriptor().Fields().ByName("e") + case *TestVersionFD1WithExtraAny_F: + return x.Descriptor().Fields().ByName("f") + } + default: + panic(fmt.Errorf("%s is not a oneof field in testpb.TestVersionFD1WithExtraAny", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_TestVersionFD1WithExtraAny) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestVersionFD1WithExtraAny) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_TestVersionFD1WithExtraAny) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_TestVersionFD1WithExtraAny) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*TestVersionFD1WithExtraAny) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + if x.X != 0 { + n += 1 + runtime.Sov(uint64(x.X)) + } + if x.A != nil { + l = options.Size(x.A) + n += 1 + l + runtime.Sov(uint64(l)) + } + switch x := x.Sum.(type) { + case *TestVersionFD1WithExtraAny_E: + if x == nil { + break + } + n += 1 + runtime.Sov(uint64(x.E)) + case *TestVersionFD1WithExtraAny_F: + if x == nil { + break + } + l = options.Size(x.F) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.G != nil { + l = options.Size(x.G) + n += 1 + l + runtime.Sov(uint64(l)) + } + if len(x.H) > 0 { + for _, e := range x.H { + l = options.Size(e) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*TestVersionFD1WithExtraAny) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + switch x := x.Sum.(type) { + case *TestVersionFD1WithExtraAny_E: + i = runtime.EncodeVarint(dAtA, i, uint64(x.E)) + i-- + dAtA[i] = 0x30 + case *TestVersionFD1WithExtraAny_F: + encoded, err := options.Marshal(x.F) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x3a + } + if len(x.H) > 0 { + for iNdEx := len(x.H) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.H[iNdEx]) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x4a + } + } + if x.G != nil { + encoded, err := options.Marshal(x.G) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x42 + } + if x.A != nil { + encoded, err := options.Marshal(x.A) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x12 + } + if x.X != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.X)) + i-- + dAtA[i] = 0x8 + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*TestVersionFD1WithExtraAny) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersionFD1WithExtraAny: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersionFD1WithExtraAny: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field X", wireType) + } + x.X = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.X |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field A", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.A == nil { + x.A = &TestVersion1{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.A); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 6: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field E", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + x.Sum = &TestVersionFD1WithExtraAny_E{v} + case 7: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field F", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + v := &TestVersion1{} + if err := options.Unmarshal(dAtA[iNdEx:postIndex], v); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + x.Sum = &TestVersionFD1WithExtraAny_F{v} + iNdEx = postIndex + case 8: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field G", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.G == nil { + x.G = &AnyWithExtra{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.G); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field H", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.H = append(x.H, &TestVersion1{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.H[len(x.H)-1]); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var ( + md_AnyWithExtra protoreflect.MessageDescriptor + fd_AnyWithExtra_a protoreflect.FieldDescriptor + fd_AnyWithExtra_b protoreflect.FieldDescriptor + fd_AnyWithExtra_c protoreflect.FieldDescriptor +) + +func init() { + file_unknonwnproto_proto_init() + md_AnyWithExtra = File_unknonwnproto_proto.Messages().ByName("AnyWithExtra") + fd_AnyWithExtra_a = md_AnyWithExtra.Fields().ByName("a") + fd_AnyWithExtra_b = md_AnyWithExtra.Fields().ByName("b") + fd_AnyWithExtra_c = md_AnyWithExtra.Fields().ByName("c") +} + +var _ protoreflect.Message = (*fastReflection_AnyWithExtra)(nil) + +type fastReflection_AnyWithExtra AnyWithExtra + +func (x *AnyWithExtra) ProtoReflect() protoreflect.Message { + return (*fastReflection_AnyWithExtra)(x) +} + +func (x *AnyWithExtra) slowProtoReflect() protoreflect.Message { + mi := &file_unknonwnproto_proto_msgTypes[19] + 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) +} + +var _fastReflection_AnyWithExtra_messageType fastReflection_AnyWithExtra_messageType +var _ protoreflect.MessageType = fastReflection_AnyWithExtra_messageType{} + +type fastReflection_AnyWithExtra_messageType struct{} + +func (x fastReflection_AnyWithExtra_messageType) Zero() protoreflect.Message { + return (*fastReflection_AnyWithExtra)(nil) +} +func (x fastReflection_AnyWithExtra_messageType) New() protoreflect.Message { + return new(fastReflection_AnyWithExtra) +} +func (x fastReflection_AnyWithExtra_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_AnyWithExtra +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_AnyWithExtra) Descriptor() protoreflect.MessageDescriptor { + return md_AnyWithExtra +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_AnyWithExtra) Type() protoreflect.MessageType { + return _fastReflection_AnyWithExtra_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_AnyWithExtra) New() protoreflect.Message { + return new(fastReflection_AnyWithExtra) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_AnyWithExtra) Interface() protoreflect.ProtoMessage { + return (*AnyWithExtra)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_AnyWithExtra) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.A != nil { + value := protoreflect.ValueOfMessage(x.A.ProtoReflect()) + if !f(fd_AnyWithExtra_a, value) { + return + } + } + if x.B != int64(0) { + value := protoreflect.ValueOfInt64(x.B) + if !f(fd_AnyWithExtra_b, value) { + return + } + } + if x.C != int64(0) { + value := protoreflect.ValueOfInt64(x.C) + if !f(fd_AnyWithExtra_c, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_AnyWithExtra) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "testpb.AnyWithExtra.a": + return x.A != nil + case "testpb.AnyWithExtra.b": + return x.B != int64(0) + case "testpb.AnyWithExtra.c": + return x.C != int64(0) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.AnyWithExtra")) + } + panic(fmt.Errorf("message testpb.AnyWithExtra does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_AnyWithExtra) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "testpb.AnyWithExtra.a": + x.A = nil + case "testpb.AnyWithExtra.b": + x.B = int64(0) + case "testpb.AnyWithExtra.c": + x.C = int64(0) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.AnyWithExtra")) + } + panic(fmt.Errorf("message testpb.AnyWithExtra does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_AnyWithExtra) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "testpb.AnyWithExtra.a": + value := x.A + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "testpb.AnyWithExtra.b": + value := x.B + return protoreflect.ValueOfInt64(value) + case "testpb.AnyWithExtra.c": + value := x.C + return protoreflect.ValueOfInt64(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.AnyWithExtra")) + } + panic(fmt.Errorf("message testpb.AnyWithExtra does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_AnyWithExtra) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "testpb.AnyWithExtra.a": + x.A = value.Message().Interface().(*anypb.Any) + case "testpb.AnyWithExtra.b": + x.B = value.Int() + case "testpb.AnyWithExtra.c": + x.C = value.Int() + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.AnyWithExtra")) + } + panic(fmt.Errorf("message testpb.AnyWithExtra does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_AnyWithExtra) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.AnyWithExtra.a": + if x.A == nil { + x.A = new(anypb.Any) + } + return protoreflect.ValueOfMessage(x.A.ProtoReflect()) + case "testpb.AnyWithExtra.b": + panic(fmt.Errorf("field b of message testpb.AnyWithExtra is not mutable")) + case "testpb.AnyWithExtra.c": + panic(fmt.Errorf("field c of message testpb.AnyWithExtra is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.AnyWithExtra")) + } + panic(fmt.Errorf("message testpb.AnyWithExtra does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_AnyWithExtra) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.AnyWithExtra.a": + m := new(anypb.Any) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "testpb.AnyWithExtra.b": + return protoreflect.ValueOfInt64(int64(0)) + case "testpb.AnyWithExtra.c": + return protoreflect.ValueOfInt64(int64(0)) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.AnyWithExtra")) + } + panic(fmt.Errorf("message testpb.AnyWithExtra does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_AnyWithExtra) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in testpb.AnyWithExtra", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_AnyWithExtra) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_AnyWithExtra) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_AnyWithExtra) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_AnyWithExtra) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*AnyWithExtra) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + if x.A != nil { + l = options.Size(x.A) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.B != 0 { + n += 1 + runtime.Sov(uint64(x.B)) + } + if x.C != 0 { + n += 1 + runtime.Sov(uint64(x.C)) + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*AnyWithExtra) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if x.C != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.C)) + i-- + dAtA[i] = 0x20 + } + if x.B != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.B)) + i-- + dAtA[i] = 0x18 + } + if x.A != nil { + encoded, err := options.Marshal(x.A) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0xa + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*AnyWithExtra) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: AnyWithExtra: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: AnyWithExtra: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field A", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.A == nil { + x.A = &anypb.Any{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.A); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 3: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field B", wireType) + } + x.B = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.B |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field C", wireType) + } + x.C = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.C |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var _ protoreflect.List = (*_TestUpdatedTxRaw_3_list)(nil) + +type _TestUpdatedTxRaw_3_list struct { + list *[][]byte +} + +func (x *_TestUpdatedTxRaw_3_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_TestUpdatedTxRaw_3_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfBytes((*x.list)[i]) +} + +func (x *_TestUpdatedTxRaw_3_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Bytes() + concreteValue := valueUnwrapped + (*x.list)[i] = concreteValue +} + +func (x *_TestUpdatedTxRaw_3_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Bytes() + concreteValue := valueUnwrapped + *x.list = append(*x.list, concreteValue) +} + +func (x *_TestUpdatedTxRaw_3_list) AppendMutable() protoreflect.Value { + panic(fmt.Errorf("AppendMutable can not be called on message TestUpdatedTxRaw at list field Signatures as it is not of Message kind")) +} + +func (x *_TestUpdatedTxRaw_3_list) Truncate(n int) { + *x.list = (*x.list)[:n] +} + +func (x *_TestUpdatedTxRaw_3_list) NewElement() protoreflect.Value { + var v []byte + return protoreflect.ValueOfBytes(v) +} + +func (x *_TestUpdatedTxRaw_3_list) IsValid() bool { + return x.list != nil +} + +var ( + md_TestUpdatedTxRaw protoreflect.MessageDescriptor + fd_TestUpdatedTxRaw_body_bytes protoreflect.FieldDescriptor + fd_TestUpdatedTxRaw_auth_info_bytes protoreflect.FieldDescriptor + fd_TestUpdatedTxRaw_signatures protoreflect.FieldDescriptor + fd_TestUpdatedTxRaw_new_field_5 protoreflect.FieldDescriptor + fd_TestUpdatedTxRaw_new_field_1024 protoreflect.FieldDescriptor +) + +func init() { + file_unknonwnproto_proto_init() + md_TestUpdatedTxRaw = File_unknonwnproto_proto.Messages().ByName("TestUpdatedTxRaw") + fd_TestUpdatedTxRaw_body_bytes = md_TestUpdatedTxRaw.Fields().ByName("body_bytes") + fd_TestUpdatedTxRaw_auth_info_bytes = md_TestUpdatedTxRaw.Fields().ByName("auth_info_bytes") + fd_TestUpdatedTxRaw_signatures = md_TestUpdatedTxRaw.Fields().ByName("signatures") + fd_TestUpdatedTxRaw_new_field_5 = md_TestUpdatedTxRaw.Fields().ByName("new_field_5") + fd_TestUpdatedTxRaw_new_field_1024 = md_TestUpdatedTxRaw.Fields().ByName("new_field_1024") +} + +var _ protoreflect.Message = (*fastReflection_TestUpdatedTxRaw)(nil) + +type fastReflection_TestUpdatedTxRaw TestUpdatedTxRaw + +func (x *TestUpdatedTxRaw) ProtoReflect() protoreflect.Message { + return (*fastReflection_TestUpdatedTxRaw)(x) +} + +func (x *TestUpdatedTxRaw) slowProtoReflect() protoreflect.Message { + mi := &file_unknonwnproto_proto_msgTypes[20] + 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) +} + +var _fastReflection_TestUpdatedTxRaw_messageType fastReflection_TestUpdatedTxRaw_messageType +var _ protoreflect.MessageType = fastReflection_TestUpdatedTxRaw_messageType{} + +type fastReflection_TestUpdatedTxRaw_messageType struct{} + +func (x fastReflection_TestUpdatedTxRaw_messageType) Zero() protoreflect.Message { + return (*fastReflection_TestUpdatedTxRaw)(nil) +} +func (x fastReflection_TestUpdatedTxRaw_messageType) New() protoreflect.Message { + return new(fastReflection_TestUpdatedTxRaw) +} +func (x fastReflection_TestUpdatedTxRaw_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_TestUpdatedTxRaw +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_TestUpdatedTxRaw) Descriptor() protoreflect.MessageDescriptor { + return md_TestUpdatedTxRaw +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_TestUpdatedTxRaw) Type() protoreflect.MessageType { + return _fastReflection_TestUpdatedTxRaw_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_TestUpdatedTxRaw) New() protoreflect.Message { + return new(fastReflection_TestUpdatedTxRaw) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_TestUpdatedTxRaw) Interface() protoreflect.ProtoMessage { + return (*TestUpdatedTxRaw)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_TestUpdatedTxRaw) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if len(x.BodyBytes) != 0 { + value := protoreflect.ValueOfBytes(x.BodyBytes) + if !f(fd_TestUpdatedTxRaw_body_bytes, value) { + return + } + } + if len(x.AuthInfoBytes) != 0 { + value := protoreflect.ValueOfBytes(x.AuthInfoBytes) + if !f(fd_TestUpdatedTxRaw_auth_info_bytes, value) { + return + } + } + if len(x.Signatures) != 0 { + value := protoreflect.ValueOfList(&_TestUpdatedTxRaw_3_list{list: &x.Signatures}) + if !f(fd_TestUpdatedTxRaw_signatures, value) { + return + } + } + if len(x.NewField_5) != 0 { + value := protoreflect.ValueOfBytes(x.NewField_5) + if !f(fd_TestUpdatedTxRaw_new_field_5, value) { + return + } + } + if len(x.NewField_1024) != 0 { + value := protoreflect.ValueOfBytes(x.NewField_1024) + if !f(fd_TestUpdatedTxRaw_new_field_1024, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_TestUpdatedTxRaw) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "testpb.TestUpdatedTxRaw.body_bytes": + return len(x.BodyBytes) != 0 + case "testpb.TestUpdatedTxRaw.auth_info_bytes": + return len(x.AuthInfoBytes) != 0 + case "testpb.TestUpdatedTxRaw.signatures": + return len(x.Signatures) != 0 + case "testpb.TestUpdatedTxRaw.new_field_5": + return len(x.NewField_5) != 0 + case "testpb.TestUpdatedTxRaw.new_field_1024": + return len(x.NewField_1024) != 0 + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestUpdatedTxRaw")) + } + panic(fmt.Errorf("message testpb.TestUpdatedTxRaw does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestUpdatedTxRaw) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "testpb.TestUpdatedTxRaw.body_bytes": + x.BodyBytes = nil + case "testpb.TestUpdatedTxRaw.auth_info_bytes": + x.AuthInfoBytes = nil + case "testpb.TestUpdatedTxRaw.signatures": + x.Signatures = nil + case "testpb.TestUpdatedTxRaw.new_field_5": + x.NewField_5 = nil + case "testpb.TestUpdatedTxRaw.new_field_1024": + x.NewField_1024 = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestUpdatedTxRaw")) + } + panic(fmt.Errorf("message testpb.TestUpdatedTxRaw does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_TestUpdatedTxRaw) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "testpb.TestUpdatedTxRaw.body_bytes": + value := x.BodyBytes + return protoreflect.ValueOfBytes(value) + case "testpb.TestUpdatedTxRaw.auth_info_bytes": + value := x.AuthInfoBytes + return protoreflect.ValueOfBytes(value) + case "testpb.TestUpdatedTxRaw.signatures": + if len(x.Signatures) == 0 { + return protoreflect.ValueOfList(&_TestUpdatedTxRaw_3_list{}) + } + listValue := &_TestUpdatedTxRaw_3_list{list: &x.Signatures} + return protoreflect.ValueOfList(listValue) + case "testpb.TestUpdatedTxRaw.new_field_5": + value := x.NewField_5 + return protoreflect.ValueOfBytes(value) + case "testpb.TestUpdatedTxRaw.new_field_1024": + value := x.NewField_1024 + return protoreflect.ValueOfBytes(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestUpdatedTxRaw")) + } + panic(fmt.Errorf("message testpb.TestUpdatedTxRaw does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestUpdatedTxRaw) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "testpb.TestUpdatedTxRaw.body_bytes": + x.BodyBytes = value.Bytes() + case "testpb.TestUpdatedTxRaw.auth_info_bytes": + x.AuthInfoBytes = value.Bytes() + case "testpb.TestUpdatedTxRaw.signatures": + lv := value.List() + clv := lv.(*_TestUpdatedTxRaw_3_list) + x.Signatures = *clv.list + case "testpb.TestUpdatedTxRaw.new_field_5": + x.NewField_5 = value.Bytes() + case "testpb.TestUpdatedTxRaw.new_field_1024": + x.NewField_1024 = value.Bytes() + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestUpdatedTxRaw")) + } + panic(fmt.Errorf("message testpb.TestUpdatedTxRaw does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestUpdatedTxRaw) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.TestUpdatedTxRaw.signatures": + if x.Signatures == nil { + x.Signatures = [][]byte{} + } + value := &_TestUpdatedTxRaw_3_list{list: &x.Signatures} + return protoreflect.ValueOfList(value) + case "testpb.TestUpdatedTxRaw.body_bytes": + panic(fmt.Errorf("field body_bytes of message testpb.TestUpdatedTxRaw is not mutable")) + case "testpb.TestUpdatedTxRaw.auth_info_bytes": + panic(fmt.Errorf("field auth_info_bytes of message testpb.TestUpdatedTxRaw is not mutable")) + case "testpb.TestUpdatedTxRaw.new_field_5": + panic(fmt.Errorf("field new_field_5 of message testpb.TestUpdatedTxRaw is not mutable")) + case "testpb.TestUpdatedTxRaw.new_field_1024": + panic(fmt.Errorf("field new_field_1024 of message testpb.TestUpdatedTxRaw is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestUpdatedTxRaw")) + } + panic(fmt.Errorf("message testpb.TestUpdatedTxRaw does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_TestUpdatedTxRaw) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.TestUpdatedTxRaw.body_bytes": + return protoreflect.ValueOfBytes(nil) + case "testpb.TestUpdatedTxRaw.auth_info_bytes": + return protoreflect.ValueOfBytes(nil) + case "testpb.TestUpdatedTxRaw.signatures": + list := [][]byte{} + return protoreflect.ValueOfList(&_TestUpdatedTxRaw_3_list{list: &list}) + case "testpb.TestUpdatedTxRaw.new_field_5": + return protoreflect.ValueOfBytes(nil) + case "testpb.TestUpdatedTxRaw.new_field_1024": + return protoreflect.ValueOfBytes(nil) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestUpdatedTxRaw")) + } + panic(fmt.Errorf("message testpb.TestUpdatedTxRaw does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_TestUpdatedTxRaw) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in testpb.TestUpdatedTxRaw", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_TestUpdatedTxRaw) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestUpdatedTxRaw) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_TestUpdatedTxRaw) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_TestUpdatedTxRaw) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*TestUpdatedTxRaw) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + l = len(x.BodyBytes) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.AuthInfoBytes) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if len(x.Signatures) > 0 { + for _, b := range x.Signatures { + l = len(b) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + l = len(x.NewField_5) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.NewField_1024) + if l > 0 { + n += 2 + l + runtime.Sov(uint64(l)) + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*TestUpdatedTxRaw) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if len(x.NewField_1024) > 0 { + i -= len(x.NewField_1024) + copy(dAtA[i:], x.NewField_1024) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.NewField_1024))) + i-- + dAtA[i] = 0x40 + i-- + dAtA[i] = 0x82 + } + if len(x.NewField_5) > 0 { + i -= len(x.NewField_5) + copy(dAtA[i:], x.NewField_5) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.NewField_5))) + i-- + dAtA[i] = 0x2a + } + if len(x.Signatures) > 0 { + for iNdEx := len(x.Signatures) - 1; iNdEx >= 0; iNdEx-- { + i -= len(x.Signatures[iNdEx]) + copy(dAtA[i:], x.Signatures[iNdEx]) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Signatures[iNdEx]))) + i-- + dAtA[i] = 0x1a + } + } + if len(x.AuthInfoBytes) > 0 { + i -= len(x.AuthInfoBytes) + copy(dAtA[i:], x.AuthInfoBytes) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.AuthInfoBytes))) + i-- + dAtA[i] = 0x12 + } + if len(x.BodyBytes) > 0 { + i -= len(x.BodyBytes) + copy(dAtA[i:], x.BodyBytes) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.BodyBytes))) + i-- + dAtA[i] = 0xa + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*TestUpdatedTxRaw) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestUpdatedTxRaw: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestUpdatedTxRaw: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field BodyBytes", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.BodyBytes = append(x.BodyBytes[:0], dAtA[iNdEx:postIndex]...) + if x.BodyBytes == nil { + x.BodyBytes = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field AuthInfoBytes", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.AuthInfoBytes = append(x.AuthInfoBytes[:0], dAtA[iNdEx:postIndex]...) + if x.AuthInfoBytes == nil { + x.AuthInfoBytes = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Signatures", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Signatures = append(x.Signatures, make([]byte, postIndex-iNdEx)) + copy(x.Signatures[len(x.Signatures)-1], dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field NewField_5", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.NewField_5 = append(x.NewField_5[:0], dAtA[iNdEx:postIndex]...) + if x.NewField_5 == nil { + x.NewField_5 = []byte{} + } + iNdEx = postIndex + case 1024: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field NewField_1024", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.NewField_1024 = append(x.NewField_1024[:0], dAtA[iNdEx:postIndex]...) + if x.NewField_1024 == nil { + x.NewField_1024 = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var _ protoreflect.List = (*_TestUpdatedTxBody_1_list)(nil) + +type _TestUpdatedTxBody_1_list struct { + list *[]*anypb.Any +} + +func (x *_TestUpdatedTxBody_1_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_TestUpdatedTxBody_1_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_TestUpdatedTxBody_1_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*anypb.Any) + (*x.list)[i] = concreteValue +} + +func (x *_TestUpdatedTxBody_1_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*anypb.Any) + *x.list = append(*x.list, concreteValue) +} + +func (x *_TestUpdatedTxBody_1_list) AppendMutable() protoreflect.Value { + v := new(anypb.Any) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_TestUpdatedTxBody_1_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_TestUpdatedTxBody_1_list) NewElement() protoreflect.Value { + v := new(anypb.Any) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_TestUpdatedTxBody_1_list) IsValid() bool { + return x.list != nil +} + +var _ protoreflect.List = (*_TestUpdatedTxBody_1023_list)(nil) + +type _TestUpdatedTxBody_1023_list struct { + list *[]*anypb.Any +} + +func (x *_TestUpdatedTxBody_1023_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_TestUpdatedTxBody_1023_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_TestUpdatedTxBody_1023_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*anypb.Any) + (*x.list)[i] = concreteValue +} + +func (x *_TestUpdatedTxBody_1023_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*anypb.Any) + *x.list = append(*x.list, concreteValue) +} + +func (x *_TestUpdatedTxBody_1023_list) AppendMutable() protoreflect.Value { + v := new(anypb.Any) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_TestUpdatedTxBody_1023_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_TestUpdatedTxBody_1023_list) NewElement() protoreflect.Value { + v := new(anypb.Any) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_TestUpdatedTxBody_1023_list) IsValid() bool { + return x.list != nil +} + +var _ protoreflect.List = (*_TestUpdatedTxBody_2047_list)(nil) + +type _TestUpdatedTxBody_2047_list struct { + list *[]*anypb.Any +} + +func (x *_TestUpdatedTxBody_2047_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_TestUpdatedTxBody_2047_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_TestUpdatedTxBody_2047_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*anypb.Any) + (*x.list)[i] = concreteValue +} + +func (x *_TestUpdatedTxBody_2047_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*anypb.Any) + *x.list = append(*x.list, concreteValue) +} + +func (x *_TestUpdatedTxBody_2047_list) AppendMutable() protoreflect.Value { + v := new(anypb.Any) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_TestUpdatedTxBody_2047_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_TestUpdatedTxBody_2047_list) NewElement() protoreflect.Value { + v := new(anypb.Any) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_TestUpdatedTxBody_2047_list) IsValid() bool { + return x.list != nil +} + +var ( + md_TestUpdatedTxBody protoreflect.MessageDescriptor + fd_TestUpdatedTxBody_messages protoreflect.FieldDescriptor + fd_TestUpdatedTxBody_memo protoreflect.FieldDescriptor + fd_TestUpdatedTxBody_timeout_height protoreflect.FieldDescriptor + fd_TestUpdatedTxBody_some_new_field protoreflect.FieldDescriptor + fd_TestUpdatedTxBody_some_new_field_non_critical_field protoreflect.FieldDescriptor + fd_TestUpdatedTxBody_extension_options protoreflect.FieldDescriptor + fd_TestUpdatedTxBody_non_critical_extension_options protoreflect.FieldDescriptor +) + +func init() { + file_unknonwnproto_proto_init() + md_TestUpdatedTxBody = File_unknonwnproto_proto.Messages().ByName("TestUpdatedTxBody") + fd_TestUpdatedTxBody_messages = md_TestUpdatedTxBody.Fields().ByName("messages") + fd_TestUpdatedTxBody_memo = md_TestUpdatedTxBody.Fields().ByName("memo") + fd_TestUpdatedTxBody_timeout_height = md_TestUpdatedTxBody.Fields().ByName("timeout_height") + fd_TestUpdatedTxBody_some_new_field = md_TestUpdatedTxBody.Fields().ByName("some_new_field") + fd_TestUpdatedTxBody_some_new_field_non_critical_field = md_TestUpdatedTxBody.Fields().ByName("some_new_field_non_critical_field") + fd_TestUpdatedTxBody_extension_options = md_TestUpdatedTxBody.Fields().ByName("extension_options") + fd_TestUpdatedTxBody_non_critical_extension_options = md_TestUpdatedTxBody.Fields().ByName("non_critical_extension_options") +} + +var _ protoreflect.Message = (*fastReflection_TestUpdatedTxBody)(nil) + +type fastReflection_TestUpdatedTxBody TestUpdatedTxBody + +func (x *TestUpdatedTxBody) ProtoReflect() protoreflect.Message { + return (*fastReflection_TestUpdatedTxBody)(x) +} + +func (x *TestUpdatedTxBody) slowProtoReflect() protoreflect.Message { + mi := &file_unknonwnproto_proto_msgTypes[21] + 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) +} + +var _fastReflection_TestUpdatedTxBody_messageType fastReflection_TestUpdatedTxBody_messageType +var _ protoreflect.MessageType = fastReflection_TestUpdatedTxBody_messageType{} + +type fastReflection_TestUpdatedTxBody_messageType struct{} + +func (x fastReflection_TestUpdatedTxBody_messageType) Zero() protoreflect.Message { + return (*fastReflection_TestUpdatedTxBody)(nil) +} +func (x fastReflection_TestUpdatedTxBody_messageType) New() protoreflect.Message { + return new(fastReflection_TestUpdatedTxBody) +} +func (x fastReflection_TestUpdatedTxBody_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_TestUpdatedTxBody +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_TestUpdatedTxBody) Descriptor() protoreflect.MessageDescriptor { + return md_TestUpdatedTxBody +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_TestUpdatedTxBody) Type() protoreflect.MessageType { + return _fastReflection_TestUpdatedTxBody_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_TestUpdatedTxBody) New() protoreflect.Message { + return new(fastReflection_TestUpdatedTxBody) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_TestUpdatedTxBody) Interface() protoreflect.ProtoMessage { + return (*TestUpdatedTxBody)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_TestUpdatedTxBody) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if len(x.Messages) != 0 { + value := protoreflect.ValueOfList(&_TestUpdatedTxBody_1_list{list: &x.Messages}) + if !f(fd_TestUpdatedTxBody_messages, value) { + return + } + } + if x.Memo != "" { + value := protoreflect.ValueOfString(x.Memo) + if !f(fd_TestUpdatedTxBody_memo, value) { + return + } + } + if x.TimeoutHeight != int64(0) { + value := protoreflect.ValueOfInt64(x.TimeoutHeight) + if !f(fd_TestUpdatedTxBody_timeout_height, value) { + return + } + } + if x.SomeNewField != uint64(0) { + value := protoreflect.ValueOfUint64(x.SomeNewField) + if !f(fd_TestUpdatedTxBody_some_new_field, value) { + return + } + } + if x.SomeNewFieldNonCriticalField != "" { + value := protoreflect.ValueOfString(x.SomeNewFieldNonCriticalField) + if !f(fd_TestUpdatedTxBody_some_new_field_non_critical_field, value) { + return + } + } + if len(x.ExtensionOptions) != 0 { + value := protoreflect.ValueOfList(&_TestUpdatedTxBody_1023_list{list: &x.ExtensionOptions}) + if !f(fd_TestUpdatedTxBody_extension_options, value) { + return + } + } + if len(x.NonCriticalExtensionOptions) != 0 { + value := protoreflect.ValueOfList(&_TestUpdatedTxBody_2047_list{list: &x.NonCriticalExtensionOptions}) + if !f(fd_TestUpdatedTxBody_non_critical_extension_options, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_TestUpdatedTxBody) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "testpb.TestUpdatedTxBody.messages": + return len(x.Messages) != 0 + case "testpb.TestUpdatedTxBody.memo": + return x.Memo != "" + case "testpb.TestUpdatedTxBody.timeout_height": + return x.TimeoutHeight != int64(0) + case "testpb.TestUpdatedTxBody.some_new_field": + return x.SomeNewField != uint64(0) + case "testpb.TestUpdatedTxBody.some_new_field_non_critical_field": + return x.SomeNewFieldNonCriticalField != "" + case "testpb.TestUpdatedTxBody.extension_options": + return len(x.ExtensionOptions) != 0 + case "testpb.TestUpdatedTxBody.non_critical_extension_options": + return len(x.NonCriticalExtensionOptions) != 0 + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestUpdatedTxBody")) + } + panic(fmt.Errorf("message testpb.TestUpdatedTxBody does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestUpdatedTxBody) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "testpb.TestUpdatedTxBody.messages": + x.Messages = nil + case "testpb.TestUpdatedTxBody.memo": + x.Memo = "" + case "testpb.TestUpdatedTxBody.timeout_height": + x.TimeoutHeight = int64(0) + case "testpb.TestUpdatedTxBody.some_new_field": + x.SomeNewField = uint64(0) + case "testpb.TestUpdatedTxBody.some_new_field_non_critical_field": + x.SomeNewFieldNonCriticalField = "" + case "testpb.TestUpdatedTxBody.extension_options": + x.ExtensionOptions = nil + case "testpb.TestUpdatedTxBody.non_critical_extension_options": + x.NonCriticalExtensionOptions = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestUpdatedTxBody")) + } + panic(fmt.Errorf("message testpb.TestUpdatedTxBody does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_TestUpdatedTxBody) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "testpb.TestUpdatedTxBody.messages": + if len(x.Messages) == 0 { + return protoreflect.ValueOfList(&_TestUpdatedTxBody_1_list{}) + } + listValue := &_TestUpdatedTxBody_1_list{list: &x.Messages} + return protoreflect.ValueOfList(listValue) + case "testpb.TestUpdatedTxBody.memo": + value := x.Memo + return protoreflect.ValueOfString(value) + case "testpb.TestUpdatedTxBody.timeout_height": + value := x.TimeoutHeight + return protoreflect.ValueOfInt64(value) + case "testpb.TestUpdatedTxBody.some_new_field": + value := x.SomeNewField + return protoreflect.ValueOfUint64(value) + case "testpb.TestUpdatedTxBody.some_new_field_non_critical_field": + value := x.SomeNewFieldNonCriticalField + return protoreflect.ValueOfString(value) + case "testpb.TestUpdatedTxBody.extension_options": + if len(x.ExtensionOptions) == 0 { + return protoreflect.ValueOfList(&_TestUpdatedTxBody_1023_list{}) + } + listValue := &_TestUpdatedTxBody_1023_list{list: &x.ExtensionOptions} + return protoreflect.ValueOfList(listValue) + case "testpb.TestUpdatedTxBody.non_critical_extension_options": + if len(x.NonCriticalExtensionOptions) == 0 { + return protoreflect.ValueOfList(&_TestUpdatedTxBody_2047_list{}) + } + listValue := &_TestUpdatedTxBody_2047_list{list: &x.NonCriticalExtensionOptions} + return protoreflect.ValueOfList(listValue) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestUpdatedTxBody")) + } + panic(fmt.Errorf("message testpb.TestUpdatedTxBody does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestUpdatedTxBody) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "testpb.TestUpdatedTxBody.messages": + lv := value.List() + clv := lv.(*_TestUpdatedTxBody_1_list) + x.Messages = *clv.list + case "testpb.TestUpdatedTxBody.memo": + x.Memo = value.Interface().(string) + case "testpb.TestUpdatedTxBody.timeout_height": + x.TimeoutHeight = value.Int() + case "testpb.TestUpdatedTxBody.some_new_field": + x.SomeNewField = value.Uint() + case "testpb.TestUpdatedTxBody.some_new_field_non_critical_field": + x.SomeNewFieldNonCriticalField = value.Interface().(string) + case "testpb.TestUpdatedTxBody.extension_options": + lv := value.List() + clv := lv.(*_TestUpdatedTxBody_1023_list) + x.ExtensionOptions = *clv.list + case "testpb.TestUpdatedTxBody.non_critical_extension_options": + lv := value.List() + clv := lv.(*_TestUpdatedTxBody_2047_list) + x.NonCriticalExtensionOptions = *clv.list + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestUpdatedTxBody")) + } + panic(fmt.Errorf("message testpb.TestUpdatedTxBody does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestUpdatedTxBody) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.TestUpdatedTxBody.messages": + if x.Messages == nil { + x.Messages = []*anypb.Any{} + } + value := &_TestUpdatedTxBody_1_list{list: &x.Messages} + return protoreflect.ValueOfList(value) + case "testpb.TestUpdatedTxBody.extension_options": + if x.ExtensionOptions == nil { + x.ExtensionOptions = []*anypb.Any{} + } + value := &_TestUpdatedTxBody_1023_list{list: &x.ExtensionOptions} + return protoreflect.ValueOfList(value) + case "testpb.TestUpdatedTxBody.non_critical_extension_options": + if x.NonCriticalExtensionOptions == nil { + x.NonCriticalExtensionOptions = []*anypb.Any{} + } + value := &_TestUpdatedTxBody_2047_list{list: &x.NonCriticalExtensionOptions} + return protoreflect.ValueOfList(value) + case "testpb.TestUpdatedTxBody.memo": + panic(fmt.Errorf("field memo of message testpb.TestUpdatedTxBody is not mutable")) + case "testpb.TestUpdatedTxBody.timeout_height": + panic(fmt.Errorf("field timeout_height of message testpb.TestUpdatedTxBody is not mutable")) + case "testpb.TestUpdatedTxBody.some_new_field": + panic(fmt.Errorf("field some_new_field of message testpb.TestUpdatedTxBody is not mutable")) + case "testpb.TestUpdatedTxBody.some_new_field_non_critical_field": + panic(fmt.Errorf("field some_new_field_non_critical_field of message testpb.TestUpdatedTxBody is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestUpdatedTxBody")) + } + panic(fmt.Errorf("message testpb.TestUpdatedTxBody does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_TestUpdatedTxBody) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.TestUpdatedTxBody.messages": + list := []*anypb.Any{} + return protoreflect.ValueOfList(&_TestUpdatedTxBody_1_list{list: &list}) + case "testpb.TestUpdatedTxBody.memo": + return protoreflect.ValueOfString("") + case "testpb.TestUpdatedTxBody.timeout_height": + return protoreflect.ValueOfInt64(int64(0)) + case "testpb.TestUpdatedTxBody.some_new_field": + return protoreflect.ValueOfUint64(uint64(0)) + case "testpb.TestUpdatedTxBody.some_new_field_non_critical_field": + return protoreflect.ValueOfString("") + case "testpb.TestUpdatedTxBody.extension_options": + list := []*anypb.Any{} + return protoreflect.ValueOfList(&_TestUpdatedTxBody_1023_list{list: &list}) + case "testpb.TestUpdatedTxBody.non_critical_extension_options": + list := []*anypb.Any{} + return protoreflect.ValueOfList(&_TestUpdatedTxBody_2047_list{list: &list}) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestUpdatedTxBody")) + } + panic(fmt.Errorf("message testpb.TestUpdatedTxBody does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_TestUpdatedTxBody) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in testpb.TestUpdatedTxBody", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_TestUpdatedTxBody) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestUpdatedTxBody) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_TestUpdatedTxBody) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_TestUpdatedTxBody) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*TestUpdatedTxBody) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + if len(x.Messages) > 0 { + for _, e := range x.Messages { + l = options.Size(e) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + l = len(x.Memo) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.TimeoutHeight != 0 { + n += 1 + runtime.Sov(uint64(x.TimeoutHeight)) + } + if x.SomeNewField != 0 { + n += 1 + runtime.Sov(uint64(x.SomeNewField)) + } + l = len(x.SomeNewFieldNonCriticalField) + if l > 0 { + n += 2 + l + runtime.Sov(uint64(l)) + } + if len(x.ExtensionOptions) > 0 { + for _, e := range x.ExtensionOptions { + l = options.Size(e) + n += 2 + l + runtime.Sov(uint64(l)) + } + } + if len(x.NonCriticalExtensionOptions) > 0 { + for _, e := range x.NonCriticalExtensionOptions { + l = options.Size(e) + n += 2 + l + runtime.Sov(uint64(l)) + } + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*TestUpdatedTxBody) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if len(x.NonCriticalExtensionOptions) > 0 { + for iNdEx := len(x.NonCriticalExtensionOptions) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.NonCriticalExtensionOptions[iNdEx]) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x7f + i-- + dAtA[i] = 0xfa + } + } + if len(x.SomeNewFieldNonCriticalField) > 0 { + i -= len(x.SomeNewFieldNonCriticalField) + copy(dAtA[i:], x.SomeNewFieldNonCriticalField) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.SomeNewFieldNonCriticalField))) + i-- + dAtA[i] = 0x41 + i-- + dAtA[i] = 0xd2 + } + if len(x.ExtensionOptions) > 0 { + for iNdEx := len(x.ExtensionOptions) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.ExtensionOptions[iNdEx]) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x3f + i-- + dAtA[i] = 0xfa + } + } + if x.SomeNewField != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.SomeNewField)) + i-- + dAtA[i] = 0x20 + } + if x.TimeoutHeight != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.TimeoutHeight)) + i-- + dAtA[i] = 0x18 + } + if len(x.Memo) > 0 { + i -= len(x.Memo) + copy(dAtA[i:], x.Memo) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Memo))) + i-- + dAtA[i] = 0x12 + } + if len(x.Messages) > 0 { + for iNdEx := len(x.Messages) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.Messages[iNdEx]) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0xa + } + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*TestUpdatedTxBody) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestUpdatedTxBody: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestUpdatedTxBody: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Messages", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Messages = append(x.Messages, &anypb.Any{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Messages[len(x.Messages)-1]); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Memo", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Memo = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field TimeoutHeight", wireType) + } + x.TimeoutHeight = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.TimeoutHeight |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field SomeNewField", wireType) + } + x.SomeNewField = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.SomeNewField |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 1050: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field SomeNewFieldNonCriticalField", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.SomeNewFieldNonCriticalField = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 1023: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ExtensionOptions", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.ExtensionOptions = append(x.ExtensionOptions, &anypb.Any{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ExtensionOptions[len(x.ExtensionOptions)-1]); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 2047: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field NonCriticalExtensionOptions", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.NonCriticalExtensionOptions = append(x.NonCriticalExtensionOptions, &anypb.Any{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.NonCriticalExtensionOptions[len(x.NonCriticalExtensionOptions)-1]); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var _ protoreflect.List = (*_TestUpdatedAuthInfo_1_list)(nil) + +type _TestUpdatedAuthInfo_1_list struct { + list *[]*v1beta1.SignerInfo +} + +func (x *_TestUpdatedAuthInfo_1_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_TestUpdatedAuthInfo_1_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_TestUpdatedAuthInfo_1_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*v1beta1.SignerInfo) + (*x.list)[i] = concreteValue +} + +func (x *_TestUpdatedAuthInfo_1_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*v1beta1.SignerInfo) + *x.list = append(*x.list, concreteValue) +} + +func (x *_TestUpdatedAuthInfo_1_list) AppendMutable() protoreflect.Value { + v := new(v1beta1.SignerInfo) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_TestUpdatedAuthInfo_1_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_TestUpdatedAuthInfo_1_list) NewElement() protoreflect.Value { + v := new(v1beta1.SignerInfo) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_TestUpdatedAuthInfo_1_list) IsValid() bool { + return x.list != nil +} + +var ( + md_TestUpdatedAuthInfo protoreflect.MessageDescriptor + fd_TestUpdatedAuthInfo_signer_infos protoreflect.FieldDescriptor + fd_TestUpdatedAuthInfo_fee protoreflect.FieldDescriptor + fd_TestUpdatedAuthInfo_new_field_3 protoreflect.FieldDescriptor + fd_TestUpdatedAuthInfo_new_field_1024 protoreflect.FieldDescriptor +) + +func init() { + file_unknonwnproto_proto_init() + md_TestUpdatedAuthInfo = File_unknonwnproto_proto.Messages().ByName("TestUpdatedAuthInfo") + fd_TestUpdatedAuthInfo_signer_infos = md_TestUpdatedAuthInfo.Fields().ByName("signer_infos") + fd_TestUpdatedAuthInfo_fee = md_TestUpdatedAuthInfo.Fields().ByName("fee") + fd_TestUpdatedAuthInfo_new_field_3 = md_TestUpdatedAuthInfo.Fields().ByName("new_field_3") + fd_TestUpdatedAuthInfo_new_field_1024 = md_TestUpdatedAuthInfo.Fields().ByName("new_field_1024") +} + +var _ protoreflect.Message = (*fastReflection_TestUpdatedAuthInfo)(nil) + +type fastReflection_TestUpdatedAuthInfo TestUpdatedAuthInfo + +func (x *TestUpdatedAuthInfo) ProtoReflect() protoreflect.Message { + return (*fastReflection_TestUpdatedAuthInfo)(x) +} + +func (x *TestUpdatedAuthInfo) slowProtoReflect() protoreflect.Message { + mi := &file_unknonwnproto_proto_msgTypes[22] + 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) +} + +var _fastReflection_TestUpdatedAuthInfo_messageType fastReflection_TestUpdatedAuthInfo_messageType +var _ protoreflect.MessageType = fastReflection_TestUpdatedAuthInfo_messageType{} + +type fastReflection_TestUpdatedAuthInfo_messageType struct{} + +func (x fastReflection_TestUpdatedAuthInfo_messageType) Zero() protoreflect.Message { + return (*fastReflection_TestUpdatedAuthInfo)(nil) +} +func (x fastReflection_TestUpdatedAuthInfo_messageType) New() protoreflect.Message { + return new(fastReflection_TestUpdatedAuthInfo) +} +func (x fastReflection_TestUpdatedAuthInfo_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_TestUpdatedAuthInfo +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_TestUpdatedAuthInfo) Descriptor() protoreflect.MessageDescriptor { + return md_TestUpdatedAuthInfo +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_TestUpdatedAuthInfo) Type() protoreflect.MessageType { + return _fastReflection_TestUpdatedAuthInfo_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_TestUpdatedAuthInfo) New() protoreflect.Message { + return new(fastReflection_TestUpdatedAuthInfo) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_TestUpdatedAuthInfo) Interface() protoreflect.ProtoMessage { + return (*TestUpdatedAuthInfo)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_TestUpdatedAuthInfo) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if len(x.SignerInfos) != 0 { + value := protoreflect.ValueOfList(&_TestUpdatedAuthInfo_1_list{list: &x.SignerInfos}) + if !f(fd_TestUpdatedAuthInfo_signer_infos, value) { + return + } + } + if x.Fee != nil { + value := protoreflect.ValueOfMessage(x.Fee.ProtoReflect()) + if !f(fd_TestUpdatedAuthInfo_fee, value) { + return + } + } + if len(x.NewField_3) != 0 { + value := protoreflect.ValueOfBytes(x.NewField_3) + if !f(fd_TestUpdatedAuthInfo_new_field_3, value) { + return + } + } + if len(x.NewField_1024) != 0 { + value := protoreflect.ValueOfBytes(x.NewField_1024) + if !f(fd_TestUpdatedAuthInfo_new_field_1024, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_TestUpdatedAuthInfo) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "testpb.TestUpdatedAuthInfo.signer_infos": + return len(x.SignerInfos) != 0 + case "testpb.TestUpdatedAuthInfo.fee": + return x.Fee != nil + case "testpb.TestUpdatedAuthInfo.new_field_3": + return len(x.NewField_3) != 0 + case "testpb.TestUpdatedAuthInfo.new_field_1024": + return len(x.NewField_1024) != 0 + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestUpdatedAuthInfo")) + } + panic(fmt.Errorf("message testpb.TestUpdatedAuthInfo does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestUpdatedAuthInfo) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "testpb.TestUpdatedAuthInfo.signer_infos": + x.SignerInfos = nil + case "testpb.TestUpdatedAuthInfo.fee": + x.Fee = nil + case "testpb.TestUpdatedAuthInfo.new_field_3": + x.NewField_3 = nil + case "testpb.TestUpdatedAuthInfo.new_field_1024": + x.NewField_1024 = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestUpdatedAuthInfo")) + } + panic(fmt.Errorf("message testpb.TestUpdatedAuthInfo does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_TestUpdatedAuthInfo) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "testpb.TestUpdatedAuthInfo.signer_infos": + if len(x.SignerInfos) == 0 { + return protoreflect.ValueOfList(&_TestUpdatedAuthInfo_1_list{}) + } + listValue := &_TestUpdatedAuthInfo_1_list{list: &x.SignerInfos} + return protoreflect.ValueOfList(listValue) + case "testpb.TestUpdatedAuthInfo.fee": + value := x.Fee + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "testpb.TestUpdatedAuthInfo.new_field_3": + value := x.NewField_3 + return protoreflect.ValueOfBytes(value) + case "testpb.TestUpdatedAuthInfo.new_field_1024": + value := x.NewField_1024 + return protoreflect.ValueOfBytes(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestUpdatedAuthInfo")) + } + panic(fmt.Errorf("message testpb.TestUpdatedAuthInfo does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestUpdatedAuthInfo) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "testpb.TestUpdatedAuthInfo.signer_infos": + lv := value.List() + clv := lv.(*_TestUpdatedAuthInfo_1_list) + x.SignerInfos = *clv.list + case "testpb.TestUpdatedAuthInfo.fee": + x.Fee = value.Message().Interface().(*v1beta1.Fee) + case "testpb.TestUpdatedAuthInfo.new_field_3": + x.NewField_3 = value.Bytes() + case "testpb.TestUpdatedAuthInfo.new_field_1024": + x.NewField_1024 = value.Bytes() + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestUpdatedAuthInfo")) + } + panic(fmt.Errorf("message testpb.TestUpdatedAuthInfo does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestUpdatedAuthInfo) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.TestUpdatedAuthInfo.signer_infos": + if x.SignerInfos == nil { + x.SignerInfos = []*v1beta1.SignerInfo{} + } + value := &_TestUpdatedAuthInfo_1_list{list: &x.SignerInfos} + return protoreflect.ValueOfList(value) + case "testpb.TestUpdatedAuthInfo.fee": + if x.Fee == nil { + x.Fee = new(v1beta1.Fee) + } + return protoreflect.ValueOfMessage(x.Fee.ProtoReflect()) + case "testpb.TestUpdatedAuthInfo.new_field_3": + panic(fmt.Errorf("field new_field_3 of message testpb.TestUpdatedAuthInfo is not mutable")) + case "testpb.TestUpdatedAuthInfo.new_field_1024": + panic(fmt.Errorf("field new_field_1024 of message testpb.TestUpdatedAuthInfo is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestUpdatedAuthInfo")) + } + panic(fmt.Errorf("message testpb.TestUpdatedAuthInfo does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_TestUpdatedAuthInfo) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.TestUpdatedAuthInfo.signer_infos": + list := []*v1beta1.SignerInfo{} + return protoreflect.ValueOfList(&_TestUpdatedAuthInfo_1_list{list: &list}) + case "testpb.TestUpdatedAuthInfo.fee": + m := new(v1beta1.Fee) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "testpb.TestUpdatedAuthInfo.new_field_3": + return protoreflect.ValueOfBytes(nil) + case "testpb.TestUpdatedAuthInfo.new_field_1024": + return protoreflect.ValueOfBytes(nil) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestUpdatedAuthInfo")) + } + panic(fmt.Errorf("message testpb.TestUpdatedAuthInfo does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_TestUpdatedAuthInfo) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in testpb.TestUpdatedAuthInfo", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_TestUpdatedAuthInfo) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestUpdatedAuthInfo) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_TestUpdatedAuthInfo) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_TestUpdatedAuthInfo) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*TestUpdatedAuthInfo) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + if len(x.SignerInfos) > 0 { + for _, e := range x.SignerInfos { + l = options.Size(e) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + if x.Fee != nil { + l = options.Size(x.Fee) + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.NewField_3) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.NewField_1024) + if l > 0 { + n += 2 + l + runtime.Sov(uint64(l)) + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*TestUpdatedAuthInfo) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if len(x.NewField_1024) > 0 { + i -= len(x.NewField_1024) + copy(dAtA[i:], x.NewField_1024) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.NewField_1024))) + i-- + dAtA[i] = 0x40 + i-- + dAtA[i] = 0x82 + } + if len(x.NewField_3) > 0 { + i -= len(x.NewField_3) + copy(dAtA[i:], x.NewField_3) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.NewField_3))) + i-- + dAtA[i] = 0x1a + } + if x.Fee != nil { + encoded, err := options.Marshal(x.Fee) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x12 + } + if len(x.SignerInfos) > 0 { + for iNdEx := len(x.SignerInfos) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.SignerInfos[iNdEx]) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0xa + } + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*TestUpdatedAuthInfo) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestUpdatedAuthInfo: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestUpdatedAuthInfo: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field SignerInfos", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.SignerInfos = append(x.SignerInfos, &v1beta1.SignerInfo{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.SignerInfos[len(x.SignerInfos)-1]); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Fee", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.Fee == nil { + x.Fee = &v1beta1.Fee{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Fee); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field NewField_3", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.NewField_3 = append(x.NewField_3[:0], dAtA[iNdEx:postIndex]...) + if x.NewField_3 == nil { + x.NewField_3 = []byte{} + } + iNdEx = postIndex + case 1024: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field NewField_1024", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.NewField_1024 = append(x.NewField_1024[:0], dAtA[iNdEx:postIndex]...) + if x.NewField_1024 == nil { + x.NewField_1024 = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var _ protoreflect.List = (*_TestRepeatedUints_1_list)(nil) + +type _TestRepeatedUints_1_list struct { + list *[]uint64 +} + +func (x *_TestRepeatedUints_1_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_TestRepeatedUints_1_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfUint64((*x.list)[i]) +} + +func (x *_TestRepeatedUints_1_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Uint() + concreteValue := valueUnwrapped + (*x.list)[i] = concreteValue +} + +func (x *_TestRepeatedUints_1_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Uint() + concreteValue := valueUnwrapped + *x.list = append(*x.list, concreteValue) +} + +func (x *_TestRepeatedUints_1_list) AppendMutable() protoreflect.Value { + panic(fmt.Errorf("AppendMutable can not be called on message TestRepeatedUints at list field Nums as it is not of Message kind")) +} + +func (x *_TestRepeatedUints_1_list) Truncate(n int) { + *x.list = (*x.list)[:n] +} + +func (x *_TestRepeatedUints_1_list) NewElement() protoreflect.Value { + v := uint64(0) + return protoreflect.ValueOfUint64(v) +} + +func (x *_TestRepeatedUints_1_list) IsValid() bool { + return x.list != nil +} + +var ( + md_TestRepeatedUints protoreflect.MessageDescriptor + fd_TestRepeatedUints_nums protoreflect.FieldDescriptor +) + +func init() { + file_unknonwnproto_proto_init() + md_TestRepeatedUints = File_unknonwnproto_proto.Messages().ByName("TestRepeatedUints") + fd_TestRepeatedUints_nums = md_TestRepeatedUints.Fields().ByName("nums") +} + +var _ protoreflect.Message = (*fastReflection_TestRepeatedUints)(nil) + +type fastReflection_TestRepeatedUints TestRepeatedUints + +func (x *TestRepeatedUints) ProtoReflect() protoreflect.Message { + return (*fastReflection_TestRepeatedUints)(x) +} + +func (x *TestRepeatedUints) slowProtoReflect() protoreflect.Message { + mi := &file_unknonwnproto_proto_msgTypes[23] + 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) +} + +var _fastReflection_TestRepeatedUints_messageType fastReflection_TestRepeatedUints_messageType +var _ protoreflect.MessageType = fastReflection_TestRepeatedUints_messageType{} + +type fastReflection_TestRepeatedUints_messageType struct{} + +func (x fastReflection_TestRepeatedUints_messageType) Zero() protoreflect.Message { + return (*fastReflection_TestRepeatedUints)(nil) +} +func (x fastReflection_TestRepeatedUints_messageType) New() protoreflect.Message { + return new(fastReflection_TestRepeatedUints) +} +func (x fastReflection_TestRepeatedUints_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_TestRepeatedUints +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_TestRepeatedUints) Descriptor() protoreflect.MessageDescriptor { + return md_TestRepeatedUints +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_TestRepeatedUints) Type() protoreflect.MessageType { + return _fastReflection_TestRepeatedUints_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_TestRepeatedUints) New() protoreflect.Message { + return new(fastReflection_TestRepeatedUints) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_TestRepeatedUints) Interface() protoreflect.ProtoMessage { + return (*TestRepeatedUints)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_TestRepeatedUints) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if len(x.Nums) != 0 { + value := protoreflect.ValueOfList(&_TestRepeatedUints_1_list{list: &x.Nums}) + if !f(fd_TestRepeatedUints_nums, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_TestRepeatedUints) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "testpb.TestRepeatedUints.nums": + return len(x.Nums) != 0 + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestRepeatedUints")) + } + panic(fmt.Errorf("message testpb.TestRepeatedUints does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestRepeatedUints) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "testpb.TestRepeatedUints.nums": + x.Nums = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestRepeatedUints")) + } + panic(fmt.Errorf("message testpb.TestRepeatedUints does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_TestRepeatedUints) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "testpb.TestRepeatedUints.nums": + if len(x.Nums) == 0 { + return protoreflect.ValueOfList(&_TestRepeatedUints_1_list{}) + } + listValue := &_TestRepeatedUints_1_list{list: &x.Nums} + return protoreflect.ValueOfList(listValue) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestRepeatedUints")) + } + panic(fmt.Errorf("message testpb.TestRepeatedUints does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestRepeatedUints) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "testpb.TestRepeatedUints.nums": + lv := value.List() + clv := lv.(*_TestRepeatedUints_1_list) + x.Nums = *clv.list + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestRepeatedUints")) + } + panic(fmt.Errorf("message testpb.TestRepeatedUints does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestRepeatedUints) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.TestRepeatedUints.nums": + if x.Nums == nil { + x.Nums = []uint64{} + } + value := &_TestRepeatedUints_1_list{list: &x.Nums} + return protoreflect.ValueOfList(value) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestRepeatedUints")) + } + panic(fmt.Errorf("message testpb.TestRepeatedUints does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_TestRepeatedUints) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "testpb.TestRepeatedUints.nums": + list := []uint64{} + return protoreflect.ValueOfList(&_TestRepeatedUints_1_list{list: &list}) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestRepeatedUints")) + } + panic(fmt.Errorf("message testpb.TestRepeatedUints does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_TestRepeatedUints) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in testpb.TestRepeatedUints", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_TestRepeatedUints) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_TestRepeatedUints) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_TestRepeatedUints) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_TestRepeatedUints) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*TestRepeatedUints) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + if len(x.Nums) > 0 { + l = 0 + for _, e := range x.Nums { + l += runtime.Sov(uint64(e)) + } + n += 1 + runtime.Sov(uint64(l)) + l + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*TestRepeatedUints) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if len(x.Nums) > 0 { + var pksize2 int + for _, num := range x.Nums { + pksize2 += runtime.Sov(uint64(num)) + } + i -= pksize2 + j1 := i + for _, num := range x.Nums { + for num >= 1<<7 { + dAtA[j1] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j1++ + } + dAtA[j1] = uint8(num) + j1++ + } + i = runtime.EncodeVarint(dAtA, i, uint64(pksize2)) + i-- + dAtA[i] = 0xa + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*TestRepeatedUints) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestRepeatedUints: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestRepeatedUints: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType == 0 { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + x.Nums = append(x.Nums, v) + } else if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + packedLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + packedLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + var elementCount int + var count int + for _, integer := range dAtA[iNdEx:postIndex] { + if integer < 128 { + count++ + } + } + elementCount = count + if elementCount != 0 && len(x.Nums) == 0 { + x.Nums = make([]uint64, 0, elementCount) + } + for iNdEx < postIndex { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + x.Nums = append(x.Nums, v) + } + } else { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Nums", wireType) + } + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.27.0 +// protoc (unknown) +// source: unknonwnproto.proto + +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 Customer2_City int32 + +const ( + Customer2_Laos Customer2_City = 0 + Customer2_LosAngeles Customer2_City = 1 + Customer2_PaloAlto Customer2_City = 2 + Customer2_Moscow Customer2_City = 3 + Customer2_Nairobi Customer2_City = 4 +) + +// Enum value maps for Customer2_City. +var ( + Customer2_City_name = map[int32]string{ + 0: "Laos", + 1: "LosAngeles", + 2: "PaloAlto", + 3: "Moscow", + 4: "Nairobi", + } + Customer2_City_value = map[string]int32{ + "Laos": 0, + "LosAngeles": 1, + "PaloAlto": 2, + "Moscow": 3, + "Nairobi": 4, + } +) + +func (x Customer2_City) Enum() *Customer2_City { + p := new(Customer2_City) + *p = x + return p +} + +func (x Customer2_City) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (Customer2_City) Descriptor() protoreflect.EnumDescriptor { + return file_unknonwnproto_proto_enumTypes[0].Descriptor() +} + +func (Customer2_City) Type() protoreflect.EnumType { + return &file_unknonwnproto_proto_enumTypes[0] +} + +func (x Customer2_City) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use Customer2_City.Descriptor instead. +func (Customer2_City) EnumDescriptor() ([]byte, []int) { + return file_unknonwnproto_proto_rawDescGZIP(), []int{1, 0} +} + +type Customer1 struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id int32 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + SubscriptionFee float32 `protobuf:"fixed32,3,opt,name=subscription_fee,json=subscriptionFee,proto3" json:"subscription_fee,omitempty"` + Payment string `protobuf:"bytes,7,opt,name=payment,proto3" json:"payment,omitempty"` +} + +func (x *Customer1) Reset() { + *x = Customer1{} + if protoimpl.UnsafeEnabled { + mi := &file_unknonwnproto_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Customer1) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Customer1) ProtoMessage() {} + +// Deprecated: Use Customer1.ProtoReflect.Descriptor instead. +func (*Customer1) Descriptor() ([]byte, []int) { + return file_unknonwnproto_proto_rawDescGZIP(), []int{0} +} + +func (x *Customer1) GetId() int32 { + if x != nil { + return x.Id + } + return 0 +} + +func (x *Customer1) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *Customer1) GetSubscriptionFee() float32 { + if x != nil { + return x.SubscriptionFee + } + return 0 +} + +func (x *Customer1) GetPayment() string { + if x != nil { + return x.Payment + } + return "" +} + +type Customer2 struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id int32 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + Industry int32 `protobuf:"varint,2,opt,name=industry,proto3" json:"industry,omitempty"` + Name string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"` + Fewer float32 `protobuf:"fixed32,4,opt,name=fewer,proto3" json:"fewer,omitempty"` + Reserved int64 `protobuf:"varint,1047,opt,name=reserved,proto3" json:"reserved,omitempty"` + City Customer2_City `protobuf:"varint,6,opt,name=city,proto3,enum=testpb.Customer2_City" json:"city,omitempty"` + Miscellaneous *anypb.Any `protobuf:"bytes,10,opt,name=miscellaneous,proto3" json:"miscellaneous,omitempty"` +} + +func (x *Customer2) Reset() { + *x = Customer2{} + if protoimpl.UnsafeEnabled { + mi := &file_unknonwnproto_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Customer2) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Customer2) ProtoMessage() {} + +// Deprecated: Use Customer2.ProtoReflect.Descriptor instead. +func (*Customer2) Descriptor() ([]byte, []int) { + return file_unknonwnproto_proto_rawDescGZIP(), []int{1} +} + +func (x *Customer2) GetId() int32 { + if x != nil { + return x.Id + } + return 0 +} + +func (x *Customer2) GetIndustry() int32 { + if x != nil { + return x.Industry + } + return 0 +} + +func (x *Customer2) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *Customer2) GetFewer() float32 { + if x != nil { + return x.Fewer + } + return 0 +} + +func (x *Customer2) GetReserved() int64 { + if x != nil { + return x.Reserved + } + return 0 +} + +func (x *Customer2) GetCity() Customer2_City { + if x != nil { + return x.City + } + return Customer2_Laos +} + +func (x *Customer2) GetMiscellaneous() *anypb.Any { + if x != nil { + return x.Miscellaneous + } + return nil +} + +type Nested4A struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id int32 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` +} + +func (x *Nested4A) Reset() { + *x = Nested4A{} + if protoimpl.UnsafeEnabled { + mi := &file_unknonwnproto_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Nested4A) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Nested4A) ProtoMessage() {} + +// Deprecated: Use Nested4A.ProtoReflect.Descriptor instead. +func (*Nested4A) Descriptor() ([]byte, []int) { + return file_unknonwnproto_proto_rawDescGZIP(), []int{2} +} + +func (x *Nested4A) GetId() int32 { + if x != nil { + return x.Id + } + return 0 +} + +func (x *Nested4A) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +type Nested3A struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id int32 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + A4 []*Nested4A `protobuf:"bytes,4,rep,name=a4,proto3" json:"a4,omitempty"` + Index map[int64]*Nested4A `protobuf:"bytes,5,rep,name=index,proto3" json:"index,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (x *Nested3A) Reset() { + *x = Nested3A{} + if protoimpl.UnsafeEnabled { + mi := &file_unknonwnproto_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Nested3A) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Nested3A) ProtoMessage() {} + +// Deprecated: Use Nested3A.ProtoReflect.Descriptor instead. +func (*Nested3A) Descriptor() ([]byte, []int) { + return file_unknonwnproto_proto_rawDescGZIP(), []int{3} +} + +func (x *Nested3A) GetId() int32 { + if x != nil { + return x.Id + } + return 0 +} + +func (x *Nested3A) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *Nested3A) GetA4() []*Nested4A { + if x != nil { + return x.A4 + } + return nil +} + +func (x *Nested3A) GetIndex() map[int64]*Nested4A { + if x != nil { + return x.Index + } + return nil +} + +type Nested2A struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id int32 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + Nested *Nested3A `protobuf:"bytes,3,opt,name=nested,proto3" json:"nested,omitempty"` +} + +func (x *Nested2A) Reset() { + *x = Nested2A{} + if protoimpl.UnsafeEnabled { + mi := &file_unknonwnproto_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Nested2A) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Nested2A) ProtoMessage() {} + +// Deprecated: Use Nested2A.ProtoReflect.Descriptor instead. +func (*Nested2A) Descriptor() ([]byte, []int) { + return file_unknonwnproto_proto_rawDescGZIP(), []int{4} +} + +func (x *Nested2A) GetId() int32 { + if x != nil { + return x.Id + } + return 0 +} + +func (x *Nested2A) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *Nested2A) GetNested() *Nested3A { + if x != nil { + return x.Nested + } + return nil +} + +type Nested1A struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id int32 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + Nested *Nested2A `protobuf:"bytes,2,opt,name=nested,proto3" json:"nested,omitempty"` +} + +func (x *Nested1A) Reset() { + *x = Nested1A{} + if protoimpl.UnsafeEnabled { + mi := &file_unknonwnproto_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Nested1A) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Nested1A) ProtoMessage() {} + +// Deprecated: Use Nested1A.ProtoReflect.Descriptor instead. +func (*Nested1A) Descriptor() ([]byte, []int) { + return file_unknonwnproto_proto_rawDescGZIP(), []int{5} +} + +func (x *Nested1A) GetId() int32 { + if x != nil { + return x.Id + } + return 0 +} + +func (x *Nested1A) GetNested() *Nested2A { + if x != nil { + return x.Nested + } + return nil +} + +type Nested4B struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id int32 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + Age int32 `protobuf:"varint,2,opt,name=age,proto3" json:"age,omitempty"` + Name string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"` +} + +func (x *Nested4B) Reset() { + *x = Nested4B{} + if protoimpl.UnsafeEnabled { + mi := &file_unknonwnproto_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Nested4B) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Nested4B) ProtoMessage() {} + +// Deprecated: Use Nested4B.ProtoReflect.Descriptor instead. +func (*Nested4B) Descriptor() ([]byte, []int) { + return file_unknonwnproto_proto_rawDescGZIP(), []int{6} +} + +func (x *Nested4B) GetId() int32 { + if x != nil { + return x.Id + } + return 0 +} + +func (x *Nested4B) GetAge() int32 { + if x != nil { + return x.Age + } + return 0 +} + +func (x *Nested4B) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +type Nested3B struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id int32 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + Age int32 `protobuf:"varint,2,opt,name=age,proto3" json:"age,omitempty"` + Name string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"` + B4 []*Nested4B `protobuf:"bytes,4,rep,name=b4,proto3" json:"b4,omitempty"` +} + +func (x *Nested3B) Reset() { + *x = Nested3B{} + if protoimpl.UnsafeEnabled { + mi := &file_unknonwnproto_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Nested3B) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Nested3B) ProtoMessage() {} + +// Deprecated: Use Nested3B.ProtoReflect.Descriptor instead. +func (*Nested3B) Descriptor() ([]byte, []int) { + return file_unknonwnproto_proto_rawDescGZIP(), []int{7} +} + +func (x *Nested3B) GetId() int32 { + if x != nil { + return x.Id + } + return 0 +} + +func (x *Nested3B) GetAge() int32 { + if x != nil { + return x.Age + } + return 0 +} + +func (x *Nested3B) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *Nested3B) GetB4() []*Nested4B { + if x != nil { + return x.B4 + } + return nil +} + +type Nested2B struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id int32 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + Fee float64 `protobuf:"fixed64,2,opt,name=fee,proto3" json:"fee,omitempty"` + Nested *Nested3B `protobuf:"bytes,3,opt,name=nested,proto3" json:"nested,omitempty"` + Route string `protobuf:"bytes,4,opt,name=route,proto3" json:"route,omitempty"` +} + +func (x *Nested2B) Reset() { + *x = Nested2B{} + if protoimpl.UnsafeEnabled { + mi := &file_unknonwnproto_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Nested2B) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Nested2B) ProtoMessage() {} + +// Deprecated: Use Nested2B.ProtoReflect.Descriptor instead. +func (*Nested2B) Descriptor() ([]byte, []int) { + return file_unknonwnproto_proto_rawDescGZIP(), []int{8} +} + +func (x *Nested2B) GetId() int32 { + if x != nil { + return x.Id + } + return 0 +} + +func (x *Nested2B) GetFee() float64 { + if x != nil { + return x.Fee + } + return 0 +} + +func (x *Nested2B) GetNested() *Nested3B { + if x != nil { + return x.Nested + } + return nil +} + +func (x *Nested2B) GetRoute() string { + if x != nil { + return x.Route + } + return "" +} + +type Nested1B struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id int32 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + Nested *Nested2B `protobuf:"bytes,2,opt,name=nested,proto3" json:"nested,omitempty"` + Age int32 `protobuf:"varint,3,opt,name=age,proto3" json:"age,omitempty"` +} + +func (x *Nested1B) Reset() { + *x = Nested1B{} + if protoimpl.UnsafeEnabled { + mi := &file_unknonwnproto_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Nested1B) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Nested1B) ProtoMessage() {} + +// Deprecated: Use Nested1B.ProtoReflect.Descriptor instead. +func (*Nested1B) Descriptor() ([]byte, []int) { + return file_unknonwnproto_proto_rawDescGZIP(), []int{9} +} + +func (x *Nested1B) GetId() int32 { + if x != nil { + return x.Id + } + return 0 +} + +func (x *Nested1B) GetNested() *Nested2B { + if x != nil { + return x.Nested + } + return nil +} + +func (x *Nested1B) GetAge() int32 { + if x != nil { + return x.Age + } + return 0 +} + +type Customer3 struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id int32 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + Sf float32 `protobuf:"fixed32,3,opt,name=sf,proto3" json:"sf,omitempty"` + Surcharge float32 `protobuf:"fixed32,4,opt,name=surcharge,proto3" json:"surcharge,omitempty"` + Destination string `protobuf:"bytes,5,opt,name=destination,proto3" json:"destination,omitempty"` + // Types that are assignable to Payment: + // + // *Customer3_CreditCardNo + // *Customer3_ChequeNo + Payment isCustomer3_Payment `protobuf_oneof:"payment"` + Original *Customer1 `protobuf:"bytes,9,opt,name=original,proto3" json:"original,omitempty"` +} + +func (x *Customer3) Reset() { + *x = Customer3{} + if protoimpl.UnsafeEnabled { + mi := &file_unknonwnproto_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Customer3) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Customer3) ProtoMessage() {} + +// Deprecated: Use Customer3.ProtoReflect.Descriptor instead. +func (*Customer3) Descriptor() ([]byte, []int) { + return file_unknonwnproto_proto_rawDescGZIP(), []int{10} +} + +func (x *Customer3) GetId() int32 { + if x != nil { + return x.Id + } + return 0 +} + +func (x *Customer3) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *Customer3) GetSf() float32 { + if x != nil { + return x.Sf + } + return 0 +} + +func (x *Customer3) GetSurcharge() float32 { + if x != nil { + return x.Surcharge + } + return 0 +} + +func (x *Customer3) GetDestination() string { + if x != nil { + return x.Destination + } + return "" +} + +func (x *Customer3) GetPayment() isCustomer3_Payment { + if x != nil { + return x.Payment + } + return nil +} + +func (x *Customer3) GetCreditCardNo() string { + if x, ok := x.GetPayment().(*Customer3_CreditCardNo); ok { + return x.CreditCardNo + } + return "" +} + +func (x *Customer3) GetChequeNo() string { + if x, ok := x.GetPayment().(*Customer3_ChequeNo); ok { + return x.ChequeNo + } + return "" +} + +func (x *Customer3) GetOriginal() *Customer1 { + if x != nil { + return x.Original + } + return nil +} + +type isCustomer3_Payment interface { + isCustomer3_Payment() +} + +type Customer3_CreditCardNo struct { + CreditCardNo string `protobuf:"bytes,7,opt,name=credit_card_no,json=creditCardNo,proto3,oneof"` +} + +type Customer3_ChequeNo struct { + ChequeNo string `protobuf:"bytes,8,opt,name=cheque_no,json=chequeNo,proto3,oneof"` +} + +func (*Customer3_CreditCardNo) isCustomer3_Payment() {} + +func (*Customer3_ChequeNo) isCustomer3_Payment() {} + +type TestVersion1 struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + X int64 `protobuf:"varint,1,opt,name=x,proto3" json:"x,omitempty"` + A *TestVersion1 `protobuf:"bytes,2,opt,name=a,proto3" json:"a,omitempty"` + B *TestVersion1 `protobuf:"bytes,3,opt,name=b,proto3" json:"b,omitempty"` // [(gogoproto.nullable) = false] generates invalid recursive structs; + C []*TestVersion1 `protobuf:"bytes,4,rep,name=c,proto3" json:"c,omitempty"` + D []*TestVersion1 `protobuf:"bytes,5,rep,name=d,proto3" json:"d,omitempty"` + // Types that are assignable to Sum: + // + // *TestVersion1_E + // *TestVersion1_F + Sum isTestVersion1_Sum `protobuf_oneof:"sum"` + G *anypb.Any `protobuf:"bytes,8,opt,name=g,proto3" json:"g,omitempty"` + H []*TestVersion1 `protobuf:"bytes,9,rep,name=h,proto3" json:"h,omitempty"` // [(gogoproto.castrepeated) = "TestVersion1"]; + // google.protobuf.Timestamp i = 10; + // google.protobuf.Timestamp j = 11; // [(gogoproto.stdtime) = true]; + K *Customer1 `protobuf:"bytes,12,opt,name=k,proto3" json:"k,omitempty"` +} + +func (x *TestVersion1) Reset() { + *x = TestVersion1{} + if protoimpl.UnsafeEnabled { + mi := &file_unknonwnproto_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TestVersion1) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TestVersion1) ProtoMessage() {} + +// Deprecated: Use TestVersion1.ProtoReflect.Descriptor instead. +func (*TestVersion1) Descriptor() ([]byte, []int) { + return file_unknonwnproto_proto_rawDescGZIP(), []int{11} +} + +func (x *TestVersion1) GetX() int64 { + if x != nil { + return x.X + } + return 0 +} + +func (x *TestVersion1) GetA() *TestVersion1 { + if x != nil { + return x.A + } + return nil +} + +func (x *TestVersion1) GetB() *TestVersion1 { + if x != nil { + return x.B + } + return nil +} + +func (x *TestVersion1) GetC() []*TestVersion1 { + if x != nil { + return x.C + } + return nil +} + +func (x *TestVersion1) GetD() []*TestVersion1 { + if x != nil { + return x.D + } + return nil +} + +func (x *TestVersion1) GetSum() isTestVersion1_Sum { + if x != nil { + return x.Sum + } + return nil +} + +func (x *TestVersion1) GetE() int32 { + if x, ok := x.GetSum().(*TestVersion1_E); ok { + return x.E + } + return 0 +} + +func (x *TestVersion1) GetF() *TestVersion1 { + if x, ok := x.GetSum().(*TestVersion1_F); ok { + return x.F + } + return nil +} + +func (x *TestVersion1) GetG() *anypb.Any { + if x != nil { + return x.G + } + return nil +} + +func (x *TestVersion1) GetH() []*TestVersion1 { + if x != nil { + return x.H + } + return nil +} + +func (x *TestVersion1) GetK() *Customer1 { + if x != nil { + return x.K + } + return nil +} + +type isTestVersion1_Sum interface { + isTestVersion1_Sum() +} + +type TestVersion1_E struct { + E int32 `protobuf:"varint,6,opt,name=e,proto3,oneof"` +} + +type TestVersion1_F struct { + F *TestVersion1 `protobuf:"bytes,7,opt,name=f,proto3,oneof"` +} + +func (*TestVersion1_E) isTestVersion1_Sum() {} + +func (*TestVersion1_F) isTestVersion1_Sum() {} + +type TestVersion2 struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + X int64 `protobuf:"varint,1,opt,name=x,proto3" json:"x,omitempty"` + A *TestVersion2 `protobuf:"bytes,2,opt,name=a,proto3" json:"a,omitempty"` + B *TestVersion2 `protobuf:"bytes,3,opt,name=b,proto3" json:"b,omitempty"` // [(gogoproto.nullable) = false]; + C []*TestVersion2 `protobuf:"bytes,4,rep,name=c,proto3" json:"c,omitempty"` + D []*TestVersion2 `protobuf:"bytes,5,rep,name=d,proto3" json:"d,omitempty"` // [(gogoproto.nullable) = false]; + // Types that are assignable to Sum: + // + // *TestVersion2_E + // *TestVersion2_F + Sum isTestVersion2_Sum `protobuf_oneof:"sum"` + G *anypb.Any `protobuf:"bytes,8,opt,name=g,proto3" json:"g,omitempty"` + H []*TestVersion1 `protobuf:"bytes,9,rep,name=h,proto3" json:"h,omitempty"` // [(gogoproto.castrepeated) = "TestVersion1"]; + // google.protobuf.Timestamp i = 10; + // google.protobuf.Timestamp j = 11; // [(gogoproto.stdtime) = true]; + K *Customer1 `protobuf:"bytes,12,opt,name=k,proto3" json:"k,omitempty"` + NewField_ uint64 `protobuf:"varint,25,opt,name=new_field,json=newField,proto3" json:"new_field,omitempty"` +} + +func (x *TestVersion2) Reset() { + *x = TestVersion2{} + if protoimpl.UnsafeEnabled { + mi := &file_unknonwnproto_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TestVersion2) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TestVersion2) ProtoMessage() {} + +// Deprecated: Use TestVersion2.ProtoReflect.Descriptor instead. +func (*TestVersion2) Descriptor() ([]byte, []int) { + return file_unknonwnproto_proto_rawDescGZIP(), []int{12} +} + +func (x *TestVersion2) GetX() int64 { + if x != nil { + return x.X + } + return 0 +} + +func (x *TestVersion2) GetA() *TestVersion2 { + if x != nil { + return x.A + } + return nil +} + +func (x *TestVersion2) GetB() *TestVersion2 { + if x != nil { + return x.B + } + return nil +} + +func (x *TestVersion2) GetC() []*TestVersion2 { + if x != nil { + return x.C + } + return nil +} + +func (x *TestVersion2) GetD() []*TestVersion2 { + if x != nil { + return x.D + } + return nil +} + +func (x *TestVersion2) GetSum() isTestVersion2_Sum { + if x != nil { + return x.Sum + } + return nil +} + +func (x *TestVersion2) GetE() int32 { + if x, ok := x.GetSum().(*TestVersion2_E); ok { + return x.E + } + return 0 +} + +func (x *TestVersion2) GetF() *TestVersion2 { + if x, ok := x.GetSum().(*TestVersion2_F); ok { + return x.F + } + return nil +} + +func (x *TestVersion2) GetG() *anypb.Any { + if x != nil { + return x.G + } + return nil +} + +func (x *TestVersion2) GetH() []*TestVersion1 { + if x != nil { + return x.H + } + return nil +} + +func (x *TestVersion2) GetK() *Customer1 { + if x != nil { + return x.K + } + return nil +} + +func (x *TestVersion2) GetNewField_() uint64 { + if x != nil { + return x.NewField_ + } + return 0 +} + +type isTestVersion2_Sum interface { + isTestVersion2_Sum() +} + +type TestVersion2_E struct { + E int32 `protobuf:"varint,6,opt,name=e,proto3,oneof"` +} + +type TestVersion2_F struct { + F *TestVersion2 `protobuf:"bytes,7,opt,name=f,proto3,oneof"` +} + +func (*TestVersion2_E) isTestVersion2_Sum() {} + +func (*TestVersion2_F) isTestVersion2_Sum() {} + +type TestVersion3 struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + X int64 `protobuf:"varint,1,opt,name=x,proto3" json:"x,omitempty"` + A *TestVersion3 `protobuf:"bytes,2,opt,name=a,proto3" json:"a,omitempty"` + B *TestVersion3 `protobuf:"bytes,3,opt,name=b,proto3" json:"b,omitempty"` // [(gogoproto.nullable) = false]; + C []*TestVersion3 `protobuf:"bytes,4,rep,name=c,proto3" json:"c,omitempty"` + D []*TestVersion3 `protobuf:"bytes,5,rep,name=d,proto3" json:"d,omitempty"` // [(gogoproto.nullable) = false]; + // Types that are assignable to Sum: + // + // *TestVersion3_E + // *TestVersion3_F + Sum isTestVersion3_Sum `protobuf_oneof:"sum"` + G *anypb.Any `protobuf:"bytes,8,opt,name=g,proto3" json:"g,omitempty"` + H []*TestVersion1 `protobuf:"bytes,9,rep,name=h,proto3" json:"h,omitempty"` //[(gogoproto.castrepeated) = "TestVersion1"]; + // google.protobuf.Timestamp i = 10; + // google.protobuf.Timestamp j = 11; // [(gogoproto.stdtime) = true]; + K *Customer1 `protobuf:"bytes,12,opt,name=k,proto3" json:"k,omitempty"` + NonCriticalField string `protobuf:"bytes,1031,opt,name=non_critical_field,json=nonCriticalField,proto3" json:"non_critical_field,omitempty"` +} + +func (x *TestVersion3) Reset() { + *x = TestVersion3{} + if protoimpl.UnsafeEnabled { + mi := &file_unknonwnproto_proto_msgTypes[13] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TestVersion3) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TestVersion3) ProtoMessage() {} + +// Deprecated: Use TestVersion3.ProtoReflect.Descriptor instead. +func (*TestVersion3) Descriptor() ([]byte, []int) { + return file_unknonwnproto_proto_rawDescGZIP(), []int{13} +} + +func (x *TestVersion3) GetX() int64 { + if x != nil { + return x.X + } + return 0 +} + +func (x *TestVersion3) GetA() *TestVersion3 { + if x != nil { + return x.A + } + return nil +} + +func (x *TestVersion3) GetB() *TestVersion3 { + if x != nil { + return x.B + } + return nil +} + +func (x *TestVersion3) GetC() []*TestVersion3 { + if x != nil { + return x.C + } + return nil +} + +func (x *TestVersion3) GetD() []*TestVersion3 { + if x != nil { + return x.D + } + return nil +} + +func (x *TestVersion3) GetSum() isTestVersion3_Sum { + if x != nil { + return x.Sum + } + return nil +} + +func (x *TestVersion3) GetE() int32 { + if x, ok := x.GetSum().(*TestVersion3_E); ok { + return x.E + } + return 0 +} + +func (x *TestVersion3) GetF() *TestVersion3 { + if x, ok := x.GetSum().(*TestVersion3_F); ok { + return x.F + } + return nil +} + +func (x *TestVersion3) GetG() *anypb.Any { + if x != nil { + return x.G + } + return nil +} + +func (x *TestVersion3) GetH() []*TestVersion1 { + if x != nil { + return x.H + } + return nil +} + +func (x *TestVersion3) GetK() *Customer1 { + if x != nil { + return x.K + } + return nil +} + +func (x *TestVersion3) GetNonCriticalField() string { + if x != nil { + return x.NonCriticalField + } + return "" +} + +type isTestVersion3_Sum interface { + isTestVersion3_Sum() +} + +type TestVersion3_E struct { + E int32 `protobuf:"varint,6,opt,name=e,proto3,oneof"` +} + +type TestVersion3_F struct { + F *TestVersion3 `protobuf:"bytes,7,opt,name=f,proto3,oneof"` +} + +func (*TestVersion3_E) isTestVersion3_Sum() {} + +func (*TestVersion3_F) isTestVersion3_Sum() {} + +type TestVersion3LoneOneOfValue struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + X int64 `protobuf:"varint,1,opt,name=x,proto3" json:"x,omitempty"` + A *TestVersion3 `protobuf:"bytes,2,opt,name=a,proto3" json:"a,omitempty"` + B *TestVersion3 `protobuf:"bytes,3,opt,name=b,proto3" json:"b,omitempty"` // [(gogoproto.nullable) = false]; + C []*TestVersion3 `protobuf:"bytes,4,rep,name=c,proto3" json:"c,omitempty"` + D []*TestVersion3 `protobuf:"bytes,5,rep,name=d,proto3" json:"d,omitempty"` // [(gogoproto.nullable) = false]; + // Types that are assignable to Sum: + // + // *TestVersion3LoneOneOfValue_E + Sum isTestVersion3LoneOneOfValue_Sum `protobuf_oneof:"sum"` + G *anypb.Any `protobuf:"bytes,8,opt,name=g,proto3" json:"g,omitempty"` + H []*TestVersion1 `protobuf:"bytes,9,rep,name=h,proto3" json:"h,omitempty"` //[(gogoproto.castrepeated) = "TestVersion1"]; + // google.protobuf.Timestamp i = 10; + // google.protobuf.Timestamp j = 11; // [(gogoproto.stdtime) = true]; + K *Customer1 `protobuf:"bytes,12,opt,name=k,proto3" json:"k,omitempty"` + NonCriticalField string `protobuf:"bytes,1031,opt,name=non_critical_field,json=nonCriticalField,proto3" json:"non_critical_field,omitempty"` +} + +func (x *TestVersion3LoneOneOfValue) Reset() { + *x = TestVersion3LoneOneOfValue{} + if protoimpl.UnsafeEnabled { + mi := &file_unknonwnproto_proto_msgTypes[14] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TestVersion3LoneOneOfValue) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TestVersion3LoneOneOfValue) ProtoMessage() {} + +// Deprecated: Use TestVersion3LoneOneOfValue.ProtoReflect.Descriptor instead. +func (*TestVersion3LoneOneOfValue) Descriptor() ([]byte, []int) { + return file_unknonwnproto_proto_rawDescGZIP(), []int{14} +} + +func (x *TestVersion3LoneOneOfValue) GetX() int64 { + if x != nil { + return x.X + } + return 0 +} + +func (x *TestVersion3LoneOneOfValue) GetA() *TestVersion3 { + if x != nil { + return x.A + } + return nil +} + +func (x *TestVersion3LoneOneOfValue) GetB() *TestVersion3 { + if x != nil { + return x.B + } + return nil +} + +func (x *TestVersion3LoneOneOfValue) GetC() []*TestVersion3 { + if x != nil { + return x.C + } + return nil +} + +func (x *TestVersion3LoneOneOfValue) GetD() []*TestVersion3 { + if x != nil { + return x.D + } + return nil +} + +func (x *TestVersion3LoneOneOfValue) GetSum() isTestVersion3LoneOneOfValue_Sum { + if x != nil { + return x.Sum + } + return nil +} + +func (x *TestVersion3LoneOneOfValue) GetE() int32 { + if x, ok := x.GetSum().(*TestVersion3LoneOneOfValue_E); ok { + return x.E + } + return 0 +} + +func (x *TestVersion3LoneOneOfValue) GetG() *anypb.Any { + if x != nil { + return x.G + } + return nil +} + +func (x *TestVersion3LoneOneOfValue) GetH() []*TestVersion1 { + if x != nil { + return x.H + } + return nil +} + +func (x *TestVersion3LoneOneOfValue) GetK() *Customer1 { + if x != nil { + return x.K + } + return nil +} + +func (x *TestVersion3LoneOneOfValue) GetNonCriticalField() string { + if x != nil { + return x.NonCriticalField + } + return "" +} + +type isTestVersion3LoneOneOfValue_Sum interface { + isTestVersion3LoneOneOfValue_Sum() +} + +type TestVersion3LoneOneOfValue_E struct { + E int32 `protobuf:"varint,6,opt,name=e,proto3,oneof"` +} + +func (*TestVersion3LoneOneOfValue_E) isTestVersion3LoneOneOfValue_Sum() {} + +type TestVersion3LoneNesting struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + X int64 `protobuf:"varint,1,opt,name=x,proto3" json:"x,omitempty"` + A *TestVersion3 `protobuf:"bytes,2,opt,name=a,proto3" json:"a,omitempty"` + B *TestVersion3 `protobuf:"bytes,3,opt,name=b,proto3" json:"b,omitempty"` // [(gogoproto.nullable) = false]; + C []*TestVersion3 `protobuf:"bytes,4,rep,name=c,proto3" json:"c,omitempty"` + D []*TestVersion3 `protobuf:"bytes,5,rep,name=d,proto3" json:"d,omitempty"` // [(gogoproto.nullable) = false]; + // Types that are assignable to Sum: + // + // *TestVersion3LoneNesting_F + Sum isTestVersion3LoneNesting_Sum `protobuf_oneof:"sum"` + G *anypb.Any `protobuf:"bytes,8,opt,name=g,proto3" json:"g,omitempty"` + H []*TestVersion1 `protobuf:"bytes,9,rep,name=h,proto3" json:"h,omitempty"` //[(gogoproto.castrepeated) = "TestVersion1"]; + // google.protobuf.Timestamp i = 10; + // google.protobuf.Timestamp j = 11; // [(gogoproto.stdtime) = true]; + K *Customer1 `protobuf:"bytes,12,opt,name=k,proto3" json:"k,omitempty"` + NonCriticalField string `protobuf:"bytes,1031,opt,name=non_critical_field,json=nonCriticalField,proto3" json:"non_critical_field,omitempty"` + Inner1 *TestVersion3LoneNesting_Inner1 `protobuf:"bytes,14,opt,name=inner1,proto3" json:"inner1,omitempty"` + Inner2 *TestVersion3LoneNesting_Inner2 `protobuf:"bytes,15,opt,name=inner2,proto3" json:"inner2,omitempty"` +} + +func (x *TestVersion3LoneNesting) Reset() { + *x = TestVersion3LoneNesting{} + if protoimpl.UnsafeEnabled { + mi := &file_unknonwnproto_proto_msgTypes[15] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TestVersion3LoneNesting) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TestVersion3LoneNesting) ProtoMessage() {} + +// Deprecated: Use TestVersion3LoneNesting.ProtoReflect.Descriptor instead. +func (*TestVersion3LoneNesting) Descriptor() ([]byte, []int) { + return file_unknonwnproto_proto_rawDescGZIP(), []int{15} +} + +func (x *TestVersion3LoneNesting) GetX() int64 { + if x != nil { + return x.X + } + return 0 +} + +func (x *TestVersion3LoneNesting) GetA() *TestVersion3 { + if x != nil { + return x.A + } + return nil +} + +func (x *TestVersion3LoneNesting) GetB() *TestVersion3 { + if x != nil { + return x.B + } + return nil +} + +func (x *TestVersion3LoneNesting) GetC() []*TestVersion3 { + if x != nil { + return x.C + } + return nil +} + +func (x *TestVersion3LoneNesting) GetD() []*TestVersion3 { + if x != nil { + return x.D + } + return nil +} + +func (x *TestVersion3LoneNesting) GetSum() isTestVersion3LoneNesting_Sum { + if x != nil { + return x.Sum + } + return nil +} + +func (x *TestVersion3LoneNesting) GetF() *TestVersion3LoneNesting { + if x, ok := x.GetSum().(*TestVersion3LoneNesting_F); ok { + return x.F + } + return nil +} + +func (x *TestVersion3LoneNesting) GetG() *anypb.Any { + if x != nil { + return x.G + } + return nil +} + +func (x *TestVersion3LoneNesting) GetH() []*TestVersion1 { + if x != nil { + return x.H + } + return nil +} + +func (x *TestVersion3LoneNesting) GetK() *Customer1 { + if x != nil { + return x.K + } + return nil +} + +func (x *TestVersion3LoneNesting) GetNonCriticalField() string { + if x != nil { + return x.NonCriticalField + } + return "" +} + +func (x *TestVersion3LoneNesting) GetInner1() *TestVersion3LoneNesting_Inner1 { + if x != nil { + return x.Inner1 + } + return nil +} + +func (x *TestVersion3LoneNesting) GetInner2() *TestVersion3LoneNesting_Inner2 { + if x != nil { + return x.Inner2 + } + return nil +} + +type isTestVersion3LoneNesting_Sum interface { + isTestVersion3LoneNesting_Sum() +} + +type TestVersion3LoneNesting_F struct { + F *TestVersion3LoneNesting `protobuf:"bytes,7,opt,name=f,proto3,oneof"` +} + +func (*TestVersion3LoneNesting_F) isTestVersion3LoneNesting_Sum() {} + +type TestVersion4LoneNesting struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + X int64 `protobuf:"varint,1,opt,name=x,proto3" json:"x,omitempty"` + A *TestVersion3 `protobuf:"bytes,2,opt,name=a,proto3" json:"a,omitempty"` + B *TestVersion3 `protobuf:"bytes,3,opt,name=b,proto3" json:"b,omitempty"` // [(gogoproto.nullable) = false]; + C []*TestVersion3 `protobuf:"bytes,4,rep,name=c,proto3" json:"c,omitempty"` + D []*TestVersion3 `protobuf:"bytes,5,rep,name=d,proto3" json:"d,omitempty"` // [(gogoproto.nullable) = false]; + // Types that are assignable to Sum: + // + // *TestVersion4LoneNesting_F + Sum isTestVersion4LoneNesting_Sum `protobuf_oneof:"sum"` + G *anypb.Any `protobuf:"bytes,8,opt,name=g,proto3" json:"g,omitempty"` + H []*TestVersion1 `protobuf:"bytes,9,rep,name=h,proto3" json:"h,omitempty"` //[(gogoproto.castrepeated) = "TestVersion1"]; + // google.protobuf.Timestamp i = 10; + // google.protobuf.Timestamp j = 11; // [(gogoproto.stdtime) = true]; + K *Customer1 `protobuf:"bytes,12,opt,name=k,proto3" json:"k,omitempty"` + NonCriticalField string `protobuf:"bytes,1031,opt,name=non_critical_field,json=nonCriticalField,proto3" json:"non_critical_field,omitempty"` + Inner1 *TestVersion4LoneNesting_Inner1 `protobuf:"bytes,14,opt,name=inner1,proto3" json:"inner1,omitempty"` + Inner2 *TestVersion4LoneNesting_Inner2 `protobuf:"bytes,15,opt,name=inner2,proto3" json:"inner2,omitempty"` +} + +func (x *TestVersion4LoneNesting) Reset() { + *x = TestVersion4LoneNesting{} + if protoimpl.UnsafeEnabled { + mi := &file_unknonwnproto_proto_msgTypes[16] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TestVersion4LoneNesting) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TestVersion4LoneNesting) ProtoMessage() {} + +// Deprecated: Use TestVersion4LoneNesting.ProtoReflect.Descriptor instead. +func (*TestVersion4LoneNesting) Descriptor() ([]byte, []int) { + return file_unknonwnproto_proto_rawDescGZIP(), []int{16} +} + +func (x *TestVersion4LoneNesting) GetX() int64 { + if x != nil { + return x.X + } + return 0 +} + +func (x *TestVersion4LoneNesting) GetA() *TestVersion3 { + if x != nil { + return x.A + } + return nil +} + +func (x *TestVersion4LoneNesting) GetB() *TestVersion3 { + if x != nil { + return x.B + } + return nil +} + +func (x *TestVersion4LoneNesting) GetC() []*TestVersion3 { + if x != nil { + return x.C + } + return nil +} + +func (x *TestVersion4LoneNesting) GetD() []*TestVersion3 { + if x != nil { + return x.D + } + return nil +} + +func (x *TestVersion4LoneNesting) GetSum() isTestVersion4LoneNesting_Sum { + if x != nil { + return x.Sum + } + return nil +} + +func (x *TestVersion4LoneNesting) GetF() *TestVersion3LoneNesting { + if x, ok := x.GetSum().(*TestVersion4LoneNesting_F); ok { + return x.F + } + return nil +} + +func (x *TestVersion4LoneNesting) GetG() *anypb.Any { + if x != nil { + return x.G + } + return nil +} + +func (x *TestVersion4LoneNesting) GetH() []*TestVersion1 { + if x != nil { + return x.H + } + return nil +} + +func (x *TestVersion4LoneNesting) GetK() *Customer1 { + if x != nil { + return x.K + } + return nil +} + +func (x *TestVersion4LoneNesting) GetNonCriticalField() string { + if x != nil { + return x.NonCriticalField + } + return "" +} + +func (x *TestVersion4LoneNesting) GetInner1() *TestVersion4LoneNesting_Inner1 { + if x != nil { + return x.Inner1 + } + return nil +} + +func (x *TestVersion4LoneNesting) GetInner2() *TestVersion4LoneNesting_Inner2 { + if x != nil { + return x.Inner2 + } + return nil +} + +type isTestVersion4LoneNesting_Sum interface { + isTestVersion4LoneNesting_Sum() +} + +type TestVersion4LoneNesting_F struct { + F *TestVersion3LoneNesting `protobuf:"bytes,7,opt,name=f,proto3,oneof"` +} + +func (*TestVersion4LoneNesting_F) isTestVersion4LoneNesting_Sum() {} + +type TestVersionFD1 struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + X int64 `protobuf:"varint,1,opt,name=x,proto3" json:"x,omitempty"` + A *TestVersion1 `protobuf:"bytes,2,opt,name=a,proto3" json:"a,omitempty"` + // Types that are assignable to Sum: + // + // *TestVersionFD1_E + // *TestVersionFD1_F + Sum isTestVersionFD1_Sum `protobuf_oneof:"sum"` + G *anypb.Any `protobuf:"bytes,8,opt,name=g,proto3" json:"g,omitempty"` + H []*TestVersion1 `protobuf:"bytes,9,rep,name=h,proto3" json:"h,omitempty"` // [(gogoproto.castrepeated) = "TestVersion1"]; +} + +func (x *TestVersionFD1) Reset() { + *x = TestVersionFD1{} + if protoimpl.UnsafeEnabled { + mi := &file_unknonwnproto_proto_msgTypes[17] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TestVersionFD1) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TestVersionFD1) ProtoMessage() {} + +// Deprecated: Use TestVersionFD1.ProtoReflect.Descriptor instead. +func (*TestVersionFD1) Descriptor() ([]byte, []int) { + return file_unknonwnproto_proto_rawDescGZIP(), []int{17} +} + +func (x *TestVersionFD1) GetX() int64 { + if x != nil { + return x.X + } + return 0 +} + +func (x *TestVersionFD1) GetA() *TestVersion1 { + if x != nil { + return x.A + } + return nil +} + +func (x *TestVersionFD1) GetSum() isTestVersionFD1_Sum { + if x != nil { + return x.Sum + } + return nil +} + +func (x *TestVersionFD1) GetE() int32 { + if x, ok := x.GetSum().(*TestVersionFD1_E); ok { + return x.E + } + return 0 +} + +func (x *TestVersionFD1) GetF() *TestVersion1 { + if x, ok := x.GetSum().(*TestVersionFD1_F); ok { + return x.F + } + return nil +} + +func (x *TestVersionFD1) GetG() *anypb.Any { + if x != nil { + return x.G + } + return nil +} + +func (x *TestVersionFD1) GetH() []*TestVersion1 { + if x != nil { + return x.H + } + return nil +} + +type isTestVersionFD1_Sum interface { + isTestVersionFD1_Sum() +} + +type TestVersionFD1_E struct { + E int32 `protobuf:"varint,6,opt,name=e,proto3,oneof"` +} + +type TestVersionFD1_F struct { + F *TestVersion1 `protobuf:"bytes,7,opt,name=f,proto3,oneof"` +} + +func (*TestVersionFD1_E) isTestVersionFD1_Sum() {} + +func (*TestVersionFD1_F) isTestVersionFD1_Sum() {} + +type TestVersionFD1WithExtraAny struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + X int64 `protobuf:"varint,1,opt,name=x,proto3" json:"x,omitempty"` + A *TestVersion1 `protobuf:"bytes,2,opt,name=a,proto3" json:"a,omitempty"` + // Types that are assignable to Sum: + // + // *TestVersionFD1WithExtraAny_E + // *TestVersionFD1WithExtraAny_F + Sum isTestVersionFD1WithExtraAny_Sum `protobuf_oneof:"sum"` + G *AnyWithExtra `protobuf:"bytes,8,opt,name=g,proto3" json:"g,omitempty"` + H []*TestVersion1 `protobuf:"bytes,9,rep,name=h,proto3" json:"h,omitempty"` // [(gogoproto.castrepeated) = "TestVersion1"]; +} + +func (x *TestVersionFD1WithExtraAny) Reset() { + *x = TestVersionFD1WithExtraAny{} + if protoimpl.UnsafeEnabled { + mi := &file_unknonwnproto_proto_msgTypes[18] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TestVersionFD1WithExtraAny) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TestVersionFD1WithExtraAny) ProtoMessage() {} + +// Deprecated: Use TestVersionFD1WithExtraAny.ProtoReflect.Descriptor instead. +func (*TestVersionFD1WithExtraAny) Descriptor() ([]byte, []int) { + return file_unknonwnproto_proto_rawDescGZIP(), []int{18} +} + +func (x *TestVersionFD1WithExtraAny) GetX() int64 { + if x != nil { + return x.X + } + return 0 +} + +func (x *TestVersionFD1WithExtraAny) GetA() *TestVersion1 { + if x != nil { + return x.A + } + return nil +} + +func (x *TestVersionFD1WithExtraAny) GetSum() isTestVersionFD1WithExtraAny_Sum { + if x != nil { + return x.Sum + } + return nil +} + +func (x *TestVersionFD1WithExtraAny) GetE() int32 { + if x, ok := x.GetSum().(*TestVersionFD1WithExtraAny_E); ok { + return x.E + } + return 0 +} + +func (x *TestVersionFD1WithExtraAny) GetF() *TestVersion1 { + if x, ok := x.GetSum().(*TestVersionFD1WithExtraAny_F); ok { + return x.F + } + return nil +} + +func (x *TestVersionFD1WithExtraAny) GetG() *AnyWithExtra { + if x != nil { + return x.G + } + return nil +} + +func (x *TestVersionFD1WithExtraAny) GetH() []*TestVersion1 { + if x != nil { + return x.H + } + return nil +} + +type isTestVersionFD1WithExtraAny_Sum interface { + isTestVersionFD1WithExtraAny_Sum() +} + +type TestVersionFD1WithExtraAny_E struct { + E int32 `protobuf:"varint,6,opt,name=e,proto3,oneof"` +} + +type TestVersionFD1WithExtraAny_F struct { + F *TestVersion1 `protobuf:"bytes,7,opt,name=f,proto3,oneof"` +} + +func (*TestVersionFD1WithExtraAny_E) isTestVersionFD1WithExtraAny_Sum() {} + +func (*TestVersionFD1WithExtraAny_F) isTestVersionFD1WithExtraAny_Sum() {} + +type AnyWithExtra struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + A *anypb.Any `protobuf:"bytes,1,opt,name=a,proto3" json:"a,omitempty"` + B int64 `protobuf:"varint,3,opt,name=b,proto3" json:"b,omitempty"` + C int64 `protobuf:"varint,4,opt,name=c,proto3" json:"c,omitempty"` +} + +func (x *AnyWithExtra) Reset() { + *x = AnyWithExtra{} + if protoimpl.UnsafeEnabled { + mi := &file_unknonwnproto_proto_msgTypes[19] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *AnyWithExtra) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AnyWithExtra) ProtoMessage() {} + +// Deprecated: Use AnyWithExtra.ProtoReflect.Descriptor instead. +func (*AnyWithExtra) Descriptor() ([]byte, []int) { + return file_unknonwnproto_proto_rawDescGZIP(), []int{19} +} + +func (x *AnyWithExtra) GetA() *anypb.Any { + if x != nil { + return x.A + } + return nil +} + +func (x *AnyWithExtra) GetB() int64 { + if x != nil { + return x.B + } + return 0 +} + +func (x *AnyWithExtra) GetC() int64 { + if x != nil { + return x.C + } + return 0 +} + +type TestUpdatedTxRaw struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + BodyBytes []byte `protobuf:"bytes,1,opt,name=body_bytes,json=bodyBytes,proto3" json:"body_bytes,omitempty"` + AuthInfoBytes []byte `protobuf:"bytes,2,opt,name=auth_info_bytes,json=authInfoBytes,proto3" json:"auth_info_bytes,omitempty"` + Signatures [][]byte `protobuf:"bytes,3,rep,name=signatures,proto3" json:"signatures,omitempty"` + NewField_5 []byte `protobuf:"bytes,5,opt,name=new_field_5,json=newField5,proto3" json:"new_field_5,omitempty"` + NewField_1024 []byte `protobuf:"bytes,1024,opt,name=new_field_1024,json=newField1024,proto3" json:"new_field_1024,omitempty"` +} + +func (x *TestUpdatedTxRaw) Reset() { + *x = TestUpdatedTxRaw{} + if protoimpl.UnsafeEnabled { + mi := &file_unknonwnproto_proto_msgTypes[20] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TestUpdatedTxRaw) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TestUpdatedTxRaw) ProtoMessage() {} + +// Deprecated: Use TestUpdatedTxRaw.ProtoReflect.Descriptor instead. +func (*TestUpdatedTxRaw) Descriptor() ([]byte, []int) { + return file_unknonwnproto_proto_rawDescGZIP(), []int{20} +} + +func (x *TestUpdatedTxRaw) GetBodyBytes() []byte { + if x != nil { + return x.BodyBytes + } + return nil +} + +func (x *TestUpdatedTxRaw) GetAuthInfoBytes() []byte { + if x != nil { + return x.AuthInfoBytes + } + return nil +} + +func (x *TestUpdatedTxRaw) GetSignatures() [][]byte { + if x != nil { + return x.Signatures + } + return nil +} + +func (x *TestUpdatedTxRaw) GetNewField_5() []byte { + if x != nil { + return x.NewField_5 + } + return nil +} + +func (x *TestUpdatedTxRaw) GetNewField_1024() []byte { + if x != nil { + return x.NewField_1024 + } + return nil +} + +type TestUpdatedTxBody struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Messages []*anypb.Any `protobuf:"bytes,1,rep,name=messages,proto3" json:"messages,omitempty"` + Memo string `protobuf:"bytes,2,opt,name=memo,proto3" json:"memo,omitempty"` + TimeoutHeight int64 `protobuf:"varint,3,opt,name=timeout_height,json=timeoutHeight,proto3" json:"timeout_height,omitempty"` + SomeNewField uint64 `protobuf:"varint,4,opt,name=some_new_field,json=someNewField,proto3" json:"some_new_field,omitempty"` + SomeNewFieldNonCriticalField string `protobuf:"bytes,1050,opt,name=some_new_field_non_critical_field,json=someNewFieldNonCriticalField,proto3" json:"some_new_field_non_critical_field,omitempty"` + ExtensionOptions []*anypb.Any `protobuf:"bytes,1023,rep,name=extension_options,json=extensionOptions,proto3" json:"extension_options,omitempty"` + NonCriticalExtensionOptions []*anypb.Any `protobuf:"bytes,2047,rep,name=non_critical_extension_options,json=nonCriticalExtensionOptions,proto3" json:"non_critical_extension_options,omitempty"` +} + +func (x *TestUpdatedTxBody) Reset() { + *x = TestUpdatedTxBody{} + if protoimpl.UnsafeEnabled { + mi := &file_unknonwnproto_proto_msgTypes[21] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TestUpdatedTxBody) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TestUpdatedTxBody) ProtoMessage() {} + +// Deprecated: Use TestUpdatedTxBody.ProtoReflect.Descriptor instead. +func (*TestUpdatedTxBody) Descriptor() ([]byte, []int) { + return file_unknonwnproto_proto_rawDescGZIP(), []int{21} +} + +func (x *TestUpdatedTxBody) GetMessages() []*anypb.Any { + if x != nil { + return x.Messages + } + return nil +} + +func (x *TestUpdatedTxBody) GetMemo() string { + if x != nil { + return x.Memo + } + return "" +} + +func (x *TestUpdatedTxBody) GetTimeoutHeight() int64 { + if x != nil { + return x.TimeoutHeight + } + return 0 +} + +func (x *TestUpdatedTxBody) GetSomeNewField() uint64 { + if x != nil { + return x.SomeNewField + } + return 0 +} + +func (x *TestUpdatedTxBody) GetSomeNewFieldNonCriticalField() string { + if x != nil { + return x.SomeNewFieldNonCriticalField + } + return "" +} + +func (x *TestUpdatedTxBody) GetExtensionOptions() []*anypb.Any { + if x != nil { + return x.ExtensionOptions + } + return nil +} + +func (x *TestUpdatedTxBody) GetNonCriticalExtensionOptions() []*anypb.Any { + if x != nil { + return x.NonCriticalExtensionOptions + } + return nil +} + +type TestUpdatedAuthInfo struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + SignerInfos []*v1beta1.SignerInfo `protobuf:"bytes,1,rep,name=signer_infos,json=signerInfos,proto3" json:"signer_infos,omitempty"` + Fee *v1beta1.Fee `protobuf:"bytes,2,opt,name=fee,proto3" json:"fee,omitempty"` + NewField_3 []byte `protobuf:"bytes,3,opt,name=new_field_3,json=newField3,proto3" json:"new_field_3,omitempty"` + NewField_1024 []byte `protobuf:"bytes,1024,opt,name=new_field_1024,json=newField1024,proto3" json:"new_field_1024,omitempty"` +} + +func (x *TestUpdatedAuthInfo) Reset() { + *x = TestUpdatedAuthInfo{} + if protoimpl.UnsafeEnabled { + mi := &file_unknonwnproto_proto_msgTypes[22] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TestUpdatedAuthInfo) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TestUpdatedAuthInfo) ProtoMessage() {} + +// Deprecated: Use TestUpdatedAuthInfo.ProtoReflect.Descriptor instead. +func (*TestUpdatedAuthInfo) Descriptor() ([]byte, []int) { + return file_unknonwnproto_proto_rawDescGZIP(), []int{22} +} + +func (x *TestUpdatedAuthInfo) GetSignerInfos() []*v1beta1.SignerInfo { + if x != nil { + return x.SignerInfos + } + return nil +} + +func (x *TestUpdatedAuthInfo) GetFee() *v1beta1.Fee { + if x != nil { + return x.Fee + } + return nil +} + +func (x *TestUpdatedAuthInfo) GetNewField_3() []byte { + if x != nil { + return x.NewField_3 + } + return nil +} + +func (x *TestUpdatedAuthInfo) GetNewField_1024() []byte { + if x != nil { + return x.NewField_1024 + } + return nil +} + +type TestRepeatedUints struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Nums []uint64 `protobuf:"varint,1,rep,packed,name=nums,proto3" json:"nums,omitempty"` +} + +func (x *TestRepeatedUints) Reset() { + *x = TestRepeatedUints{} + if protoimpl.UnsafeEnabled { + mi := &file_unknonwnproto_proto_msgTypes[23] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TestRepeatedUints) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TestRepeatedUints) ProtoMessage() {} + +// Deprecated: Use TestRepeatedUints.ProtoReflect.Descriptor instead. +func (*TestRepeatedUints) Descriptor() ([]byte, []int) { + return file_unknonwnproto_proto_rawDescGZIP(), []int{23} +} + +func (x *TestRepeatedUints) GetNums() []uint64 { + if x != nil { + return x.Nums + } + return nil +} + +type TestVersion3LoneNesting_Inner1 struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + Inner *TestVersion3LoneNesting_Inner1_InnerInner `protobuf:"bytes,3,opt,name=inner,proto3" json:"inner,omitempty"` +} + +func (x *TestVersion3LoneNesting_Inner1) Reset() { + *x = TestVersion3LoneNesting_Inner1{} + if protoimpl.UnsafeEnabled { + mi := &file_unknonwnproto_proto_msgTypes[25] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TestVersion3LoneNesting_Inner1) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TestVersion3LoneNesting_Inner1) ProtoMessage() {} + +// Deprecated: Use TestVersion3LoneNesting_Inner1.ProtoReflect.Descriptor instead. +func (*TestVersion3LoneNesting_Inner1) Descriptor() ([]byte, []int) { + return file_unknonwnproto_proto_rawDescGZIP(), []int{15, 0} +} + +func (x *TestVersion3LoneNesting_Inner1) GetId() int64 { + if x != nil { + return x.Id + } + return 0 +} + +func (x *TestVersion3LoneNesting_Inner1) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *TestVersion3LoneNesting_Inner1) GetInner() *TestVersion3LoneNesting_Inner1_InnerInner { + if x != nil { + return x.Inner + } + return nil +} + +type TestVersion3LoneNesting_Inner2 struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Country string `protobuf:"bytes,2,opt,name=country,proto3" json:"country,omitempty"` + Inner *TestVersion3LoneNesting_Inner2_InnerInner `protobuf:"bytes,3,opt,name=inner,proto3" json:"inner,omitempty"` +} + +func (x *TestVersion3LoneNesting_Inner2) Reset() { + *x = TestVersion3LoneNesting_Inner2{} + if protoimpl.UnsafeEnabled { + mi := &file_unknonwnproto_proto_msgTypes[26] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TestVersion3LoneNesting_Inner2) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TestVersion3LoneNesting_Inner2) ProtoMessage() {} + +// Deprecated: Use TestVersion3LoneNesting_Inner2.ProtoReflect.Descriptor instead. +func (*TestVersion3LoneNesting_Inner2) Descriptor() ([]byte, []int) { + return file_unknonwnproto_proto_rawDescGZIP(), []int{15, 1} +} + +func (x *TestVersion3LoneNesting_Inner2) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *TestVersion3LoneNesting_Inner2) GetCountry() string { + if x != nil { + return x.Country + } + return "" +} + +func (x *TestVersion3LoneNesting_Inner2) GetInner() *TestVersion3LoneNesting_Inner2_InnerInner { + if x != nil { + return x.Inner + } + return nil +} + +type TestVersion3LoneNesting_Inner1_InnerInner struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + City string `protobuf:"bytes,2,opt,name=city,proto3" json:"city,omitempty"` +} + +func (x *TestVersion3LoneNesting_Inner1_InnerInner) Reset() { + *x = TestVersion3LoneNesting_Inner1_InnerInner{} + if protoimpl.UnsafeEnabled { + mi := &file_unknonwnproto_proto_msgTypes[27] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TestVersion3LoneNesting_Inner1_InnerInner) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TestVersion3LoneNesting_Inner1_InnerInner) ProtoMessage() {} + +// Deprecated: Use TestVersion3LoneNesting_Inner1_InnerInner.ProtoReflect.Descriptor instead. +func (*TestVersion3LoneNesting_Inner1_InnerInner) Descriptor() ([]byte, []int) { + return file_unknonwnproto_proto_rawDescGZIP(), []int{15, 0, 0} +} + +func (x *TestVersion3LoneNesting_Inner1_InnerInner) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *TestVersion3LoneNesting_Inner1_InnerInner) GetCity() string { + if x != nil { + return x.City + } + return "" +} + +type TestVersion3LoneNesting_Inner2_InnerInner struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + City string `protobuf:"bytes,2,opt,name=city,proto3" json:"city,omitempty"` +} + +func (x *TestVersion3LoneNesting_Inner2_InnerInner) Reset() { + *x = TestVersion3LoneNesting_Inner2_InnerInner{} + if protoimpl.UnsafeEnabled { + mi := &file_unknonwnproto_proto_msgTypes[28] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TestVersion3LoneNesting_Inner2_InnerInner) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TestVersion3LoneNesting_Inner2_InnerInner) ProtoMessage() {} + +// Deprecated: Use TestVersion3LoneNesting_Inner2_InnerInner.ProtoReflect.Descriptor instead. +func (*TestVersion3LoneNesting_Inner2_InnerInner) Descriptor() ([]byte, []int) { + return file_unknonwnproto_proto_rawDescGZIP(), []int{15, 1, 0} +} + +func (x *TestVersion3LoneNesting_Inner2_InnerInner) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *TestVersion3LoneNesting_Inner2_InnerInner) GetCity() string { + if x != nil { + return x.City + } + return "" +} + +type TestVersion4LoneNesting_Inner1 struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + Inner *TestVersion4LoneNesting_Inner1_InnerInner `protobuf:"bytes,3,opt,name=inner,proto3" json:"inner,omitempty"` +} + +func (x *TestVersion4LoneNesting_Inner1) Reset() { + *x = TestVersion4LoneNesting_Inner1{} + if protoimpl.UnsafeEnabled { + mi := &file_unknonwnproto_proto_msgTypes[29] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TestVersion4LoneNesting_Inner1) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TestVersion4LoneNesting_Inner1) ProtoMessage() {} + +// Deprecated: Use TestVersion4LoneNesting_Inner1.ProtoReflect.Descriptor instead. +func (*TestVersion4LoneNesting_Inner1) Descriptor() ([]byte, []int) { + return file_unknonwnproto_proto_rawDescGZIP(), []int{16, 0} +} + +func (x *TestVersion4LoneNesting_Inner1) GetId() int64 { + if x != nil { + return x.Id + } + return 0 +} + +func (x *TestVersion4LoneNesting_Inner1) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *TestVersion4LoneNesting_Inner1) GetInner() *TestVersion4LoneNesting_Inner1_InnerInner { + if x != nil { + return x.Inner + } + return nil +} + +type TestVersion4LoneNesting_Inner2 struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Country string `protobuf:"bytes,2,opt,name=country,proto3" json:"country,omitempty"` + Inner *TestVersion4LoneNesting_Inner2_InnerInner `protobuf:"bytes,3,opt,name=inner,proto3" json:"inner,omitempty"` +} + +func (x *TestVersion4LoneNesting_Inner2) Reset() { + *x = TestVersion4LoneNesting_Inner2{} + if protoimpl.UnsafeEnabled { + mi := &file_unknonwnproto_proto_msgTypes[30] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TestVersion4LoneNesting_Inner2) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TestVersion4LoneNesting_Inner2) ProtoMessage() {} + +// Deprecated: Use TestVersion4LoneNesting_Inner2.ProtoReflect.Descriptor instead. +func (*TestVersion4LoneNesting_Inner2) Descriptor() ([]byte, []int) { + return file_unknonwnproto_proto_rawDescGZIP(), []int{16, 1} +} + +func (x *TestVersion4LoneNesting_Inner2) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *TestVersion4LoneNesting_Inner2) GetCountry() string { + if x != nil { + return x.Country + } + return "" +} + +func (x *TestVersion4LoneNesting_Inner2) GetInner() *TestVersion4LoneNesting_Inner2_InnerInner { + if x != nil { + return x.Inner + } + return nil +} + +type TestVersion4LoneNesting_Inner1_InnerInner struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + City string `protobuf:"bytes,2,opt,name=city,proto3" json:"city,omitempty"` +} + +func (x *TestVersion4LoneNesting_Inner1_InnerInner) Reset() { + *x = TestVersion4LoneNesting_Inner1_InnerInner{} + if protoimpl.UnsafeEnabled { + mi := &file_unknonwnproto_proto_msgTypes[31] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TestVersion4LoneNesting_Inner1_InnerInner) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TestVersion4LoneNesting_Inner1_InnerInner) ProtoMessage() {} + +// Deprecated: Use TestVersion4LoneNesting_Inner1_InnerInner.ProtoReflect.Descriptor instead. +func (*TestVersion4LoneNesting_Inner1_InnerInner) Descriptor() ([]byte, []int) { + return file_unknonwnproto_proto_rawDescGZIP(), []int{16, 0, 0} +} + +func (x *TestVersion4LoneNesting_Inner1_InnerInner) GetId() int64 { + if x != nil { + return x.Id + } + return 0 +} + +func (x *TestVersion4LoneNesting_Inner1_InnerInner) GetCity() string { + if x != nil { + return x.City + } + return "" +} + +type TestVersion4LoneNesting_Inner2_InnerInner struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Value int64 `protobuf:"varint,2,opt,name=value,proto3" json:"value,omitempty"` +} + +func (x *TestVersion4LoneNesting_Inner2_InnerInner) Reset() { + *x = TestVersion4LoneNesting_Inner2_InnerInner{} + if protoimpl.UnsafeEnabled { + mi := &file_unknonwnproto_proto_msgTypes[32] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TestVersion4LoneNesting_Inner2_InnerInner) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TestVersion4LoneNesting_Inner2_InnerInner) ProtoMessage() {} + +// Deprecated: Use TestVersion4LoneNesting_Inner2_InnerInner.ProtoReflect.Descriptor instead. +func (*TestVersion4LoneNesting_Inner2_InnerInner) Descriptor() ([]byte, []int) { + return file_unknonwnproto_proto_rawDescGZIP(), []int{16, 1, 0} +} + +func (x *TestVersion4LoneNesting_Inner2_InnerInner) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *TestVersion4LoneNesting_Inner2_InnerInner) GetValue() int64 { + if x != nil { + return x.Value + } + return 0 +} + +var File_unknonwnproto_proto protoreflect.FileDescriptor + +var file_unknonwnproto_proto_rawDesc = []byte{ + 0x0a, 0x13, 0x75, 0x6e, 0x6b, 0x6e, 0x6f, 0x6e, 0x77, 0x6e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x06, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x1a, 0x14, 0x67, + 0x6f, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x1a, 0x19, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x61, 0x6e, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1a, + 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x74, 0x78, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, + 0x31, 0x2f, 0x74, 0x78, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x74, 0x0a, 0x09, 0x43, 0x75, + 0x73, 0x74, 0x6f, 0x6d, 0x65, 0x72, 0x31, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x05, 0x52, 0x02, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x29, 0x0a, 0x10, 0x73, + 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x66, 0x65, 0x65, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0f, 0x73, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, + 0x69, 0x6f, 0x6e, 0x46, 0x65, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, + 0x74, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, + 0x22, 0xaf, 0x02, 0x0a, 0x09, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x65, 0x72, 0x32, 0x12, 0x0e, + 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x69, 0x64, 0x12, 0x1a, + 0x0a, 0x08, 0x69, 0x6e, 0x64, 0x75, 0x73, 0x74, 0x72, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, + 0x52, 0x08, 0x69, 0x6e, 0x64, 0x75, 0x73, 0x74, 0x72, 0x79, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, + 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x14, + 0x0a, 0x05, 0x66, 0x65, 0x77, 0x65, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x02, 0x52, 0x05, 0x66, + 0x65, 0x77, 0x65, 0x72, 0x12, 0x1b, 0x0a, 0x08, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, + 0x18, 0x97, 0x08, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, + 0x64, 0x12, 0x2a, 0x0a, 0x04, 0x63, 0x69, 0x74, 0x79, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0e, 0x32, + 0x16, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x65, + 0x72, 0x32, 0x2e, 0x43, 0x69, 0x74, 0x79, 0x52, 0x04, 0x63, 0x69, 0x74, 0x79, 0x12, 0x3a, 0x0a, + 0x0d, 0x6d, 0x69, 0x73, 0x63, 0x65, 0x6c, 0x6c, 0x61, 0x6e, 0x65, 0x6f, 0x75, 0x73, 0x18, 0x0a, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x41, 0x6e, 0x79, 0x52, 0x0d, 0x6d, 0x69, 0x73, 0x63, + 0x65, 0x6c, 0x6c, 0x61, 0x6e, 0x65, 0x6f, 0x75, 0x73, 0x22, 0x47, 0x0a, 0x04, 0x43, 0x69, 0x74, + 0x79, 0x12, 0x08, 0x0a, 0x04, 0x4c, 0x61, 0x6f, 0x73, 0x10, 0x00, 0x12, 0x0e, 0x0a, 0x0a, 0x4c, + 0x6f, 0x73, 0x41, 0x6e, 0x67, 0x65, 0x6c, 0x65, 0x73, 0x10, 0x01, 0x12, 0x0c, 0x0a, 0x08, 0x50, + 0x61, 0x6c, 0x6f, 0x41, 0x6c, 0x74, 0x6f, 0x10, 0x02, 0x12, 0x0a, 0x0a, 0x06, 0x4d, 0x6f, 0x73, + 0x63, 0x6f, 0x77, 0x10, 0x03, 0x12, 0x0b, 0x0a, 0x07, 0x4e, 0x61, 0x69, 0x72, 0x6f, 0x62, 0x69, + 0x10, 0x04, 0x22, 0x2e, 0x0a, 0x08, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x34, 0x41, 0x12, 0x0e, + 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x69, 0x64, 0x12, 0x12, + 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, + 0x6d, 0x65, 0x22, 0xcf, 0x01, 0x0a, 0x08, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x33, 0x41, 0x12, + 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x69, 0x64, 0x12, + 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, + 0x61, 0x6d, 0x65, 0x12, 0x20, 0x0a, 0x02, 0x61, 0x34, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x10, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x34, + 0x41, 0x52, 0x02, 0x61, 0x34, 0x12, 0x31, 0x0a, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x05, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x4e, 0x65, + 0x73, 0x74, 0x65, 0x64, 0x33, 0x41, 0x2e, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x45, 0x6e, 0x74, 0x72, + 0x79, 0x52, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x1a, 0x4a, 0x0a, 0x0a, 0x49, 0x6e, 0x64, 0x65, + 0x78, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x26, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, + 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x34, 0x41, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, + 0x3a, 0x02, 0x38, 0x01, 0x22, 0x58, 0x0a, 0x08, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x32, 0x41, + 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x69, 0x64, + 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, + 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x28, 0x0a, 0x06, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x4e, 0x65, + 0x73, 0x74, 0x65, 0x64, 0x33, 0x41, 0x52, 0x06, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x22, 0x44, + 0x0a, 0x08, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x31, 0x41, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x69, 0x64, 0x12, 0x28, 0x0a, 0x06, 0x6e, 0x65, + 0x73, 0x74, 0x65, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x74, 0x65, 0x73, + 0x74, 0x70, 0x62, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x32, 0x41, 0x52, 0x06, 0x6e, 0x65, + 0x73, 0x74, 0x65, 0x64, 0x22, 0x40, 0x0a, 0x08, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x34, 0x42, + 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x69, 0x64, + 0x12, 0x10, 0x0a, 0x03, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x61, + 0x67, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x62, 0x0a, 0x08, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, + 0x33, 0x42, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, + 0x69, 0x64, 0x12, 0x10, 0x0a, 0x03, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, + 0x03, 0x61, 0x67, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x20, 0x0a, 0x02, 0x62, 0x34, 0x18, 0x04, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x4e, 0x65, + 0x73, 0x74, 0x65, 0x64, 0x34, 0x42, 0x52, 0x02, 0x62, 0x34, 0x22, 0x6c, 0x0a, 0x08, 0x4e, 0x65, + 0x73, 0x74, 0x65, 0x64, 0x32, 0x42, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x05, 0x52, 0x02, 0x69, 0x64, 0x12, 0x10, 0x0a, 0x03, 0x66, 0x65, 0x65, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x01, 0x52, 0x03, 0x66, 0x65, 0x65, 0x12, 0x28, 0x0a, 0x06, 0x6e, 0x65, 0x73, 0x74, + 0x65, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, + 0x62, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x33, 0x42, 0x52, 0x06, 0x6e, 0x65, 0x73, 0x74, + 0x65, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x05, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x22, 0x56, 0x0a, 0x08, 0x4e, 0x65, 0x73, 0x74, + 0x65, 0x64, 0x31, 0x42, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, + 0x52, 0x02, 0x69, 0x64, 0x12, 0x28, 0x0a, 0x06, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x4e, 0x65, + 0x73, 0x74, 0x65, 0x64, 0x32, 0x42, 0x52, 0x06, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x12, 0x10, + 0x0a, 0x03, 0x61, 0x67, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x61, 0x67, 0x65, + 0x22, 0x80, 0x02, 0x0a, 0x09, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x65, 0x72, 0x33, 0x12, 0x0e, + 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x69, 0x64, 0x12, 0x12, + 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, + 0x6d, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x73, 0x66, 0x18, 0x03, 0x20, 0x01, 0x28, 0x02, 0x52, 0x02, + 0x73, 0x66, 0x12, 0x1c, 0x0a, 0x09, 0x73, 0x75, 0x72, 0x63, 0x68, 0x61, 0x72, 0x67, 0x65, 0x18, + 0x04, 0x20, 0x01, 0x28, 0x02, 0x52, 0x09, 0x73, 0x75, 0x72, 0x63, 0x68, 0x61, 0x72, 0x67, 0x65, + 0x12, 0x20, 0x0a, 0x0b, 0x64, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, + 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x64, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x12, 0x26, 0x0a, 0x0e, 0x63, 0x72, 0x65, 0x64, 0x69, 0x74, 0x5f, 0x63, 0x61, 0x72, + 0x64, 0x5f, 0x6e, 0x6f, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0c, 0x63, 0x72, + 0x65, 0x64, 0x69, 0x74, 0x43, 0x61, 0x72, 0x64, 0x4e, 0x6f, 0x12, 0x1d, 0x0a, 0x09, 0x63, 0x68, + 0x65, 0x71, 0x75, 0x65, 0x5f, 0x6e, 0x6f, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, + 0x08, 0x63, 0x68, 0x65, 0x71, 0x75, 0x65, 0x4e, 0x6f, 0x12, 0x2d, 0x0a, 0x08, 0x6f, 0x72, 0x69, + 0x67, 0x69, 0x6e, 0x61, 0x6c, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x74, 0x65, + 0x73, 0x74, 0x70, 0x62, 0x2e, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x65, 0x72, 0x31, 0x52, 0x08, + 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x6c, 0x42, 0x09, 0x0a, 0x07, 0x70, 0x61, 0x79, 0x6d, + 0x65, 0x6e, 0x74, 0x22, 0xde, 0x02, 0x0a, 0x0c, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, + 0x69, 0x6f, 0x6e, 0x31, 0x12, 0x0c, 0x0a, 0x01, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, + 0x01, 0x78, 0x12, 0x22, 0x0a, 0x01, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, + 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, + 0x6f, 0x6e, 0x31, 0x52, 0x01, 0x61, 0x12, 0x22, 0x0a, 0x01, 0x62, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, + 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x31, 0x52, 0x01, 0x62, 0x12, 0x22, 0x0a, 0x01, 0x63, 0x18, + 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, + 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x31, 0x52, 0x01, 0x63, 0x12, 0x28, + 0x0a, 0x01, 0x64, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, + 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x31, 0x42, + 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x01, 0x64, 0x12, 0x0e, 0x0a, 0x01, 0x65, 0x18, 0x06, 0x20, + 0x01, 0x28, 0x05, 0x48, 0x00, 0x52, 0x01, 0x65, 0x12, 0x24, 0x0a, 0x01, 0x66, 0x18, 0x07, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, + 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x31, 0x48, 0x00, 0x52, 0x01, 0x66, 0x12, 0x22, + 0x0a, 0x01, 0x67, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x6f, 0x6f, 0x67, + 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x41, 0x6e, 0x79, 0x52, + 0x01, 0x67, 0x12, 0x22, 0x0a, 0x01, 0x68, 0x18, 0x09, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, + 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, + 0x6f, 0x6e, 0x31, 0x52, 0x01, 0x68, 0x12, 0x25, 0x0a, 0x01, 0x6b, 0x18, 0x0c, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x11, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x43, 0x75, 0x73, 0x74, 0x6f, + 0x6d, 0x65, 0x72, 0x31, 0x42, 0x04, 0xd0, 0xde, 0x1f, 0x01, 0x52, 0x01, 0x6b, 0x42, 0x05, 0x0a, + 0x03, 0x73, 0x75, 0x6d, 0x22, 0xf5, 0x02, 0x0a, 0x0c, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, + 0x73, 0x69, 0x6f, 0x6e, 0x32, 0x12, 0x0c, 0x0a, 0x01, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, + 0x52, 0x01, 0x78, 0x12, 0x22, 0x0a, 0x01, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, + 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, + 0x69, 0x6f, 0x6e, 0x32, 0x52, 0x01, 0x61, 0x12, 0x22, 0x0a, 0x01, 0x62, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, + 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x32, 0x52, 0x01, 0x62, 0x12, 0x22, 0x0a, 0x01, 0x63, + 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, + 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x32, 0x52, 0x01, 0x63, 0x12, + 0x22, 0x0a, 0x01, 0x64, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, + 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x32, + 0x52, 0x01, 0x64, 0x12, 0x0e, 0x0a, 0x01, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x48, 0x00, + 0x52, 0x01, 0x65, 0x12, 0x24, 0x0a, 0x01, 0x66, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, + 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, + 0x69, 0x6f, 0x6e, 0x32, 0x48, 0x00, 0x52, 0x01, 0x66, 0x12, 0x22, 0x0a, 0x01, 0x67, 0x18, 0x08, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x41, 0x6e, 0x79, 0x52, 0x01, 0x67, 0x12, 0x22, 0x0a, + 0x01, 0x68, 0x18, 0x09, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, + 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x31, 0x52, 0x01, + 0x68, 0x12, 0x25, 0x0a, 0x01, 0x6b, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x74, + 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x65, 0x72, 0x31, 0x42, + 0x04, 0xd0, 0xde, 0x1f, 0x01, 0x52, 0x01, 0x6b, 0x12, 0x1b, 0x0a, 0x09, 0x6e, 0x65, 0x77, 0x5f, + 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x19, 0x20, 0x01, 0x28, 0x04, 0x52, 0x08, 0x6e, 0x65, 0x77, + 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42, 0x05, 0x0a, 0x03, 0x73, 0x75, 0x6d, 0x22, 0x87, 0x03, 0x0a, + 0x0c, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x33, 0x12, 0x0c, 0x0a, + 0x01, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x01, 0x78, 0x12, 0x22, 0x0a, 0x01, 0x61, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, + 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x33, 0x52, 0x01, 0x61, 0x12, + 0x22, 0x0a, 0x01, 0x62, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, + 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x33, + 0x52, 0x01, 0x62, 0x12, 0x22, 0x0a, 0x01, 0x63, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, + 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, + 0x69, 0x6f, 0x6e, 0x33, 0x52, 0x01, 0x63, 0x12, 0x22, 0x0a, 0x01, 0x64, 0x18, 0x05, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, + 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x33, 0x52, 0x01, 0x64, 0x12, 0x0e, 0x0a, 0x01, 0x65, + 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x48, 0x00, 0x52, 0x01, 0x65, 0x12, 0x24, 0x0a, 0x01, 0x66, + 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, + 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x33, 0x48, 0x00, 0x52, 0x01, + 0x66, 0x12, 0x22, 0x0a, 0x01, 0x67, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, + 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x41, + 0x6e, 0x79, 0x52, 0x01, 0x67, 0x12, 0x22, 0x0a, 0x01, 0x68, 0x18, 0x09, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, + 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x31, 0x52, 0x01, 0x68, 0x12, 0x25, 0x0a, 0x01, 0x6b, 0x18, 0x0c, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x43, 0x75, + 0x73, 0x74, 0x6f, 0x6d, 0x65, 0x72, 0x31, 0x42, 0x04, 0xd0, 0xde, 0x1f, 0x01, 0x52, 0x01, 0x6b, + 0x12, 0x2d, 0x0a, 0x12, 0x6e, 0x6f, 0x6e, 0x5f, 0x63, 0x72, 0x69, 0x74, 0x69, 0x63, 0x61, 0x6c, + 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x87, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x6e, + 0x6f, 0x6e, 0x43, 0x72, 0x69, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42, + 0x05, 0x0a, 0x03, 0x73, 0x75, 0x6d, 0x22, 0xef, 0x02, 0x0a, 0x1a, 0x54, 0x65, 0x73, 0x74, 0x56, + 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x33, 0x4c, 0x6f, 0x6e, 0x65, 0x4f, 0x6e, 0x65, 0x4f, 0x66, + 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x0c, 0x0a, 0x01, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, + 0x52, 0x01, 0x78, 0x12, 0x22, 0x0a, 0x01, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, + 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, + 0x69, 0x6f, 0x6e, 0x33, 0x52, 0x01, 0x61, 0x12, 0x22, 0x0a, 0x01, 0x62, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, + 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x33, 0x52, 0x01, 0x62, 0x12, 0x22, 0x0a, 0x01, 0x63, + 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, + 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x33, 0x52, 0x01, 0x63, 0x12, + 0x22, 0x0a, 0x01, 0x64, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, + 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x33, + 0x52, 0x01, 0x64, 0x12, 0x0e, 0x0a, 0x01, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x48, 0x00, + 0x52, 0x01, 0x65, 0x12, 0x22, 0x0a, 0x01, 0x67, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, + 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, + 0x2e, 0x41, 0x6e, 0x79, 0x52, 0x01, 0x67, 0x12, 0x22, 0x0a, 0x01, 0x68, 0x18, 0x09, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, + 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x31, 0x52, 0x01, 0x68, 0x12, 0x25, 0x0a, 0x01, 0x6b, + 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, + 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x65, 0x72, 0x31, 0x42, 0x04, 0xd0, 0xde, 0x1f, 0x01, 0x52, + 0x01, 0x6b, 0x12, 0x2d, 0x0a, 0x12, 0x6e, 0x6f, 0x6e, 0x5f, 0x63, 0x72, 0x69, 0x74, 0x69, 0x63, + 0x61, 0x6c, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x87, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x10, 0x6e, 0x6f, 0x6e, 0x43, 0x72, 0x69, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x46, 0x69, 0x65, 0x6c, + 0x64, 0x42, 0x05, 0x0a, 0x03, 0x73, 0x75, 0x6d, 0x22, 0xe7, 0x06, 0x0a, 0x17, 0x54, 0x65, 0x73, + 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x33, 0x4c, 0x6f, 0x6e, 0x65, 0x4e, 0x65, 0x73, + 0x74, 0x69, 0x6e, 0x67, 0x12, 0x0c, 0x0a, 0x01, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, + 0x01, 0x78, 0x12, 0x22, 0x0a, 0x01, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, + 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, + 0x6f, 0x6e, 0x33, 0x52, 0x01, 0x61, 0x12, 0x22, 0x0a, 0x01, 0x62, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, + 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x33, 0x52, 0x01, 0x62, 0x12, 0x22, 0x0a, 0x01, 0x63, 0x18, + 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, + 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x33, 0x52, 0x01, 0x63, 0x12, 0x22, + 0x0a, 0x01, 0x64, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, + 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x33, 0x52, + 0x01, 0x64, 0x12, 0x2f, 0x0a, 0x01, 0x66, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, + 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, + 0x6f, 0x6e, 0x33, 0x4c, 0x6f, 0x6e, 0x65, 0x4e, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x48, 0x00, + 0x52, 0x01, 0x66, 0x12, 0x22, 0x0a, 0x01, 0x67, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, + 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, + 0x2e, 0x41, 0x6e, 0x79, 0x52, 0x01, 0x67, 0x12, 0x22, 0x0a, 0x01, 0x68, 0x18, 0x09, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, + 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x31, 0x52, 0x01, 0x68, 0x12, 0x25, 0x0a, 0x01, 0x6b, + 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, + 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x65, 0x72, 0x31, 0x42, 0x04, 0xd0, 0xde, 0x1f, 0x01, 0x52, + 0x01, 0x6b, 0x12, 0x2d, 0x0a, 0x12, 0x6e, 0x6f, 0x6e, 0x5f, 0x63, 0x72, 0x69, 0x74, 0x69, 0x63, + 0x61, 0x6c, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x87, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x10, 0x6e, 0x6f, 0x6e, 0x43, 0x72, 0x69, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x46, 0x69, 0x65, 0x6c, + 0x64, 0x12, 0x3e, 0x0a, 0x06, 0x69, 0x6e, 0x6e, 0x65, 0x72, 0x31, 0x18, 0x0e, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x26, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, + 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x33, 0x4c, 0x6f, 0x6e, 0x65, 0x4e, 0x65, 0x73, 0x74, 0x69, + 0x6e, 0x67, 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x31, 0x52, 0x06, 0x69, 0x6e, 0x6e, 0x65, 0x72, + 0x31, 0x12, 0x3e, 0x0a, 0x06, 0x69, 0x6e, 0x6e, 0x65, 0x72, 0x32, 0x18, 0x0f, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x26, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, + 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x33, 0x4c, 0x6f, 0x6e, 0x65, 0x4e, 0x65, 0x73, 0x74, 0x69, + 0x6e, 0x67, 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x32, 0x52, 0x06, 0x69, 0x6e, 0x6e, 0x65, 0x72, + 0x32, 0x1a, 0xa7, 0x01, 0x0a, 0x06, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x31, 0x12, 0x0e, 0x0a, 0x02, + 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x02, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, + 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, + 0x12, 0x47, 0x0a, 0x05, 0x69, 0x6e, 0x6e, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x31, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, + 0x73, 0x69, 0x6f, 0x6e, 0x33, 0x4c, 0x6f, 0x6e, 0x65, 0x4e, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x67, + 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x31, 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x49, 0x6e, 0x6e, + 0x65, 0x72, 0x52, 0x05, 0x69, 0x6e, 0x6e, 0x65, 0x72, 0x1a, 0x30, 0x0a, 0x0a, 0x49, 0x6e, 0x6e, + 0x65, 0x72, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x63, 0x69, 0x74, 0x79, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x63, 0x69, 0x74, 0x79, 0x1a, 0xad, 0x01, 0x0a, 0x06, + 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x32, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x72, + 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x72, 0x79, + 0x12, 0x47, 0x0a, 0x05, 0x69, 0x6e, 0x6e, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x31, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, + 0x73, 0x69, 0x6f, 0x6e, 0x33, 0x4c, 0x6f, 0x6e, 0x65, 0x4e, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x67, + 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x32, 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x49, 0x6e, 0x6e, + 0x65, 0x72, 0x52, 0x05, 0x69, 0x6e, 0x6e, 0x65, 0x72, 0x1a, 0x30, 0x0a, 0x0a, 0x49, 0x6e, 0x6e, + 0x65, 0x72, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x63, 0x69, 0x74, 0x79, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x63, 0x69, 0x74, 0x79, 0x42, 0x05, 0x0a, 0x03, 0x73, + 0x75, 0x6d, 0x22, 0xe9, 0x06, 0x0a, 0x17, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, + 0x6f, 0x6e, 0x34, 0x4c, 0x6f, 0x6e, 0x65, 0x4e, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x12, 0x0c, + 0x0a, 0x01, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x01, 0x78, 0x12, 0x22, 0x0a, 0x01, + 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, + 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x33, 0x52, 0x01, 0x61, + 0x12, 0x22, 0x0a, 0x01, 0x62, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, + 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, + 0x33, 0x52, 0x01, 0x62, 0x12, 0x22, 0x0a, 0x01, 0x63, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, + 0x73, 0x69, 0x6f, 0x6e, 0x33, 0x52, 0x01, 0x63, 0x12, 0x22, 0x0a, 0x01, 0x64, 0x18, 0x05, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, + 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x33, 0x52, 0x01, 0x64, 0x12, 0x2f, 0x0a, 0x01, + 0x66, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, + 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x33, 0x4c, 0x6f, 0x6e, + 0x65, 0x4e, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x48, 0x00, 0x52, 0x01, 0x66, 0x12, 0x22, 0x0a, + 0x01, 0x67, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, + 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x41, 0x6e, 0x79, 0x52, 0x01, + 0x67, 0x12, 0x22, 0x0a, 0x01, 0x68, 0x18, 0x09, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, + 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, + 0x6e, 0x31, 0x52, 0x01, 0x68, 0x12, 0x25, 0x0a, 0x01, 0x6b, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x11, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, + 0x65, 0x72, 0x31, 0x42, 0x04, 0xd0, 0xde, 0x1f, 0x01, 0x52, 0x01, 0x6b, 0x12, 0x2d, 0x0a, 0x12, + 0x6e, 0x6f, 0x6e, 0x5f, 0x63, 0x72, 0x69, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x5f, 0x66, 0x69, 0x65, + 0x6c, 0x64, 0x18, 0x87, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x6e, 0x6f, 0x6e, 0x43, 0x72, + 0x69, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x3e, 0x0a, 0x06, 0x69, + 0x6e, 0x6e, 0x65, 0x72, 0x31, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x74, 0x65, + 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, + 0x34, 0x4c, 0x6f, 0x6e, 0x65, 0x4e, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x2e, 0x49, 0x6e, 0x6e, + 0x65, 0x72, 0x31, 0x52, 0x06, 0x69, 0x6e, 0x6e, 0x65, 0x72, 0x31, 0x12, 0x3e, 0x0a, 0x06, 0x69, + 0x6e, 0x6e, 0x65, 0x72, 0x32, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x74, 0x65, + 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, + 0x34, 0x4c, 0x6f, 0x6e, 0x65, 0x4e, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x2e, 0x49, 0x6e, 0x6e, + 0x65, 0x72, 0x32, 0x52, 0x06, 0x69, 0x6e, 0x6e, 0x65, 0x72, 0x32, 0x1a, 0xa7, 0x01, 0x0a, 0x06, + 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x31, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x03, 0x52, 0x02, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x47, 0x0a, 0x05, 0x69, 0x6e, + 0x6e, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x31, 0x2e, 0x74, 0x65, 0x73, 0x74, + 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x34, 0x4c, + 0x6f, 0x6e, 0x65, 0x4e, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, + 0x31, 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x52, 0x05, 0x69, 0x6e, + 0x6e, 0x65, 0x72, 0x1a, 0x30, 0x0a, 0x0a, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x49, 0x6e, 0x6e, 0x65, + 0x72, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x02, 0x69, + 0x64, 0x12, 0x12, 0x0a, 0x04, 0x63, 0x69, 0x74, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x04, 0x63, 0x69, 0x74, 0x79, 0x1a, 0xaf, 0x01, 0x0a, 0x06, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x32, + 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, + 0x12, 0x18, 0x0a, 0x07, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x72, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x07, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x47, 0x0a, 0x05, 0x69, 0x6e, + 0x6e, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x31, 0x2e, 0x74, 0x65, 0x73, 0x74, + 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x34, 0x4c, + 0x6f, 0x6e, 0x65, 0x4e, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, + 0x32, 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x52, 0x05, 0x69, 0x6e, + 0x6e, 0x65, 0x72, 0x1a, 0x32, 0x0a, 0x0a, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x49, 0x6e, 0x6e, 0x65, + 0x72, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, + 0x64, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, + 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x42, 0x05, 0x0a, 0x03, 0x73, 0x75, 0x6d, 0x22, 0xc7, + 0x01, 0x0a, 0x0e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x46, 0x44, + 0x31, 0x12, 0x0c, 0x0a, 0x01, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x01, 0x78, 0x12, + 0x22, 0x0a, 0x01, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, + 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x31, + 0x52, 0x01, 0x61, 0x12, 0x0e, 0x0a, 0x01, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x48, 0x00, + 0x52, 0x01, 0x65, 0x12, 0x24, 0x0a, 0x01, 0x66, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, + 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, + 0x69, 0x6f, 0x6e, 0x31, 0x48, 0x00, 0x52, 0x01, 0x66, 0x12, 0x22, 0x0a, 0x01, 0x67, 0x18, 0x08, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x41, 0x6e, 0x79, 0x52, 0x01, 0x67, 0x12, 0x22, 0x0a, + 0x01, 0x68, 0x18, 0x09, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, + 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x31, 0x52, 0x01, + 0x68, 0x42, 0x05, 0x0a, 0x03, 0x73, 0x75, 0x6d, 0x22, 0xd3, 0x01, 0x0a, 0x1a, 0x54, 0x65, 0x73, + 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x46, 0x44, 0x31, 0x57, 0x69, 0x74, 0x68, 0x45, + 0x78, 0x74, 0x72, 0x61, 0x41, 0x6e, 0x79, 0x12, 0x0c, 0x0a, 0x01, 0x78, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x03, 0x52, 0x01, 0x78, 0x12, 0x22, 0x0a, 0x01, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, + 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x31, 0x52, 0x01, 0x61, 0x12, 0x0e, 0x0a, 0x01, 0x65, 0x18, 0x06, + 0x20, 0x01, 0x28, 0x05, 0x48, 0x00, 0x52, 0x01, 0x65, 0x12, 0x24, 0x0a, 0x01, 0x66, 0x18, 0x07, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, + 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x31, 0x48, 0x00, 0x52, 0x01, 0x66, 0x12, + 0x22, 0x0a, 0x01, 0x67, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, + 0x74, 0x70, 0x62, 0x2e, 0x41, 0x6e, 0x79, 0x57, 0x69, 0x74, 0x68, 0x45, 0x78, 0x74, 0x72, 0x61, + 0x52, 0x01, 0x67, 0x12, 0x22, 0x0a, 0x01, 0x68, 0x18, 0x09, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, + 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, + 0x69, 0x6f, 0x6e, 0x31, 0x52, 0x01, 0x68, 0x42, 0x05, 0x0a, 0x03, 0x73, 0x75, 0x6d, 0x22, 0x54, + 0x0a, 0x0c, 0x41, 0x6e, 0x79, 0x57, 0x69, 0x74, 0x68, 0x45, 0x78, 0x74, 0x72, 0x61, 0x12, 0x28, + 0x0a, 0x01, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x6f, 0x6f, 0x67, + 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x41, 0x6e, 0x79, 0x42, + 0x04, 0xd0, 0xde, 0x1f, 0x01, 0x52, 0x01, 0x61, 0x12, 0x0c, 0x0a, 0x01, 0x62, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x03, 0x52, 0x01, 0x62, 0x12, 0x0c, 0x0a, 0x01, 0x63, 0x18, 0x04, 0x20, 0x01, 0x28, + 0x03, 0x52, 0x01, 0x63, 0x22, 0xc0, 0x01, 0x0a, 0x10, 0x54, 0x65, 0x73, 0x74, 0x55, 0x70, 0x64, + 0x61, 0x74, 0x65, 0x64, 0x54, 0x78, 0x52, 0x61, 0x77, 0x12, 0x1d, 0x0a, 0x0a, 0x62, 0x6f, 0x64, + 0x79, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x62, + 0x6f, 0x64, 0x79, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x26, 0x0a, 0x0f, 0x61, 0x75, 0x74, 0x68, + 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0c, 0x52, 0x0d, 0x61, 0x75, 0x74, 0x68, 0x49, 0x6e, 0x66, 0x6f, 0x42, 0x79, 0x74, 0x65, 0x73, + 0x12, 0x1e, 0x0a, 0x0a, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x18, 0x03, + 0x20, 0x03, 0x28, 0x0c, 0x52, 0x0a, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, + 0x12, 0x1e, 0x0a, 0x0b, 0x6e, 0x65, 0x77, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x5f, 0x35, 0x18, + 0x05, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x6e, 0x65, 0x77, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x35, + 0x12, 0x25, 0x0a, 0x0e, 0x6e, 0x65, 0x77, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x5f, 0x31, 0x30, + 0x32, 0x34, 0x18, 0x80, 0x08, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0c, 0x6e, 0x65, 0x77, 0x46, 0x69, + 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x34, 0x22, 0x90, 0x03, 0x0a, 0x11, 0x54, 0x65, 0x73, 0x74, + 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x54, 0x78, 0x42, 0x6f, 0x64, 0x79, 0x12, 0x30, 0x0a, + 0x08, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x14, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, + 0x66, 0x2e, 0x41, 0x6e, 0x79, 0x52, 0x08, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x12, + 0x12, 0x0a, 0x04, 0x6d, 0x65, 0x6d, 0x6f, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6d, + 0x65, 0x6d, 0x6f, 0x12, 0x25, 0x0a, 0x0e, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x5f, 0x68, + 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x74, 0x69, 0x6d, + 0x65, 0x6f, 0x75, 0x74, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x24, 0x0a, 0x0e, 0x73, 0x6f, + 0x6d, 0x65, 0x5f, 0x6e, 0x65, 0x77, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x04, 0x52, 0x0c, 0x73, 0x6f, 0x6d, 0x65, 0x4e, 0x65, 0x77, 0x46, 0x69, 0x65, 0x6c, 0x64, + 0x12, 0x48, 0x0a, 0x21, 0x73, 0x6f, 0x6d, 0x65, 0x5f, 0x6e, 0x65, 0x77, 0x5f, 0x66, 0x69, 0x65, + 0x6c, 0x64, 0x5f, 0x6e, 0x6f, 0x6e, 0x5f, 0x63, 0x72, 0x69, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x5f, + 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x9a, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x1c, 0x73, 0x6f, + 0x6d, 0x65, 0x4e, 0x65, 0x77, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e, 0x6f, 0x6e, 0x43, 0x72, 0x69, + 0x74, 0x69, 0x63, 0x61, 0x6c, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x42, 0x0a, 0x11, 0x65, 0x78, + 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, + 0xff, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x41, 0x6e, 0x79, 0x52, 0x10, 0x65, 0x78, + 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x5a, + 0x0a, 0x1e, 0x6e, 0x6f, 0x6e, 0x5f, 0x63, 0x72, 0x69, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x5f, 0x65, + 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x18, 0xff, 0x0f, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x41, 0x6e, 0x79, 0x52, 0x1b, 0x6e, + 0x6f, 0x6e, 0x43, 0x72, 0x69, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, + 0x69, 0x6f, 0x6e, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0xc8, 0x01, 0x0a, 0x13, 0x54, + 0x65, 0x73, 0x74, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x41, 0x75, 0x74, 0x68, 0x49, 0x6e, + 0x66, 0x6f, 0x12, 0x40, 0x0a, 0x0c, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x72, 0x5f, 0x69, 0x6e, 0x66, + 0x6f, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, + 0x73, 0x2e, 0x74, 0x78, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x53, 0x69, 0x67, + 0x6e, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0b, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x72, 0x49, + 0x6e, 0x66, 0x6f, 0x73, 0x12, 0x28, 0x0a, 0x03, 0x66, 0x65, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x16, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x74, 0x78, 0x2e, 0x76, 0x31, + 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x46, 0x65, 0x65, 0x52, 0x03, 0x66, 0x65, 0x65, 0x12, 0x1e, + 0x0a, 0x0b, 0x6e, 0x65, 0x77, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x5f, 0x33, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x0c, 0x52, 0x09, 0x6e, 0x65, 0x77, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x12, 0x25, + 0x0a, 0x0e, 0x6e, 0x65, 0x77, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x5f, 0x31, 0x30, 0x32, 0x34, + 0x18, 0x80, 0x08, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0c, 0x6e, 0x65, 0x77, 0x46, 0x69, 0x65, 0x6c, + 0x64, 0x31, 0x30, 0x32, 0x34, 0x22, 0x27, 0x0a, 0x11, 0x54, 0x65, 0x73, 0x74, 0x52, 0x65, 0x70, + 0x65, 0x61, 0x74, 0x65, 0x64, 0x55, 0x69, 0x6e, 0x74, 0x73, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x75, + 0x6d, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x04, 0x52, 0x04, 0x6e, 0x75, 0x6d, 0x73, 0x42, 0x83, + 0x01, 0x0a, 0x0a, 0x63, 0x6f, 0x6d, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x42, 0x12, 0x55, + 0x6e, 0x6b, 0x6e, 0x6f, 0x6e, 0x77, 0x6e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x72, 0x6f, 0x74, + 0x6f, 0x50, 0x01, 0x5a, 0x29, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, + 0x6f, 0x2f, 0x78, 0x2f, 0x74, 0x78, 0x2f, 0x74, 0x65, 0x78, 0x74, 0x75, 0x61, 0x6c, 0x2f, 0x69, + 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0xa2, 0x02, + 0x03, 0x54, 0x58, 0x58, 0xaa, 0x02, 0x06, 0x54, 0x65, 0x73, 0x74, 0x70, 0x62, 0xca, 0x02, 0x06, + 0x54, 0x65, 0x73, 0x74, 0x70, 0x62, 0xe2, 0x02, 0x12, 0x54, 0x65, 0x73, 0x74, 0x70, 0x62, 0x5c, + 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x06, 0x54, 0x65, + 0x73, 0x74, 0x70, 0x62, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_unknonwnproto_proto_rawDescOnce sync.Once + file_unknonwnproto_proto_rawDescData = file_unknonwnproto_proto_rawDesc +) + +func file_unknonwnproto_proto_rawDescGZIP() []byte { + file_unknonwnproto_proto_rawDescOnce.Do(func() { + file_unknonwnproto_proto_rawDescData = protoimpl.X.CompressGZIP(file_unknonwnproto_proto_rawDescData) + }) + return file_unknonwnproto_proto_rawDescData +} + +var file_unknonwnproto_proto_enumTypes = make([]protoimpl.EnumInfo, 1) +var file_unknonwnproto_proto_msgTypes = make([]protoimpl.MessageInfo, 33) +var file_unknonwnproto_proto_goTypes = []interface{}{ + (Customer2_City)(0), // 0: testpb.Customer2.City + (*Customer1)(nil), // 1: testpb.Customer1 + (*Customer2)(nil), // 2: testpb.Customer2 + (*Nested4A)(nil), // 3: testpb.Nested4A + (*Nested3A)(nil), // 4: testpb.Nested3A + (*Nested2A)(nil), // 5: testpb.Nested2A + (*Nested1A)(nil), // 6: testpb.Nested1A + (*Nested4B)(nil), // 7: testpb.Nested4B + (*Nested3B)(nil), // 8: testpb.Nested3B + (*Nested2B)(nil), // 9: testpb.Nested2B + (*Nested1B)(nil), // 10: testpb.Nested1B + (*Customer3)(nil), // 11: testpb.Customer3 + (*TestVersion1)(nil), // 12: testpb.TestVersion1 + (*TestVersion2)(nil), // 13: testpb.TestVersion2 + (*TestVersion3)(nil), // 14: testpb.TestVersion3 + (*TestVersion3LoneOneOfValue)(nil), // 15: testpb.TestVersion3LoneOneOfValue + (*TestVersion3LoneNesting)(nil), // 16: testpb.TestVersion3LoneNesting + (*TestVersion4LoneNesting)(nil), // 17: testpb.TestVersion4LoneNesting + (*TestVersionFD1)(nil), // 18: testpb.TestVersionFD1 + (*TestVersionFD1WithExtraAny)(nil), // 19: testpb.TestVersionFD1WithExtraAny + (*AnyWithExtra)(nil), // 20: testpb.AnyWithExtra + (*TestUpdatedTxRaw)(nil), // 21: testpb.TestUpdatedTxRaw + (*TestUpdatedTxBody)(nil), // 22: testpb.TestUpdatedTxBody + (*TestUpdatedAuthInfo)(nil), // 23: testpb.TestUpdatedAuthInfo + (*TestRepeatedUints)(nil), // 24: testpb.TestRepeatedUints + nil, // 25: testpb.Nested3A.IndexEntry + (*TestVersion3LoneNesting_Inner1)(nil), // 26: testpb.TestVersion3LoneNesting.Inner1 + (*TestVersion3LoneNesting_Inner2)(nil), // 27: testpb.TestVersion3LoneNesting.Inner2 + (*TestVersion3LoneNesting_Inner1_InnerInner)(nil), // 28: testpb.TestVersion3LoneNesting.Inner1.InnerInner + (*TestVersion3LoneNesting_Inner2_InnerInner)(nil), // 29: testpb.TestVersion3LoneNesting.Inner2.InnerInner + (*TestVersion4LoneNesting_Inner1)(nil), // 30: testpb.TestVersion4LoneNesting.Inner1 + (*TestVersion4LoneNesting_Inner2)(nil), // 31: testpb.TestVersion4LoneNesting.Inner2 + (*TestVersion4LoneNesting_Inner1_InnerInner)(nil), // 32: testpb.TestVersion4LoneNesting.Inner1.InnerInner + (*TestVersion4LoneNesting_Inner2_InnerInner)(nil), // 33: testpb.TestVersion4LoneNesting.Inner2.InnerInner + (*anypb.Any)(nil), // 34: google.protobuf.Any + (*v1beta1.SignerInfo)(nil), // 35: cosmos.tx.v1beta1.SignerInfo + (*v1beta1.Fee)(nil), // 36: cosmos.tx.v1beta1.Fee +} +var file_unknonwnproto_proto_depIdxs = []int32{ + 0, // 0: testpb.Customer2.city:type_name -> testpb.Customer2.City + 34, // 1: testpb.Customer2.miscellaneous:type_name -> google.protobuf.Any + 3, // 2: testpb.Nested3A.a4:type_name -> testpb.Nested4A + 25, // 3: testpb.Nested3A.index:type_name -> testpb.Nested3A.IndexEntry + 4, // 4: testpb.Nested2A.nested:type_name -> testpb.Nested3A + 5, // 5: testpb.Nested1A.nested:type_name -> testpb.Nested2A + 7, // 6: testpb.Nested3B.b4:type_name -> testpb.Nested4B + 8, // 7: testpb.Nested2B.nested:type_name -> testpb.Nested3B + 9, // 8: testpb.Nested1B.nested:type_name -> testpb.Nested2B + 1, // 9: testpb.Customer3.original:type_name -> testpb.Customer1 + 12, // 10: testpb.TestVersion1.a:type_name -> testpb.TestVersion1 + 12, // 11: testpb.TestVersion1.b:type_name -> testpb.TestVersion1 + 12, // 12: testpb.TestVersion1.c:type_name -> testpb.TestVersion1 + 12, // 13: testpb.TestVersion1.d:type_name -> testpb.TestVersion1 + 12, // 14: testpb.TestVersion1.f:type_name -> testpb.TestVersion1 + 34, // 15: testpb.TestVersion1.g:type_name -> google.protobuf.Any + 12, // 16: testpb.TestVersion1.h:type_name -> testpb.TestVersion1 + 1, // 17: testpb.TestVersion1.k:type_name -> testpb.Customer1 + 13, // 18: testpb.TestVersion2.a:type_name -> testpb.TestVersion2 + 13, // 19: testpb.TestVersion2.b:type_name -> testpb.TestVersion2 + 13, // 20: testpb.TestVersion2.c:type_name -> testpb.TestVersion2 + 13, // 21: testpb.TestVersion2.d:type_name -> testpb.TestVersion2 + 13, // 22: testpb.TestVersion2.f:type_name -> testpb.TestVersion2 + 34, // 23: testpb.TestVersion2.g:type_name -> google.protobuf.Any + 12, // 24: testpb.TestVersion2.h:type_name -> testpb.TestVersion1 + 1, // 25: testpb.TestVersion2.k:type_name -> testpb.Customer1 + 14, // 26: testpb.TestVersion3.a:type_name -> testpb.TestVersion3 + 14, // 27: testpb.TestVersion3.b:type_name -> testpb.TestVersion3 + 14, // 28: testpb.TestVersion3.c:type_name -> testpb.TestVersion3 + 14, // 29: testpb.TestVersion3.d:type_name -> testpb.TestVersion3 + 14, // 30: testpb.TestVersion3.f:type_name -> testpb.TestVersion3 + 34, // 31: testpb.TestVersion3.g:type_name -> google.protobuf.Any + 12, // 32: testpb.TestVersion3.h:type_name -> testpb.TestVersion1 + 1, // 33: testpb.TestVersion3.k:type_name -> testpb.Customer1 + 14, // 34: testpb.TestVersion3LoneOneOfValue.a:type_name -> testpb.TestVersion3 + 14, // 35: testpb.TestVersion3LoneOneOfValue.b:type_name -> testpb.TestVersion3 + 14, // 36: testpb.TestVersion3LoneOneOfValue.c:type_name -> testpb.TestVersion3 + 14, // 37: testpb.TestVersion3LoneOneOfValue.d:type_name -> testpb.TestVersion3 + 34, // 38: testpb.TestVersion3LoneOneOfValue.g:type_name -> google.protobuf.Any + 12, // 39: testpb.TestVersion3LoneOneOfValue.h:type_name -> testpb.TestVersion1 + 1, // 40: testpb.TestVersion3LoneOneOfValue.k:type_name -> testpb.Customer1 + 14, // 41: testpb.TestVersion3LoneNesting.a:type_name -> testpb.TestVersion3 + 14, // 42: testpb.TestVersion3LoneNesting.b:type_name -> testpb.TestVersion3 + 14, // 43: testpb.TestVersion3LoneNesting.c:type_name -> testpb.TestVersion3 + 14, // 44: testpb.TestVersion3LoneNesting.d:type_name -> testpb.TestVersion3 + 16, // 45: testpb.TestVersion3LoneNesting.f:type_name -> testpb.TestVersion3LoneNesting + 34, // 46: testpb.TestVersion3LoneNesting.g:type_name -> google.protobuf.Any + 12, // 47: testpb.TestVersion3LoneNesting.h:type_name -> testpb.TestVersion1 + 1, // 48: testpb.TestVersion3LoneNesting.k:type_name -> testpb.Customer1 + 26, // 49: testpb.TestVersion3LoneNesting.inner1:type_name -> testpb.TestVersion3LoneNesting.Inner1 + 27, // 50: testpb.TestVersion3LoneNesting.inner2:type_name -> testpb.TestVersion3LoneNesting.Inner2 + 14, // 51: testpb.TestVersion4LoneNesting.a:type_name -> testpb.TestVersion3 + 14, // 52: testpb.TestVersion4LoneNesting.b:type_name -> testpb.TestVersion3 + 14, // 53: testpb.TestVersion4LoneNesting.c:type_name -> testpb.TestVersion3 + 14, // 54: testpb.TestVersion4LoneNesting.d:type_name -> testpb.TestVersion3 + 16, // 55: testpb.TestVersion4LoneNesting.f:type_name -> testpb.TestVersion3LoneNesting + 34, // 56: testpb.TestVersion4LoneNesting.g:type_name -> google.protobuf.Any + 12, // 57: testpb.TestVersion4LoneNesting.h:type_name -> testpb.TestVersion1 + 1, // 58: testpb.TestVersion4LoneNesting.k:type_name -> testpb.Customer1 + 30, // 59: testpb.TestVersion4LoneNesting.inner1:type_name -> testpb.TestVersion4LoneNesting.Inner1 + 31, // 60: testpb.TestVersion4LoneNesting.inner2:type_name -> testpb.TestVersion4LoneNesting.Inner2 + 12, // 61: testpb.TestVersionFD1.a:type_name -> testpb.TestVersion1 + 12, // 62: testpb.TestVersionFD1.f:type_name -> testpb.TestVersion1 + 34, // 63: testpb.TestVersionFD1.g:type_name -> google.protobuf.Any + 12, // 64: testpb.TestVersionFD1.h:type_name -> testpb.TestVersion1 + 12, // 65: testpb.TestVersionFD1WithExtraAny.a:type_name -> testpb.TestVersion1 + 12, // 66: testpb.TestVersionFD1WithExtraAny.f:type_name -> testpb.TestVersion1 + 20, // 67: testpb.TestVersionFD1WithExtraAny.g:type_name -> testpb.AnyWithExtra + 12, // 68: testpb.TestVersionFD1WithExtraAny.h:type_name -> testpb.TestVersion1 + 34, // 69: testpb.AnyWithExtra.a:type_name -> google.protobuf.Any + 34, // 70: testpb.TestUpdatedTxBody.messages:type_name -> google.protobuf.Any + 34, // 71: testpb.TestUpdatedTxBody.extension_options:type_name -> google.protobuf.Any + 34, // 72: testpb.TestUpdatedTxBody.non_critical_extension_options:type_name -> google.protobuf.Any + 35, // 73: testpb.TestUpdatedAuthInfo.signer_infos:type_name -> cosmos.tx.v1beta1.SignerInfo + 36, // 74: testpb.TestUpdatedAuthInfo.fee:type_name -> cosmos.tx.v1beta1.Fee + 3, // 75: testpb.Nested3A.IndexEntry.value:type_name -> testpb.Nested4A + 28, // 76: testpb.TestVersion3LoneNesting.Inner1.inner:type_name -> testpb.TestVersion3LoneNesting.Inner1.InnerInner + 29, // 77: testpb.TestVersion3LoneNesting.Inner2.inner:type_name -> testpb.TestVersion3LoneNesting.Inner2.InnerInner + 32, // 78: testpb.TestVersion4LoneNesting.Inner1.inner:type_name -> testpb.TestVersion4LoneNesting.Inner1.InnerInner + 33, // 79: testpb.TestVersion4LoneNesting.Inner2.inner:type_name -> testpb.TestVersion4LoneNesting.Inner2.InnerInner + 80, // [80:80] is the sub-list for method output_type + 80, // [80:80] is the sub-list for method input_type + 80, // [80:80] is the sub-list for extension type_name + 80, // [80:80] is the sub-list for extension extendee + 0, // [0:80] is the sub-list for field type_name +} + +func init() { file_unknonwnproto_proto_init() } +func file_unknonwnproto_proto_init() { + if File_unknonwnproto_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_unknonwnproto_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Customer1); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_unknonwnproto_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Customer2); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_unknonwnproto_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Nested4A); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_unknonwnproto_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Nested3A); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_unknonwnproto_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Nested2A); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_unknonwnproto_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Nested1A); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_unknonwnproto_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Nested4B); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_unknonwnproto_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Nested3B); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_unknonwnproto_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Nested2B); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_unknonwnproto_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Nested1B); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_unknonwnproto_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Customer3); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_unknonwnproto_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TestVersion1); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_unknonwnproto_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TestVersion2); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_unknonwnproto_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TestVersion3); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_unknonwnproto_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TestVersion3LoneOneOfValue); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_unknonwnproto_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TestVersion3LoneNesting); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_unknonwnproto_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TestVersion4LoneNesting); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_unknonwnproto_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TestVersionFD1); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_unknonwnproto_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TestVersionFD1WithExtraAny); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_unknonwnproto_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*AnyWithExtra); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_unknonwnproto_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TestUpdatedTxRaw); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_unknonwnproto_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TestUpdatedTxBody); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_unknonwnproto_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TestUpdatedAuthInfo); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_unknonwnproto_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TestRepeatedUints); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_unknonwnproto_proto_msgTypes[25].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TestVersion3LoneNesting_Inner1); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_unknonwnproto_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TestVersion3LoneNesting_Inner2); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_unknonwnproto_proto_msgTypes[27].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TestVersion3LoneNesting_Inner1_InnerInner); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_unknonwnproto_proto_msgTypes[28].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TestVersion3LoneNesting_Inner2_InnerInner); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_unknonwnproto_proto_msgTypes[29].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TestVersion4LoneNesting_Inner1); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_unknonwnproto_proto_msgTypes[30].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TestVersion4LoneNesting_Inner2); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_unknonwnproto_proto_msgTypes[31].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TestVersion4LoneNesting_Inner1_InnerInner); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_unknonwnproto_proto_msgTypes[32].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TestVersion4LoneNesting_Inner2_InnerInner); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + file_unknonwnproto_proto_msgTypes[10].OneofWrappers = []interface{}{ + (*Customer3_CreditCardNo)(nil), + (*Customer3_ChequeNo)(nil), + } + file_unknonwnproto_proto_msgTypes[11].OneofWrappers = []interface{}{ + (*TestVersion1_E)(nil), + (*TestVersion1_F)(nil), + } + file_unknonwnproto_proto_msgTypes[12].OneofWrappers = []interface{}{ + (*TestVersion2_E)(nil), + (*TestVersion2_F)(nil), + } + file_unknonwnproto_proto_msgTypes[13].OneofWrappers = []interface{}{ + (*TestVersion3_E)(nil), + (*TestVersion3_F)(nil), + } + file_unknonwnproto_proto_msgTypes[14].OneofWrappers = []interface{}{ + (*TestVersion3LoneOneOfValue_E)(nil), + } + file_unknonwnproto_proto_msgTypes[15].OneofWrappers = []interface{}{ + (*TestVersion3LoneNesting_F)(nil), + } + file_unknonwnproto_proto_msgTypes[16].OneofWrappers = []interface{}{ + (*TestVersion4LoneNesting_F)(nil), + } + file_unknonwnproto_proto_msgTypes[17].OneofWrappers = []interface{}{ + (*TestVersionFD1_E)(nil), + (*TestVersionFD1_F)(nil), + } + file_unknonwnproto_proto_msgTypes[18].OneofWrappers = []interface{}{ + (*TestVersionFD1WithExtraAny_E)(nil), + (*TestVersionFD1WithExtraAny_F)(nil), + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_unknonwnproto_proto_rawDesc, + NumEnums: 1, + NumMessages: 33, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_unknonwnproto_proto_goTypes, + DependencyIndexes: file_unknonwnproto_proto_depIdxs, + EnumInfos: file_unknonwnproto_proto_enumTypes, + MessageInfos: file_unknonwnproto_proto_msgTypes, + }.Build() + File_unknonwnproto_proto = out.File + file_unknonwnproto_proto_rawDesc = nil + file_unknonwnproto_proto_goTypes = nil + file_unknonwnproto_proto_depIdxs = nil +}