| // Copyright 2024 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| // Code generated by protoc-gen-go. DO NOT EDIT. |
| // versions: |
| // protoc-gen-go v1.36.8 |
| // protoc v6.32.0 |
| // source: proto2test.proto |
| |
| package proto2test_go_proto |
| |
| import ( |
| protoreflect "google.golang.org/protobuf/reflect/protoreflect" |
| protoimpl "google.golang.org/protobuf/runtime/protoimpl" |
| _ "google.golang.org/protobuf/types/gofeaturespb" |
| emptypb "google.golang.org/protobuf/types/known/emptypb" |
| reflect "reflect" |
| sync "sync" |
| unsafe "unsafe" |
| ) |
| |
| 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 M2_Enum int32 |
| |
| const ( |
| M2_E_VAL M2_Enum = 0 |
| ) |
| |
| // Enum value maps for M2_Enum. |
| var ( |
| M2_Enum_name = map[int32]string{ |
| 0: "E_VAL", |
| } |
| M2_Enum_value = map[string]int32{ |
| "E_VAL": 0, |
| } |
| ) |
| |
| func (x M2_Enum) Enum() *M2_Enum { |
| p := new(M2_Enum) |
| *p = x |
| return p |
| } |
| |
| func (x M2_Enum) String() string { |
| return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) |
| } |
| |
| func (M2_Enum) Descriptor() protoreflect.EnumDescriptor { |
| return file_proto2test_proto_enumTypes[0].Descriptor() |
| } |
| |
| func (M2_Enum) Type() protoreflect.EnumType { |
| return &file_proto2test_proto_enumTypes[0] |
| } |
| |
| func (x M2_Enum) Number() protoreflect.EnumNumber { |
| return protoreflect.EnumNumber(x) |
| } |
| |
| // Deprecated: Use M2_Enum.Descriptor instead. |
| func (M2_Enum) EnumDescriptor() ([]byte, []int) { |
| return file_proto2test_proto_rawDescGZIP(), []int{1, 0} |
| } |
| |
| type OtherProto2_OtherEnum int32 |
| |
| const ( |
| OtherProto2_E_VAL OtherProto2_OtherEnum = 0 |
| ) |
| |
| // Enum value maps for OtherProto2_OtherEnum. |
| var ( |
| OtherProto2_OtherEnum_name = map[int32]string{ |
| 0: "E_VAL", |
| } |
| OtherProto2_OtherEnum_value = map[string]int32{ |
| "E_VAL": 0, |
| } |
| ) |
| |
| func (x OtherProto2_OtherEnum) Enum() *OtherProto2_OtherEnum { |
| p := new(OtherProto2_OtherEnum) |
| *p = x |
| return p |
| } |
| |
| func (x OtherProto2_OtherEnum) String() string { |
| return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) |
| } |
| |
| func (OtherProto2_OtherEnum) Descriptor() protoreflect.EnumDescriptor { |
| return file_proto2test_proto_enumTypes[1].Descriptor() |
| } |
| |
| func (OtherProto2_OtherEnum) Type() protoreflect.EnumType { |
| return &file_proto2test_proto_enumTypes[1] |
| } |
| |
| func (x OtherProto2_OtherEnum) Number() protoreflect.EnumNumber { |
| return protoreflect.EnumNumber(x) |
| } |
| |
| // Deprecated: Use OtherProto2_OtherEnum.Descriptor instead. |
| func (OtherProto2_OtherEnum) EnumDescriptor() ([]byte, []int) { |
| return file_proto2test_proto_rawDescGZIP(), []int{2, 0} |
| } |
| |
| type DoNotMigrateMe struct { |
| state protoimpl.MessageState `protogen:"open.v1"` |
| B *bool `protobuf:"varint,1,opt,name=b" json:"b,omitempty"` |
| unknownFields protoimpl.UnknownFields |
| sizeCache protoimpl.SizeCache |
| } |
| |
| func (x *DoNotMigrateMe) Reset() { |
| *x = DoNotMigrateMe{} |
| mi := &file_proto2test_proto_msgTypes[0] |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| ms.StoreMessageInfo(mi) |
| } |
| |
| func (x *DoNotMigrateMe) String() string { |
| return protoimpl.X.MessageStringOf(x) |
| } |
| |
| func (*DoNotMigrateMe) ProtoMessage() {} |
| |
| func (x *DoNotMigrateMe) ProtoReflect() protoreflect.Message { |
| mi := &file_proto2test_proto_msgTypes[0] |
| if x != nil { |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| if ms.LoadMessageInfo() == nil { |
| ms.StoreMessageInfo(mi) |
| } |
| return ms |
| } |
| return mi.MessageOf(x) |
| } |
| |
| // Deprecated: Use DoNotMigrateMe.ProtoReflect.Descriptor instead. |
| func (*DoNotMigrateMe) Descriptor() ([]byte, []int) { |
| return file_proto2test_proto_rawDescGZIP(), []int{0} |
| } |
| |
| func (x *DoNotMigrateMe) GetB() bool { |
| if x != nil && x.B != nil { |
| return *x.B |
| } |
| return false |
| } |
| |
| type M2 struct { |
| state protoimpl.MessageState `protogen:"hybrid.v1"` |
| B *bool `protobuf:"varint,1,opt,name=b" json:"b,omitempty"` |
| Bytes []byte `protobuf:"bytes,2,opt,name=bytes" json:"bytes,omitempty"` |
| F32 *float32 `protobuf:"fixed32,3,opt,name=f32" json:"f32,omitempty"` |
| F64 *float64 `protobuf:"fixed64,4,opt,name=f64" json:"f64,omitempty"` |
| I32 *int32 `protobuf:"varint,5,opt,name=i32" json:"i32,omitempty"` |
| I64 *int64 `protobuf:"varint,6,opt,name=i64" json:"i64,omitempty"` |
| Ui32 *uint32 `protobuf:"varint,7,opt,name=ui32" json:"ui32,omitempty"` |
| Ui64 *uint64 `protobuf:"varint,8,opt,name=ui64" json:"ui64,omitempty"` |
| S *string `protobuf:"bytes,9,opt,name=s" json:"s,omitempty"` |
| M *M2 `protobuf:"bytes,10,opt,name=m" json:"m,omitempty"` |
| Is []int32 `protobuf:"varint,11,rep,packed,name=is" json:"is,omitempty"` |
| Ms []*M2 `protobuf:"bytes,12,rep,name=ms" json:"ms,omitempty"` |
| Map map[string]bool `protobuf:"bytes,29,rep,name=map" json:"map,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` |
| E *M2_Enum `protobuf:"varint,13,opt,name=e,enum=net.proto2.go.open2opaque.o2o.test.M2_Enum" json:"e,omitempty"` |
| // Types that are valid to be assigned to OneofField: |
| // |
| // *M2_StringOneof |
| // *M2_IntOneof |
| // *M2_MsgOneof |
| // *M2_EnumOneof |
| // *M2_BytesOneof |
| // *M2_EmptyOneof |
| OneofField isM2_OneofField `protobuf_oneof:"oneof_field"` |
| // Types that are valid to be assigned to OneofField2: |
| // |
| // *M2_StringOneof2 |
| // *M2_IntOneof2 |
| // *M2_MsgOneof2 |
| // *M2_EnumOneof2 |
| // *M2_BytesOneof2 |
| OneofField2 isM2_OneofField2 `protobuf_oneof:"oneof_field2"` |
| Build *int32 `protobuf:"varint,24,opt,name=build" json:"build,omitempty"` |
| ProtoMessage_ *int32 `protobuf:"varint,25,opt,name=proto_message,json=protoMessage" json:"proto_message,omitempty"` |
| Reset_ *int32 `protobuf:"varint,26,opt,name=reset" json:"reset,omitempty"` |
| String_ *int32 `protobuf:"varint,27,opt,name=string" json:"string,omitempty"` |
| Descriptor_ *int32 `protobuf:"varint,28,opt,name=descriptor" json:"descriptor,omitempty"` |
| unknownFields protoimpl.UnknownFields |
| sizeCache protoimpl.SizeCache |
| } |
| |
| func (x *M2) Reset() { |
| *x = M2{} |
| mi := &file_proto2test_proto_msgTypes[1] |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| ms.StoreMessageInfo(mi) |
| } |
| |
| func (x *M2) String() string { |
| return protoimpl.X.MessageStringOf(x) |
| } |
| |
| func (*M2) ProtoMessage() {} |
| |
| func (x *M2) ProtoReflect() protoreflect.Message { |
| mi := &file_proto2test_proto_msgTypes[1] |
| if x != nil { |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| if ms.LoadMessageInfo() == nil { |
| ms.StoreMessageInfo(mi) |
| } |
| return ms |
| } |
| return mi.MessageOf(x) |
| } |
| |
| func (x *M2) GetB() bool { |
| if x != nil && x.B != nil { |
| return *x.B |
| } |
| return false |
| } |
| |
| func (x *M2) GetBytes() []byte { |
| if x != nil { |
| return x.Bytes |
| } |
| return nil |
| } |
| |
| func (x *M2) GetF32() float32 { |
| if x != nil && x.F32 != nil { |
| return *x.F32 |
| } |
| return 0 |
| } |
| |
| func (x *M2) GetF64() float64 { |
| if x != nil && x.F64 != nil { |
| return *x.F64 |
| } |
| return 0 |
| } |
| |
| func (x *M2) GetI32() int32 { |
| if x != nil && x.I32 != nil { |
| return *x.I32 |
| } |
| return 0 |
| } |
| |
| func (x *M2) GetI64() int64 { |
| if x != nil && x.I64 != nil { |
| return *x.I64 |
| } |
| return 0 |
| } |
| |
| func (x *M2) GetUi32() uint32 { |
| if x != nil && x.Ui32 != nil { |
| return *x.Ui32 |
| } |
| return 0 |
| } |
| |
| func (x *M2) GetUi64() uint64 { |
| if x != nil && x.Ui64 != nil { |
| return *x.Ui64 |
| } |
| return 0 |
| } |
| |
| func (x *M2) GetS() string { |
| if x != nil && x.S != nil { |
| return *x.S |
| } |
| return "" |
| } |
| |
| func (x *M2) GetM() *M2 { |
| if x != nil { |
| return x.M |
| } |
| return nil |
| } |
| |
| func (x *M2) GetIs() []int32 { |
| if x != nil { |
| return x.Is |
| } |
| return nil |
| } |
| |
| func (x *M2) GetMs() []*M2 { |
| if x != nil { |
| return x.Ms |
| } |
| return nil |
| } |
| |
| func (x *M2) GetMap() map[string]bool { |
| if x != nil { |
| return x.Map |
| } |
| return nil |
| } |
| |
| func (x *M2) GetE() M2_Enum { |
| if x != nil && x.E != nil { |
| return *x.E |
| } |
| return M2_E_VAL |
| } |
| |
| func (x *M2) GetOneofField() isM2_OneofField { |
| if x != nil { |
| return x.OneofField |
| } |
| return nil |
| } |
| |
| func (x *M2) GetStringOneof() string { |
| if x != nil { |
| if x, ok := x.OneofField.(*M2_StringOneof); ok { |
| return x.StringOneof |
| } |
| } |
| return "" |
| } |
| |
| func (x *M2) GetIntOneof() int64 { |
| if x != nil { |
| if x, ok := x.OneofField.(*M2_IntOneof); ok { |
| return x.IntOneof |
| } |
| } |
| return 0 |
| } |
| |
| func (x *M2) GetMsgOneof() *M2 { |
| if x != nil { |
| if x, ok := x.OneofField.(*M2_MsgOneof); ok { |
| return x.MsgOneof |
| } |
| } |
| return nil |
| } |
| |
| func (x *M2) GetEnumOneof() M2_Enum { |
| if x != nil { |
| if x, ok := x.OneofField.(*M2_EnumOneof); ok { |
| return x.EnumOneof |
| } |
| } |
| return M2_E_VAL |
| } |
| |
| func (x *M2) GetBytesOneof() []byte { |
| if x != nil { |
| if x, ok := x.OneofField.(*M2_BytesOneof); ok { |
| return x.BytesOneof |
| } |
| } |
| return nil |
| } |
| |
| func (x *M2) GetEmptyOneof() *emptypb.Empty { |
| if x != nil { |
| if x, ok := x.OneofField.(*M2_EmptyOneof); ok { |
| return x.EmptyOneof |
| } |
| } |
| return nil |
| } |
| |
| func (x *M2) GetOneofField2() isM2_OneofField2 { |
| if x != nil { |
| return x.OneofField2 |
| } |
| return nil |
| } |
| |
| func (x *M2) GetStringOneof2() string { |
| if x != nil { |
| if x, ok := x.OneofField2.(*M2_StringOneof2); ok { |
| return x.StringOneof2 |
| } |
| } |
| return "" |
| } |
| |
| func (x *M2) GetIntOneof2() int64 { |
| if x != nil { |
| if x, ok := x.OneofField2.(*M2_IntOneof2); ok { |
| return x.IntOneof2 |
| } |
| } |
| return 0 |
| } |
| |
| func (x *M2) GetMsgOneof2() *M2 { |
| if x != nil { |
| if x, ok := x.OneofField2.(*M2_MsgOneof2); ok { |
| return x.MsgOneof2 |
| } |
| } |
| return nil |
| } |
| |
| func (x *M2) GetEnumOneof2() M2_Enum { |
| if x != nil { |
| if x, ok := x.OneofField2.(*M2_EnumOneof2); ok { |
| return x.EnumOneof2 |
| } |
| } |
| return M2_E_VAL |
| } |
| |
| func (x *M2) GetBytesOneof2() []byte { |
| if x != nil { |
| if x, ok := x.OneofField2.(*M2_BytesOneof2); ok { |
| return x.BytesOneof2 |
| } |
| } |
| return nil |
| } |
| |
| func (x *M2) GetBuild_() int32 { |
| if x != nil && x.Build != nil { |
| return *x.Build |
| } |
| return 0 |
| } |
| |
| // Deprecated: Use GetBuild_ instead. |
| func (x *M2) GetBuild() int32 { |
| return x.GetBuild_() |
| } |
| |
| func (x *M2) GetProtoMessage() int32 { |
| if x != nil && x.ProtoMessage_ != nil { |
| return *x.ProtoMessage_ |
| } |
| return 0 |
| } |
| |
| // Deprecated: Use GetProtoMessage instead. |
| func (x *M2) GetProtoMessage_() int32 { |
| return x.GetProtoMessage() |
| } |
| |
| func (x *M2) GetReset() int32 { |
| if x != nil && x.Reset_ != nil { |
| return *x.Reset_ |
| } |
| return 0 |
| } |
| |
| // Deprecated: Use GetReset instead. |
| func (x *M2) GetReset_() int32 { |
| return x.GetReset() |
| } |
| |
| func (x *M2) GetString() int32 { |
| if x != nil && x.String_ != nil { |
| return *x.String_ |
| } |
| return 0 |
| } |
| |
| // Deprecated: Use GetString instead. |
| func (x *M2) GetString_() int32 { |
| return x.GetString() |
| } |
| |
| func (x *M2) GetDescriptor() int32 { |
| if x != nil && x.Descriptor_ != nil { |
| return *x.Descriptor_ |
| } |
| return 0 |
| } |
| |
| // Deprecated: Use GetDescriptor instead. |
| func (x *M2) GetDescriptor_() int32 { |
| return x.GetDescriptor() |
| } |
| |
| func (x *M2) SetB(v bool) { |
| x.B = &v |
| } |
| |
| func (x *M2) SetBytes(v []byte) { |
| if v == nil { |
| v = []byte{} |
| } |
| x.Bytes = v |
| } |
| |
| func (x *M2) SetF32(v float32) { |
| x.F32 = &v |
| } |
| |
| func (x *M2) SetF64(v float64) { |
| x.F64 = &v |
| } |
| |
| func (x *M2) SetI32(v int32) { |
| x.I32 = &v |
| } |
| |
| func (x *M2) SetI64(v int64) { |
| x.I64 = &v |
| } |
| |
| func (x *M2) SetUi32(v uint32) { |
| x.Ui32 = &v |
| } |
| |
| func (x *M2) SetUi64(v uint64) { |
| x.Ui64 = &v |
| } |
| |
| func (x *M2) SetS(v string) { |
| x.S = &v |
| } |
| |
| func (x *M2) SetM(v *M2) { |
| x.M = v |
| } |
| |
| func (x *M2) SetIs(v []int32) { |
| x.Is = v |
| } |
| |
| func (x *M2) SetMs(v []*M2) { |
| x.Ms = v |
| } |
| |
| func (x *M2) SetMap(v map[string]bool) { |
| x.Map = v |
| } |
| |
| func (x *M2) SetE(v M2_Enum) { |
| x.E = &v |
| } |
| |
| func (x *M2) SetStringOneof(v string) { |
| x.OneofField = &M2_StringOneof{v} |
| } |
| |
| func (x *M2) SetIntOneof(v int64) { |
| x.OneofField = &M2_IntOneof{v} |
| } |
| |
| func (x *M2) SetMsgOneof(v *M2) { |
| if v == nil { |
| x.OneofField = nil |
| return |
| } |
| x.OneofField = &M2_MsgOneof{v} |
| } |
| |
| func (x *M2) SetEnumOneof(v M2_Enum) { |
| x.OneofField = &M2_EnumOneof{v} |
| } |
| |
| func (x *M2) SetBytesOneof(v []byte) { |
| if v == nil { |
| v = []byte{} |
| } |
| x.OneofField = &M2_BytesOneof{v} |
| } |
| |
| func (x *M2) SetEmptyOneof(v *emptypb.Empty) { |
| if v == nil { |
| x.OneofField = nil |
| return |
| } |
| x.OneofField = &M2_EmptyOneof{v} |
| } |
| |
| func (x *M2) SetStringOneof2(v string) { |
| x.OneofField2 = &M2_StringOneof2{v} |
| } |
| |
| func (x *M2) SetIntOneof2(v int64) { |
| x.OneofField2 = &M2_IntOneof2{v} |
| } |
| |
| func (x *M2) SetMsgOneof2(v *M2) { |
| if v == nil { |
| x.OneofField2 = nil |
| return |
| } |
| x.OneofField2 = &M2_MsgOneof2{v} |
| } |
| |
| func (x *M2) SetEnumOneof2(v M2_Enum) { |
| x.OneofField2 = &M2_EnumOneof2{v} |
| } |
| |
| func (x *M2) SetBytesOneof2(v []byte) { |
| if v == nil { |
| v = []byte{} |
| } |
| x.OneofField2 = &M2_BytesOneof2{v} |
| } |
| |
| func (x *M2) SetBuild_(v int32) { |
| x.Build = &v |
| } |
| |
| func (x *M2) SetProtoMessage(v int32) { |
| x.ProtoMessage_ = &v |
| } |
| |
| func (x *M2) SetReset(v int32) { |
| x.Reset_ = &v |
| } |
| |
| func (x *M2) SetString(v int32) { |
| x.String_ = &v |
| } |
| |
| func (x *M2) SetDescriptor(v int32) { |
| x.Descriptor_ = &v |
| } |
| |
| func (x *M2) HasB() bool { |
| if x == nil { |
| return false |
| } |
| return x.B != nil |
| } |
| |
| func (x *M2) HasBytes() bool { |
| if x == nil { |
| return false |
| } |
| return x.Bytes != nil |
| } |
| |
| func (x *M2) HasF32() bool { |
| if x == nil { |
| return false |
| } |
| return x.F32 != nil |
| } |
| |
| func (x *M2) HasF64() bool { |
| if x == nil { |
| return false |
| } |
| return x.F64 != nil |
| } |
| |
| func (x *M2) HasI32() bool { |
| if x == nil { |
| return false |
| } |
| return x.I32 != nil |
| } |
| |
| func (x *M2) HasI64() bool { |
| if x == nil { |
| return false |
| } |
| return x.I64 != nil |
| } |
| |
| func (x *M2) HasUi32() bool { |
| if x == nil { |
| return false |
| } |
| return x.Ui32 != nil |
| } |
| |
| func (x *M2) HasUi64() bool { |
| if x == nil { |
| return false |
| } |
| return x.Ui64 != nil |
| } |
| |
| func (x *M2) HasS() bool { |
| if x == nil { |
| return false |
| } |
| return x.S != nil |
| } |
| |
| func (x *M2) HasM() bool { |
| if x == nil { |
| return false |
| } |
| return x.M != nil |
| } |
| |
| func (x *M2) HasE() bool { |
| if x == nil { |
| return false |
| } |
| return x.E != nil |
| } |
| |
| func (x *M2) HasOneofField() bool { |
| if x == nil { |
| return false |
| } |
| return x.OneofField != nil |
| } |
| |
| func (x *M2) HasStringOneof() bool { |
| if x == nil { |
| return false |
| } |
| _, ok := x.OneofField.(*M2_StringOneof) |
| return ok |
| } |
| |
| func (x *M2) HasIntOneof() bool { |
| if x == nil { |
| return false |
| } |
| _, ok := x.OneofField.(*M2_IntOneof) |
| return ok |
| } |
| |
| func (x *M2) HasMsgOneof() bool { |
| if x == nil { |
| return false |
| } |
| _, ok := x.OneofField.(*M2_MsgOneof) |
| return ok |
| } |
| |
| func (x *M2) HasEnumOneof() bool { |
| if x == nil { |
| return false |
| } |
| _, ok := x.OneofField.(*M2_EnumOneof) |
| return ok |
| } |
| |
| func (x *M2) HasBytesOneof() bool { |
| if x == nil { |
| return false |
| } |
| _, ok := x.OneofField.(*M2_BytesOneof) |
| return ok |
| } |
| |
| func (x *M2) HasEmptyOneof() bool { |
| if x == nil { |
| return false |
| } |
| _, ok := x.OneofField.(*M2_EmptyOneof) |
| return ok |
| } |
| |
| func (x *M2) HasOneofField2() bool { |
| if x == nil { |
| return false |
| } |
| return x.OneofField2 != nil |
| } |
| |
| func (x *M2) HasStringOneof2() bool { |
| if x == nil { |
| return false |
| } |
| _, ok := x.OneofField2.(*M2_StringOneof2) |
| return ok |
| } |
| |
| func (x *M2) HasIntOneof2() bool { |
| if x == nil { |
| return false |
| } |
| _, ok := x.OneofField2.(*M2_IntOneof2) |
| return ok |
| } |
| |
| func (x *M2) HasMsgOneof2() bool { |
| if x == nil { |
| return false |
| } |
| _, ok := x.OneofField2.(*M2_MsgOneof2) |
| return ok |
| } |
| |
| func (x *M2) HasEnumOneof2() bool { |
| if x == nil { |
| return false |
| } |
| _, ok := x.OneofField2.(*M2_EnumOneof2) |
| return ok |
| } |
| |
| func (x *M2) HasBytesOneof2() bool { |
| if x == nil { |
| return false |
| } |
| _, ok := x.OneofField2.(*M2_BytesOneof2) |
| return ok |
| } |
| |
| func (x *M2) HasBuild_() bool { |
| if x == nil { |
| return false |
| } |
| return x.Build != nil |
| } |
| |
| func (x *M2) HasProtoMessage() bool { |
| if x == nil { |
| return false |
| } |
| return x.ProtoMessage_ != nil |
| } |
| |
| func (x *M2) HasReset() bool { |
| if x == nil { |
| return false |
| } |
| return x.Reset_ != nil |
| } |
| |
| func (x *M2) HasString() bool { |
| if x == nil { |
| return false |
| } |
| return x.String_ != nil |
| } |
| |
| func (x *M2) HasDescriptor() bool { |
| if x == nil { |
| return false |
| } |
| return x.Descriptor_ != nil |
| } |
| |
| func (x *M2) ClearB() { |
| x.B = nil |
| } |
| |
| func (x *M2) ClearBytes() { |
| x.Bytes = nil |
| } |
| |
| func (x *M2) ClearF32() { |
| x.F32 = nil |
| } |
| |
| func (x *M2) ClearF64() { |
| x.F64 = nil |
| } |
| |
| func (x *M2) ClearI32() { |
| x.I32 = nil |
| } |
| |
| func (x *M2) ClearI64() { |
| x.I64 = nil |
| } |
| |
| func (x *M2) ClearUi32() { |
| x.Ui32 = nil |
| } |
| |
| func (x *M2) ClearUi64() { |
| x.Ui64 = nil |
| } |
| |
| func (x *M2) ClearS() { |
| x.S = nil |
| } |
| |
| func (x *M2) ClearM() { |
| x.M = nil |
| } |
| |
| func (x *M2) ClearE() { |
| x.E = nil |
| } |
| |
| func (x *M2) ClearOneofField() { |
| x.OneofField = nil |
| } |
| |
| func (x *M2) ClearStringOneof() { |
| if _, ok := x.OneofField.(*M2_StringOneof); ok { |
| x.OneofField = nil |
| } |
| } |
| |
| func (x *M2) ClearIntOneof() { |
| if _, ok := x.OneofField.(*M2_IntOneof); ok { |
| x.OneofField = nil |
| } |
| } |
| |
| func (x *M2) ClearMsgOneof() { |
| if _, ok := x.OneofField.(*M2_MsgOneof); ok { |
| x.OneofField = nil |
| } |
| } |
| |
| func (x *M2) ClearEnumOneof() { |
| if _, ok := x.OneofField.(*M2_EnumOneof); ok { |
| x.OneofField = nil |
| } |
| } |
| |
| func (x *M2) ClearBytesOneof() { |
| if _, ok := x.OneofField.(*M2_BytesOneof); ok { |
| x.OneofField = nil |
| } |
| } |
| |
| func (x *M2) ClearEmptyOneof() { |
| if _, ok := x.OneofField.(*M2_EmptyOneof); ok { |
| x.OneofField = nil |
| } |
| } |
| |
| func (x *M2) ClearOneofField2() { |
| x.OneofField2 = nil |
| } |
| |
| func (x *M2) ClearStringOneof2() { |
| if _, ok := x.OneofField2.(*M2_StringOneof2); ok { |
| x.OneofField2 = nil |
| } |
| } |
| |
| func (x *M2) ClearIntOneof2() { |
| if _, ok := x.OneofField2.(*M2_IntOneof2); ok { |
| x.OneofField2 = nil |
| } |
| } |
| |
| func (x *M2) ClearMsgOneof2() { |
| if _, ok := x.OneofField2.(*M2_MsgOneof2); ok { |
| x.OneofField2 = nil |
| } |
| } |
| |
| func (x *M2) ClearEnumOneof2() { |
| if _, ok := x.OneofField2.(*M2_EnumOneof2); ok { |
| x.OneofField2 = nil |
| } |
| } |
| |
| func (x *M2) ClearBytesOneof2() { |
| if _, ok := x.OneofField2.(*M2_BytesOneof2); ok { |
| x.OneofField2 = nil |
| } |
| } |
| |
| func (x *M2) ClearBuild_() { |
| x.Build = nil |
| } |
| |
| func (x *M2) ClearProtoMessage() { |
| x.ProtoMessage_ = nil |
| } |
| |
| func (x *M2) ClearReset() { |
| x.Reset_ = nil |
| } |
| |
| func (x *M2) ClearString() { |
| x.String_ = nil |
| } |
| |
| func (x *M2) ClearDescriptor() { |
| x.Descriptor_ = nil |
| } |
| |
| const M2_OneofField_not_set_case case_M2_OneofField = 0 |
| const M2_StringOneof_case case_M2_OneofField = 14 |
| const M2_IntOneof_case case_M2_OneofField = 15 |
| const M2_MsgOneof_case case_M2_OneofField = 16 |
| const M2_EnumOneof_case case_M2_OneofField = 17 |
| const M2_BytesOneof_case case_M2_OneofField = 18 |
| const M2_EmptyOneof_case case_M2_OneofField = 99 |
| |
| func (x *M2) WhichOneofField() case_M2_OneofField { |
| if x == nil { |
| return M2_OneofField_not_set_case |
| } |
| switch x.OneofField.(type) { |
| case *M2_StringOneof: |
| return M2_StringOneof_case |
| case *M2_IntOneof: |
| return M2_IntOneof_case |
| case *M2_MsgOneof: |
| return M2_MsgOneof_case |
| case *M2_EnumOneof: |
| return M2_EnumOneof_case |
| case *M2_BytesOneof: |
| return M2_BytesOneof_case |
| case *M2_EmptyOneof: |
| return M2_EmptyOneof_case |
| default: |
| return M2_OneofField_not_set_case |
| } |
| } |
| |
| const M2_OneofField2_not_set_case case_M2_OneofField2 = 0 |
| const M2_StringOneof2_case case_M2_OneofField2 = 19 |
| const M2_IntOneof2_case case_M2_OneofField2 = 20 |
| const M2_MsgOneof2_case case_M2_OneofField2 = 21 |
| const M2_EnumOneof2_case case_M2_OneofField2 = 22 |
| const M2_BytesOneof2_case case_M2_OneofField2 = 23 |
| |
| func (x *M2) WhichOneofField2() case_M2_OneofField2 { |
| if x == nil { |
| return M2_OneofField2_not_set_case |
| } |
| switch x.OneofField2.(type) { |
| case *M2_StringOneof2: |
| return M2_StringOneof2_case |
| case *M2_IntOneof2: |
| return M2_IntOneof2_case |
| case *M2_MsgOneof2: |
| return M2_MsgOneof2_case |
| case *M2_EnumOneof2: |
| return M2_EnumOneof2_case |
| case *M2_BytesOneof2: |
| return M2_BytesOneof2_case |
| default: |
| return M2_OneofField2_not_set_case |
| } |
| } |
| |
| type M2_builder struct { |
| _ [0]func() // Prevents comparability and use of unkeyed literals for the builder. |
| |
| B *bool |
| Bytes []byte |
| F32 *float32 |
| F64 *float64 |
| I32 *int32 |
| I64 *int64 |
| Ui32 *uint32 |
| Ui64 *uint64 |
| S *string |
| M *M2 |
| Is []int32 |
| Ms []*M2 |
| Map map[string]bool |
| E *M2_Enum |
| // Fields of oneof OneofField: |
| StringOneof *string |
| IntOneof *int64 |
| MsgOneof *M2 |
| EnumOneof *M2_Enum |
| BytesOneof []byte |
| EmptyOneof *emptypb.Empty |
| // -- end of OneofField |
| // Fields of oneof OneofField2: |
| StringOneof2 *string |
| IntOneof2 *int64 |
| MsgOneof2 *M2 |
| EnumOneof2 *M2_Enum |
| BytesOneof2 []byte |
| // -- end of OneofField2 |
| Build_ *int32 |
| ProtoMessage *int32 |
| Reset *int32 |
| String *int32 |
| Descriptor *int32 |
| } |
| |
| func (b0 M2_builder) Build() *M2 { |
| m0 := &M2{} |
| b, x := &b0, m0 |
| _, _ = b, x |
| x.B = b.B |
| x.Bytes = b.Bytes |
| x.F32 = b.F32 |
| x.F64 = b.F64 |
| x.I32 = b.I32 |
| x.I64 = b.I64 |
| x.Ui32 = b.Ui32 |
| x.Ui64 = b.Ui64 |
| x.S = b.S |
| x.M = b.M |
| x.Is = b.Is |
| x.Ms = b.Ms |
| x.Map = b.Map |
| x.E = b.E |
| if b.StringOneof != nil { |
| x.OneofField = &M2_StringOneof{*b.StringOneof} |
| } |
| if b.IntOneof != nil { |
| x.OneofField = &M2_IntOneof{*b.IntOneof} |
| } |
| if b.MsgOneof != nil { |
| x.OneofField = &M2_MsgOneof{b.MsgOneof} |
| } |
| if b.EnumOneof != nil { |
| x.OneofField = &M2_EnumOneof{*b.EnumOneof} |
| } |
| if b.BytesOneof != nil { |
| x.OneofField = &M2_BytesOneof{b.BytesOneof} |
| } |
| if b.EmptyOneof != nil { |
| x.OneofField = &M2_EmptyOneof{b.EmptyOneof} |
| } |
| if b.StringOneof2 != nil { |
| x.OneofField2 = &M2_StringOneof2{*b.StringOneof2} |
| } |
| if b.IntOneof2 != nil { |
| x.OneofField2 = &M2_IntOneof2{*b.IntOneof2} |
| } |
| if b.MsgOneof2 != nil { |
| x.OneofField2 = &M2_MsgOneof2{b.MsgOneof2} |
| } |
| if b.EnumOneof2 != nil { |
| x.OneofField2 = &M2_EnumOneof2{*b.EnumOneof2} |
| } |
| if b.BytesOneof2 != nil { |
| x.OneofField2 = &M2_BytesOneof2{b.BytesOneof2} |
| } |
| x.Build = b.Build_ |
| x.ProtoMessage_ = b.ProtoMessage |
| x.Reset_ = b.Reset |
| x.String_ = b.String |
| x.Descriptor_ = b.Descriptor |
| return m0 |
| } |
| |
| type case_M2_OneofField protoreflect.FieldNumber |
| |
| func (x case_M2_OneofField) String() string { |
| md := file_proto2test_proto_msgTypes[1].Descriptor() |
| if x == 0 { |
| return "not set" |
| } |
| return protoimpl.X.MessageFieldStringOf(md, protoreflect.FieldNumber(x)) |
| } |
| |
| type case_M2_OneofField2 protoreflect.FieldNumber |
| |
| func (x case_M2_OneofField2) String() string { |
| md := file_proto2test_proto_msgTypes[1].Descriptor() |
| if x == 0 { |
| return "not set" |
| } |
| return protoimpl.X.MessageFieldStringOf(md, protoreflect.FieldNumber(x)) |
| } |
| |
| type isM2_OneofField interface { |
| isM2_OneofField() |
| } |
| |
| type M2_StringOneof struct { |
| StringOneof string `protobuf:"bytes,14,opt,name=string_oneof,json=stringOneof,oneof"` |
| } |
| |
| type M2_IntOneof struct { |
| IntOneof int64 `protobuf:"varint,15,opt,name=int_oneof,json=intOneof,oneof"` |
| } |
| |
| type M2_MsgOneof struct { |
| MsgOneof *M2 `protobuf:"bytes,16,opt,name=msg_oneof,json=msgOneof,oneof"` |
| } |
| |
| type M2_EnumOneof struct { |
| EnumOneof M2_Enum `protobuf:"varint,17,opt,name=enum_oneof,json=enumOneof,enum=net.proto2.go.open2opaque.o2o.test.M2_Enum,oneof"` |
| } |
| |
| type M2_BytesOneof struct { |
| BytesOneof []byte `protobuf:"bytes,18,opt,name=bytes_oneof,json=bytesOneof,oneof"` |
| } |
| |
| type M2_EmptyOneof struct { |
| EmptyOneof *emptypb.Empty `protobuf:"bytes,99,opt,name=empty_oneof,json=emptyOneof,oneof"` |
| } |
| |
| func (*M2_StringOneof) isM2_OneofField() {} |
| |
| func (*M2_IntOneof) isM2_OneofField() {} |
| |
| func (*M2_MsgOneof) isM2_OneofField() {} |
| |
| func (*M2_EnumOneof) isM2_OneofField() {} |
| |
| func (*M2_BytesOneof) isM2_OneofField() {} |
| |
| func (*M2_EmptyOneof) isM2_OneofField() {} |
| |
| type isM2_OneofField2 interface { |
| isM2_OneofField2() |
| } |
| |
| type M2_StringOneof2 struct { |
| StringOneof2 string `protobuf:"bytes,19,opt,name=string_oneof2,json=stringOneof2,oneof"` |
| } |
| |
| type M2_IntOneof2 struct { |
| IntOneof2 int64 `protobuf:"varint,20,opt,name=int_oneof2,json=intOneof2,oneof"` |
| } |
| |
| type M2_MsgOneof2 struct { |
| MsgOneof2 *M2 `protobuf:"bytes,21,opt,name=msg_oneof2,json=msgOneof2,oneof"` |
| } |
| |
| type M2_EnumOneof2 struct { |
| EnumOneof2 M2_Enum `protobuf:"varint,22,opt,name=enum_oneof2,json=enumOneof2,enum=net.proto2.go.open2opaque.o2o.test.M2_Enum,oneof"` |
| } |
| |
| type M2_BytesOneof2 struct { |
| BytesOneof2 []byte `protobuf:"bytes,23,opt,name=bytes_oneof2,json=bytesOneof2,oneof"` |
| } |
| |
| func (*M2_StringOneof2) isM2_OneofField2() {} |
| |
| func (*M2_IntOneof2) isM2_OneofField2() {} |
| |
| func (*M2_MsgOneof2) isM2_OneofField2() {} |
| |
| func (*M2_EnumOneof2) isM2_OneofField2() {} |
| |
| func (*M2_BytesOneof2) isM2_OneofField2() {} |
| |
| type OtherProto2 struct { |
| state protoimpl.MessageState `protogen:"hybrid.v1"` |
| B *bool `protobuf:"varint,1,opt,name=b" json:"b,omitempty"` |
| Bytes []byte `protobuf:"bytes,2,opt,name=bytes" json:"bytes,omitempty"` |
| F32 *float32 `protobuf:"fixed32,3,opt,name=f32" json:"f32,omitempty"` |
| F64 *float64 `protobuf:"fixed64,4,opt,name=f64" json:"f64,omitempty"` |
| I32 *int32 `protobuf:"varint,5,opt,name=i32" json:"i32,omitempty"` |
| I64 *int64 `protobuf:"varint,6,opt,name=i64" json:"i64,omitempty"` |
| Ui32 *uint32 `protobuf:"varint,7,opt,name=ui32" json:"ui32,omitempty"` |
| Ui64 *uint64 `protobuf:"varint,8,opt,name=ui64" json:"ui64,omitempty"` |
| S *string `protobuf:"bytes,9,opt,name=s" json:"s,omitempty"` |
| M *OtherProto2 `protobuf:"bytes,10,opt,name=m" json:"m,omitempty"` |
| Is []int32 `protobuf:"varint,11,rep,packed,name=is" json:"is,omitempty"` |
| Ms []*OtherProto2 `protobuf:"bytes,12,rep,name=ms" json:"ms,omitempty"` |
| Map map[string]bool `protobuf:"bytes,29,rep,name=map" json:"map,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` |
| E *OtherProto2_OtherEnum `protobuf:"varint,13,opt,name=e,enum=net.proto2.go.open2opaque.o2o.test.OtherProto2_OtherEnum" json:"e,omitempty"` |
| // Types that are valid to be assigned to OneofField: |
| // |
| // *OtherProto2_StringOneof |
| // *OtherProto2_IntOneof |
| // *OtherProto2_MsgOneof |
| // *OtherProto2_EnumOneof |
| // *OtherProto2_BytesOneof |
| OneofField isOtherProto2_OneofField `protobuf_oneof:"oneof_field"` |
| // Types that are valid to be assigned to OneofField2: |
| // |
| // *OtherProto2_StringOneof2 |
| // *OtherProto2_IntOneof2 |
| // *OtherProto2_MsgOneof2 |
| // *OtherProto2_EnumOneof2 |
| // *OtherProto2_BytesOneof2 |
| OneofField2 isOtherProto2_OneofField2 `protobuf_oneof:"oneof_field2"` |
| Build *int32 `protobuf:"varint,24,opt,name=build" json:"build,omitempty"` |
| ProtoMessage_ *int32 `protobuf:"varint,25,opt,name=proto_message,json=protoMessage" json:"proto_message,omitempty"` |
| Reset_ *int32 `protobuf:"varint,26,opt,name=reset" json:"reset,omitempty"` |
| String_ *int32 `protobuf:"varint,27,opt,name=string" json:"string,omitempty"` |
| Descriptor_ *int32 `protobuf:"varint,28,opt,name=descriptor" json:"descriptor,omitempty"` |
| unknownFields protoimpl.UnknownFields |
| sizeCache protoimpl.SizeCache |
| } |
| |
| func (x *OtherProto2) Reset() { |
| *x = OtherProto2{} |
| mi := &file_proto2test_proto_msgTypes[2] |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| ms.StoreMessageInfo(mi) |
| } |
| |
| func (x *OtherProto2) String() string { |
| return protoimpl.X.MessageStringOf(x) |
| } |
| |
| func (*OtherProto2) ProtoMessage() {} |
| |
| func (x *OtherProto2) ProtoReflect() protoreflect.Message { |
| mi := &file_proto2test_proto_msgTypes[2] |
| if x != nil { |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| if ms.LoadMessageInfo() == nil { |
| ms.StoreMessageInfo(mi) |
| } |
| return ms |
| } |
| return mi.MessageOf(x) |
| } |
| |
| func (x *OtherProto2) GetB() bool { |
| if x != nil && x.B != nil { |
| return *x.B |
| } |
| return false |
| } |
| |
| func (x *OtherProto2) GetBytes() []byte { |
| if x != nil { |
| return x.Bytes |
| } |
| return nil |
| } |
| |
| func (x *OtherProto2) GetF32() float32 { |
| if x != nil && x.F32 != nil { |
| return *x.F32 |
| } |
| return 0 |
| } |
| |
| func (x *OtherProto2) GetF64() float64 { |
| if x != nil && x.F64 != nil { |
| return *x.F64 |
| } |
| return 0 |
| } |
| |
| func (x *OtherProto2) GetI32() int32 { |
| if x != nil && x.I32 != nil { |
| return *x.I32 |
| } |
| return 0 |
| } |
| |
| func (x *OtherProto2) GetI64() int64 { |
| if x != nil && x.I64 != nil { |
| return *x.I64 |
| } |
| return 0 |
| } |
| |
| func (x *OtherProto2) GetUi32() uint32 { |
| if x != nil && x.Ui32 != nil { |
| return *x.Ui32 |
| } |
| return 0 |
| } |
| |
| func (x *OtherProto2) GetUi64() uint64 { |
| if x != nil && x.Ui64 != nil { |
| return *x.Ui64 |
| } |
| return 0 |
| } |
| |
| func (x *OtherProto2) GetS() string { |
| if x != nil && x.S != nil { |
| return *x.S |
| } |
| return "" |
| } |
| |
| func (x *OtherProto2) GetM() *OtherProto2 { |
| if x != nil { |
| return x.M |
| } |
| return nil |
| } |
| |
| func (x *OtherProto2) GetIs() []int32 { |
| if x != nil { |
| return x.Is |
| } |
| return nil |
| } |
| |
| func (x *OtherProto2) GetMs() []*OtherProto2 { |
| if x != nil { |
| return x.Ms |
| } |
| return nil |
| } |
| |
| func (x *OtherProto2) GetMap() map[string]bool { |
| if x != nil { |
| return x.Map |
| } |
| return nil |
| } |
| |
| func (x *OtherProto2) GetE() OtherProto2_OtherEnum { |
| if x != nil && x.E != nil { |
| return *x.E |
| } |
| return OtherProto2_E_VAL |
| } |
| |
| func (x *OtherProto2) GetOneofField() isOtherProto2_OneofField { |
| if x != nil { |
| return x.OneofField |
| } |
| return nil |
| } |
| |
| func (x *OtherProto2) GetStringOneof() string { |
| if x != nil { |
| if x, ok := x.OneofField.(*OtherProto2_StringOneof); ok { |
| return x.StringOneof |
| } |
| } |
| return "" |
| } |
| |
| func (x *OtherProto2) GetIntOneof() int64 { |
| if x != nil { |
| if x, ok := x.OneofField.(*OtherProto2_IntOneof); ok { |
| return x.IntOneof |
| } |
| } |
| return 0 |
| } |
| |
| func (x *OtherProto2) GetMsgOneof() *OtherProto2 { |
| if x != nil { |
| if x, ok := x.OneofField.(*OtherProto2_MsgOneof); ok { |
| return x.MsgOneof |
| } |
| } |
| return nil |
| } |
| |
| func (x *OtherProto2) GetEnumOneof() OtherProto2_OtherEnum { |
| if x != nil { |
| if x, ok := x.OneofField.(*OtherProto2_EnumOneof); ok { |
| return x.EnumOneof |
| } |
| } |
| return OtherProto2_E_VAL |
| } |
| |
| func (x *OtherProto2) GetBytesOneof() []byte { |
| if x != nil { |
| if x, ok := x.OneofField.(*OtherProto2_BytesOneof); ok { |
| return x.BytesOneof |
| } |
| } |
| return nil |
| } |
| |
| func (x *OtherProto2) GetOneofField2() isOtherProto2_OneofField2 { |
| if x != nil { |
| return x.OneofField2 |
| } |
| return nil |
| } |
| |
| func (x *OtherProto2) GetStringOneof2() string { |
| if x != nil { |
| if x, ok := x.OneofField2.(*OtherProto2_StringOneof2); ok { |
| return x.StringOneof2 |
| } |
| } |
| return "" |
| } |
| |
| func (x *OtherProto2) GetIntOneof2() int64 { |
| if x != nil { |
| if x, ok := x.OneofField2.(*OtherProto2_IntOneof2); ok { |
| return x.IntOneof2 |
| } |
| } |
| return 0 |
| } |
| |
| func (x *OtherProto2) GetMsgOneof2() *OtherProto2 { |
| if x != nil { |
| if x, ok := x.OneofField2.(*OtherProto2_MsgOneof2); ok { |
| return x.MsgOneof2 |
| } |
| } |
| return nil |
| } |
| |
| func (x *OtherProto2) GetEnumOneof2() OtherProto2_OtherEnum { |
| if x != nil { |
| if x, ok := x.OneofField2.(*OtherProto2_EnumOneof2); ok { |
| return x.EnumOneof2 |
| } |
| } |
| return OtherProto2_E_VAL |
| } |
| |
| func (x *OtherProto2) GetBytesOneof2() []byte { |
| if x != nil { |
| if x, ok := x.OneofField2.(*OtherProto2_BytesOneof2); ok { |
| return x.BytesOneof2 |
| } |
| } |
| return nil |
| } |
| |
| func (x *OtherProto2) GetBuild_() int32 { |
| if x != nil && x.Build != nil { |
| return *x.Build |
| } |
| return 0 |
| } |
| |
| // Deprecated: Use GetBuild_ instead. |
| func (x *OtherProto2) GetBuild() int32 { |
| return x.GetBuild_() |
| } |
| |
| func (x *OtherProto2) GetProtoMessage() int32 { |
| if x != nil && x.ProtoMessage_ != nil { |
| return *x.ProtoMessage_ |
| } |
| return 0 |
| } |
| |
| // Deprecated: Use GetProtoMessage instead. |
| func (x *OtherProto2) GetProtoMessage_() int32 { |
| return x.GetProtoMessage() |
| } |
| |
| func (x *OtherProto2) GetReset() int32 { |
| if x != nil && x.Reset_ != nil { |
| return *x.Reset_ |
| } |
| return 0 |
| } |
| |
| // Deprecated: Use GetReset instead. |
| func (x *OtherProto2) GetReset_() int32 { |
| return x.GetReset() |
| } |
| |
| func (x *OtherProto2) GetString() int32 { |
| if x != nil && x.String_ != nil { |
| return *x.String_ |
| } |
| return 0 |
| } |
| |
| // Deprecated: Use GetString instead. |
| func (x *OtherProto2) GetString_() int32 { |
| return x.GetString() |
| } |
| |
| func (x *OtherProto2) GetDescriptor() int32 { |
| if x != nil && x.Descriptor_ != nil { |
| return *x.Descriptor_ |
| } |
| return 0 |
| } |
| |
| // Deprecated: Use GetDescriptor instead. |
| func (x *OtherProto2) GetDescriptor_() int32 { |
| return x.GetDescriptor() |
| } |
| |
| func (x *OtherProto2) SetB(v bool) { |
| x.B = &v |
| } |
| |
| func (x *OtherProto2) SetBytes(v []byte) { |
| if v == nil { |
| v = []byte{} |
| } |
| x.Bytes = v |
| } |
| |
| func (x *OtherProto2) SetF32(v float32) { |
| x.F32 = &v |
| } |
| |
| func (x *OtherProto2) SetF64(v float64) { |
| x.F64 = &v |
| } |
| |
| func (x *OtherProto2) SetI32(v int32) { |
| x.I32 = &v |
| } |
| |
| func (x *OtherProto2) SetI64(v int64) { |
| x.I64 = &v |
| } |
| |
| func (x *OtherProto2) SetUi32(v uint32) { |
| x.Ui32 = &v |
| } |
| |
| func (x *OtherProto2) SetUi64(v uint64) { |
| x.Ui64 = &v |
| } |
| |
| func (x *OtherProto2) SetS(v string) { |
| x.S = &v |
| } |
| |
| func (x *OtherProto2) SetM(v *OtherProto2) { |
| x.M = v |
| } |
| |
| func (x *OtherProto2) SetIs(v []int32) { |
| x.Is = v |
| } |
| |
| func (x *OtherProto2) SetMs(v []*OtherProto2) { |
| x.Ms = v |
| } |
| |
| func (x *OtherProto2) SetMap(v map[string]bool) { |
| x.Map = v |
| } |
| |
| func (x *OtherProto2) SetE(v OtherProto2_OtherEnum) { |
| x.E = &v |
| } |
| |
| func (x *OtherProto2) SetStringOneof(v string) { |
| x.OneofField = &OtherProto2_StringOneof{v} |
| } |
| |
| func (x *OtherProto2) SetIntOneof(v int64) { |
| x.OneofField = &OtherProto2_IntOneof{v} |
| } |
| |
| func (x *OtherProto2) SetMsgOneof(v *OtherProto2) { |
| if v == nil { |
| x.OneofField = nil |
| return |
| } |
| x.OneofField = &OtherProto2_MsgOneof{v} |
| } |
| |
| func (x *OtherProto2) SetEnumOneof(v OtherProto2_OtherEnum) { |
| x.OneofField = &OtherProto2_EnumOneof{v} |
| } |
| |
| func (x *OtherProto2) SetBytesOneof(v []byte) { |
| if v == nil { |
| v = []byte{} |
| } |
| x.OneofField = &OtherProto2_BytesOneof{v} |
| } |
| |
| func (x *OtherProto2) SetStringOneof2(v string) { |
| x.OneofField2 = &OtherProto2_StringOneof2{v} |
| } |
| |
| func (x *OtherProto2) SetIntOneof2(v int64) { |
| x.OneofField2 = &OtherProto2_IntOneof2{v} |
| } |
| |
| func (x *OtherProto2) SetMsgOneof2(v *OtherProto2) { |
| if v == nil { |
| x.OneofField2 = nil |
| return |
| } |
| x.OneofField2 = &OtherProto2_MsgOneof2{v} |
| } |
| |
| func (x *OtherProto2) SetEnumOneof2(v OtherProto2_OtherEnum) { |
| x.OneofField2 = &OtherProto2_EnumOneof2{v} |
| } |
| |
| func (x *OtherProto2) SetBytesOneof2(v []byte) { |
| if v == nil { |
| v = []byte{} |
| } |
| x.OneofField2 = &OtherProto2_BytesOneof2{v} |
| } |
| |
| func (x *OtherProto2) SetBuild_(v int32) { |
| x.Build = &v |
| } |
| |
| func (x *OtherProto2) SetProtoMessage(v int32) { |
| x.ProtoMessage_ = &v |
| } |
| |
| func (x *OtherProto2) SetReset(v int32) { |
| x.Reset_ = &v |
| } |
| |
| func (x *OtherProto2) SetString(v int32) { |
| x.String_ = &v |
| } |
| |
| func (x *OtherProto2) SetDescriptor(v int32) { |
| x.Descriptor_ = &v |
| } |
| |
| func (x *OtherProto2) HasB() bool { |
| if x == nil { |
| return false |
| } |
| return x.B != nil |
| } |
| |
| func (x *OtherProto2) HasBytes() bool { |
| if x == nil { |
| return false |
| } |
| return x.Bytes != nil |
| } |
| |
| func (x *OtherProto2) HasF32() bool { |
| if x == nil { |
| return false |
| } |
| return x.F32 != nil |
| } |
| |
| func (x *OtherProto2) HasF64() bool { |
| if x == nil { |
| return false |
| } |
| return x.F64 != nil |
| } |
| |
| func (x *OtherProto2) HasI32() bool { |
| if x == nil { |
| return false |
| } |
| return x.I32 != nil |
| } |
| |
| func (x *OtherProto2) HasI64() bool { |
| if x == nil { |
| return false |
| } |
| return x.I64 != nil |
| } |
| |
| func (x *OtherProto2) HasUi32() bool { |
| if x == nil { |
| return false |
| } |
| return x.Ui32 != nil |
| } |
| |
| func (x *OtherProto2) HasUi64() bool { |
| if x == nil { |
| return false |
| } |
| return x.Ui64 != nil |
| } |
| |
| func (x *OtherProto2) HasS() bool { |
| if x == nil { |
| return false |
| } |
| return x.S != nil |
| } |
| |
| func (x *OtherProto2) HasM() bool { |
| if x == nil { |
| return false |
| } |
| return x.M != nil |
| } |
| |
| func (x *OtherProto2) HasE() bool { |
| if x == nil { |
| return false |
| } |
| return x.E != nil |
| } |
| |
| func (x *OtherProto2) HasOneofField() bool { |
| if x == nil { |
| return false |
| } |
| return x.OneofField != nil |
| } |
| |
| func (x *OtherProto2) HasStringOneof() bool { |
| if x == nil { |
| return false |
| } |
| _, ok := x.OneofField.(*OtherProto2_StringOneof) |
| return ok |
| } |
| |
| func (x *OtherProto2) HasIntOneof() bool { |
| if x == nil { |
| return false |
| } |
| _, ok := x.OneofField.(*OtherProto2_IntOneof) |
| return ok |
| } |
| |
| func (x *OtherProto2) HasMsgOneof() bool { |
| if x == nil { |
| return false |
| } |
| _, ok := x.OneofField.(*OtherProto2_MsgOneof) |
| return ok |
| } |
| |
| func (x *OtherProto2) HasEnumOneof() bool { |
| if x == nil { |
| return false |
| } |
| _, ok := x.OneofField.(*OtherProto2_EnumOneof) |
| return ok |
| } |
| |
| func (x *OtherProto2) HasBytesOneof() bool { |
| if x == nil { |
| return false |
| } |
| _, ok := x.OneofField.(*OtherProto2_BytesOneof) |
| return ok |
| } |
| |
| func (x *OtherProto2) HasOneofField2() bool { |
| if x == nil { |
| return false |
| } |
| return x.OneofField2 != nil |
| } |
| |
| func (x *OtherProto2) HasStringOneof2() bool { |
| if x == nil { |
| return false |
| } |
| _, ok := x.OneofField2.(*OtherProto2_StringOneof2) |
| return ok |
| } |
| |
| func (x *OtherProto2) HasIntOneof2() bool { |
| if x == nil { |
| return false |
| } |
| _, ok := x.OneofField2.(*OtherProto2_IntOneof2) |
| return ok |
| } |
| |
| func (x *OtherProto2) HasMsgOneof2() bool { |
| if x == nil { |
| return false |
| } |
| _, ok := x.OneofField2.(*OtherProto2_MsgOneof2) |
| return ok |
| } |
| |
| func (x *OtherProto2) HasEnumOneof2() bool { |
| if x == nil { |
| return false |
| } |
| _, ok := x.OneofField2.(*OtherProto2_EnumOneof2) |
| return ok |
| } |
| |
| func (x *OtherProto2) HasBytesOneof2() bool { |
| if x == nil { |
| return false |
| } |
| _, ok := x.OneofField2.(*OtherProto2_BytesOneof2) |
| return ok |
| } |
| |
| func (x *OtherProto2) HasBuild_() bool { |
| if x == nil { |
| return false |
| } |
| return x.Build != nil |
| } |
| |
| func (x *OtherProto2) HasProtoMessage() bool { |
| if x == nil { |
| return false |
| } |
| return x.ProtoMessage_ != nil |
| } |
| |
| func (x *OtherProto2) HasReset() bool { |
| if x == nil { |
| return false |
| } |
| return x.Reset_ != nil |
| } |
| |
| func (x *OtherProto2) HasString() bool { |
| if x == nil { |
| return false |
| } |
| return x.String_ != nil |
| } |
| |
| func (x *OtherProto2) HasDescriptor() bool { |
| if x == nil { |
| return false |
| } |
| return x.Descriptor_ != nil |
| } |
| |
| func (x *OtherProto2) ClearB() { |
| x.B = nil |
| } |
| |
| func (x *OtherProto2) ClearBytes() { |
| x.Bytes = nil |
| } |
| |
| func (x *OtherProto2) ClearF32() { |
| x.F32 = nil |
| } |
| |
| func (x *OtherProto2) ClearF64() { |
| x.F64 = nil |
| } |
| |
| func (x *OtherProto2) ClearI32() { |
| x.I32 = nil |
| } |
| |
| func (x *OtherProto2) ClearI64() { |
| x.I64 = nil |
| } |
| |
| func (x *OtherProto2) ClearUi32() { |
| x.Ui32 = nil |
| } |
| |
| func (x *OtherProto2) ClearUi64() { |
| x.Ui64 = nil |
| } |
| |
| func (x *OtherProto2) ClearS() { |
| x.S = nil |
| } |
| |
| func (x *OtherProto2) ClearM() { |
| x.M = nil |
| } |
| |
| func (x *OtherProto2) ClearE() { |
| x.E = nil |
| } |
| |
| func (x *OtherProto2) ClearOneofField() { |
| x.OneofField = nil |
| } |
| |
| func (x *OtherProto2) ClearStringOneof() { |
| if _, ok := x.OneofField.(*OtherProto2_StringOneof); ok { |
| x.OneofField = nil |
| } |
| } |
| |
| func (x *OtherProto2) ClearIntOneof() { |
| if _, ok := x.OneofField.(*OtherProto2_IntOneof); ok { |
| x.OneofField = nil |
| } |
| } |
| |
| func (x *OtherProto2) ClearMsgOneof() { |
| if _, ok := x.OneofField.(*OtherProto2_MsgOneof); ok { |
| x.OneofField = nil |
| } |
| } |
| |
| func (x *OtherProto2) ClearEnumOneof() { |
| if _, ok := x.OneofField.(*OtherProto2_EnumOneof); ok { |
| x.OneofField = nil |
| } |
| } |
| |
| func (x *OtherProto2) ClearBytesOneof() { |
| if _, ok := x.OneofField.(*OtherProto2_BytesOneof); ok { |
| x.OneofField = nil |
| } |
| } |
| |
| func (x *OtherProto2) ClearOneofField2() { |
| x.OneofField2 = nil |
| } |
| |
| func (x *OtherProto2) ClearStringOneof2() { |
| if _, ok := x.OneofField2.(*OtherProto2_StringOneof2); ok { |
| x.OneofField2 = nil |
| } |
| } |
| |
| func (x *OtherProto2) ClearIntOneof2() { |
| if _, ok := x.OneofField2.(*OtherProto2_IntOneof2); ok { |
| x.OneofField2 = nil |
| } |
| } |
| |
| func (x *OtherProto2) ClearMsgOneof2() { |
| if _, ok := x.OneofField2.(*OtherProto2_MsgOneof2); ok { |
| x.OneofField2 = nil |
| } |
| } |
| |
| func (x *OtherProto2) ClearEnumOneof2() { |
| if _, ok := x.OneofField2.(*OtherProto2_EnumOneof2); ok { |
| x.OneofField2 = nil |
| } |
| } |
| |
| func (x *OtherProto2) ClearBytesOneof2() { |
| if _, ok := x.OneofField2.(*OtherProto2_BytesOneof2); ok { |
| x.OneofField2 = nil |
| } |
| } |
| |
| func (x *OtherProto2) ClearBuild_() { |
| x.Build = nil |
| } |
| |
| func (x *OtherProto2) ClearProtoMessage() { |
| x.ProtoMessage_ = nil |
| } |
| |
| func (x *OtherProto2) ClearReset() { |
| x.Reset_ = nil |
| } |
| |
| func (x *OtherProto2) ClearString() { |
| x.String_ = nil |
| } |
| |
| func (x *OtherProto2) ClearDescriptor() { |
| x.Descriptor_ = nil |
| } |
| |
| const OtherProto2_OneofField_not_set_case case_OtherProto2_OneofField = 0 |
| const OtherProto2_StringOneof_case case_OtherProto2_OneofField = 14 |
| const OtherProto2_IntOneof_case case_OtherProto2_OneofField = 15 |
| const OtherProto2_MsgOneof_case case_OtherProto2_OneofField = 16 |
| const OtherProto2_EnumOneof_case case_OtherProto2_OneofField = 17 |
| const OtherProto2_BytesOneof_case case_OtherProto2_OneofField = 18 |
| |
| func (x *OtherProto2) WhichOneofField() case_OtherProto2_OneofField { |
| if x == nil { |
| return OtherProto2_OneofField_not_set_case |
| } |
| switch x.OneofField.(type) { |
| case *OtherProto2_StringOneof: |
| return OtherProto2_StringOneof_case |
| case *OtherProto2_IntOneof: |
| return OtherProto2_IntOneof_case |
| case *OtherProto2_MsgOneof: |
| return OtherProto2_MsgOneof_case |
| case *OtherProto2_EnumOneof: |
| return OtherProto2_EnumOneof_case |
| case *OtherProto2_BytesOneof: |
| return OtherProto2_BytesOneof_case |
| default: |
| return OtherProto2_OneofField_not_set_case |
| } |
| } |
| |
| const OtherProto2_OneofField2_not_set_case case_OtherProto2_OneofField2 = 0 |
| const OtherProto2_StringOneof2_case case_OtherProto2_OneofField2 = 19 |
| const OtherProto2_IntOneof2_case case_OtherProto2_OneofField2 = 20 |
| const OtherProto2_MsgOneof2_case case_OtherProto2_OneofField2 = 21 |
| const OtherProto2_EnumOneof2_case case_OtherProto2_OneofField2 = 22 |
| const OtherProto2_BytesOneof2_case case_OtherProto2_OneofField2 = 23 |
| |
| func (x *OtherProto2) WhichOneofField2() case_OtherProto2_OneofField2 { |
| if x == nil { |
| return OtherProto2_OneofField2_not_set_case |
| } |
| switch x.OneofField2.(type) { |
| case *OtherProto2_StringOneof2: |
| return OtherProto2_StringOneof2_case |
| case *OtherProto2_IntOneof2: |
| return OtherProto2_IntOneof2_case |
| case *OtherProto2_MsgOneof2: |
| return OtherProto2_MsgOneof2_case |
| case *OtherProto2_EnumOneof2: |
| return OtherProto2_EnumOneof2_case |
| case *OtherProto2_BytesOneof2: |
| return OtherProto2_BytesOneof2_case |
| default: |
| return OtherProto2_OneofField2_not_set_case |
| } |
| } |
| |
| type OtherProto2_builder struct { |
| _ [0]func() // Prevents comparability and use of unkeyed literals for the builder. |
| |
| B *bool |
| Bytes []byte |
| F32 *float32 |
| F64 *float64 |
| I32 *int32 |
| I64 *int64 |
| Ui32 *uint32 |
| Ui64 *uint64 |
| S *string |
| M *OtherProto2 |
| Is []int32 |
| Ms []*OtherProto2 |
| Map map[string]bool |
| E *OtherProto2_OtherEnum |
| // Fields of oneof OneofField: |
| StringOneof *string |
| IntOneof *int64 |
| MsgOneof *OtherProto2 |
| EnumOneof *OtherProto2_OtherEnum |
| BytesOneof []byte |
| // -- end of OneofField |
| // Fields of oneof OneofField2: |
| StringOneof2 *string |
| IntOneof2 *int64 |
| MsgOneof2 *OtherProto2 |
| EnumOneof2 *OtherProto2_OtherEnum |
| BytesOneof2 []byte |
| // -- end of OneofField2 |
| Build_ *int32 |
| ProtoMessage *int32 |
| Reset *int32 |
| String *int32 |
| Descriptor *int32 |
| } |
| |
| func (b0 OtherProto2_builder) Build() *OtherProto2 { |
| m0 := &OtherProto2{} |
| b, x := &b0, m0 |
| _, _ = b, x |
| x.B = b.B |
| x.Bytes = b.Bytes |
| x.F32 = b.F32 |
| x.F64 = b.F64 |
| x.I32 = b.I32 |
| x.I64 = b.I64 |
| x.Ui32 = b.Ui32 |
| x.Ui64 = b.Ui64 |
| x.S = b.S |
| x.M = b.M |
| x.Is = b.Is |
| x.Ms = b.Ms |
| x.Map = b.Map |
| x.E = b.E |
| if b.StringOneof != nil { |
| x.OneofField = &OtherProto2_StringOneof{*b.StringOneof} |
| } |
| if b.IntOneof != nil { |
| x.OneofField = &OtherProto2_IntOneof{*b.IntOneof} |
| } |
| if b.MsgOneof != nil { |
| x.OneofField = &OtherProto2_MsgOneof{b.MsgOneof} |
| } |
| if b.EnumOneof != nil { |
| x.OneofField = &OtherProto2_EnumOneof{*b.EnumOneof} |
| } |
| if b.BytesOneof != nil { |
| x.OneofField = &OtherProto2_BytesOneof{b.BytesOneof} |
| } |
| if b.StringOneof2 != nil { |
| x.OneofField2 = &OtherProto2_StringOneof2{*b.StringOneof2} |
| } |
| if b.IntOneof2 != nil { |
| x.OneofField2 = &OtherProto2_IntOneof2{*b.IntOneof2} |
| } |
| if b.MsgOneof2 != nil { |
| x.OneofField2 = &OtherProto2_MsgOneof2{b.MsgOneof2} |
| } |
| if b.EnumOneof2 != nil { |
| x.OneofField2 = &OtherProto2_EnumOneof2{*b.EnumOneof2} |
| } |
| if b.BytesOneof2 != nil { |
| x.OneofField2 = &OtherProto2_BytesOneof2{b.BytesOneof2} |
| } |
| x.Build = b.Build_ |
| x.ProtoMessage_ = b.ProtoMessage |
| x.Reset_ = b.Reset |
| x.String_ = b.String |
| x.Descriptor_ = b.Descriptor |
| return m0 |
| } |
| |
| type case_OtherProto2_OneofField protoreflect.FieldNumber |
| |
| func (x case_OtherProto2_OneofField) String() string { |
| md := file_proto2test_proto_msgTypes[2].Descriptor() |
| if x == 0 { |
| return "not set" |
| } |
| return protoimpl.X.MessageFieldStringOf(md, protoreflect.FieldNumber(x)) |
| } |
| |
| type case_OtherProto2_OneofField2 protoreflect.FieldNumber |
| |
| func (x case_OtherProto2_OneofField2) String() string { |
| md := file_proto2test_proto_msgTypes[2].Descriptor() |
| if x == 0 { |
| return "not set" |
| } |
| return protoimpl.X.MessageFieldStringOf(md, protoreflect.FieldNumber(x)) |
| } |
| |
| type isOtherProto2_OneofField interface { |
| isOtherProto2_OneofField() |
| } |
| |
| type OtherProto2_StringOneof struct { |
| StringOneof string `protobuf:"bytes,14,opt,name=string_oneof,json=stringOneof,oneof"` |
| } |
| |
| type OtherProto2_IntOneof struct { |
| IntOneof int64 `protobuf:"varint,15,opt,name=int_oneof,json=intOneof,oneof"` |
| } |
| |
| type OtherProto2_MsgOneof struct { |
| MsgOneof *OtherProto2 `protobuf:"bytes,16,opt,name=msg_oneof,json=msgOneof,oneof"` |
| } |
| |
| type OtherProto2_EnumOneof struct { |
| EnumOneof OtherProto2_OtherEnum `protobuf:"varint,17,opt,name=enum_oneof,json=enumOneof,enum=net.proto2.go.open2opaque.o2o.test.OtherProto2_OtherEnum,oneof"` |
| } |
| |
| type OtherProto2_BytesOneof struct { |
| BytesOneof []byte `protobuf:"bytes,18,opt,name=bytes_oneof,json=bytesOneof,oneof"` |
| } |
| |
| func (*OtherProto2_StringOneof) isOtherProto2_OneofField() {} |
| |
| func (*OtherProto2_IntOneof) isOtherProto2_OneofField() {} |
| |
| func (*OtherProto2_MsgOneof) isOtherProto2_OneofField() {} |
| |
| func (*OtherProto2_EnumOneof) isOtherProto2_OneofField() {} |
| |
| func (*OtherProto2_BytesOneof) isOtherProto2_OneofField() {} |
| |
| type isOtherProto2_OneofField2 interface { |
| isOtherProto2_OneofField2() |
| } |
| |
| type OtherProto2_StringOneof2 struct { |
| StringOneof2 string `protobuf:"bytes,19,opt,name=string_oneof2,json=stringOneof2,oneof"` |
| } |
| |
| type OtherProto2_IntOneof2 struct { |
| IntOneof2 int64 `protobuf:"varint,20,opt,name=int_oneof2,json=intOneof2,oneof"` |
| } |
| |
| type OtherProto2_MsgOneof2 struct { |
| MsgOneof2 *OtherProto2 `protobuf:"bytes,21,opt,name=msg_oneof2,json=msgOneof2,oneof"` |
| } |
| |
| type OtherProto2_EnumOneof2 struct { |
| EnumOneof2 OtherProto2_OtherEnum `protobuf:"varint,22,opt,name=enum_oneof2,json=enumOneof2,enum=net.proto2.go.open2opaque.o2o.test.OtherProto2_OtherEnum,oneof"` |
| } |
| |
| type OtherProto2_BytesOneof2 struct { |
| BytesOneof2 []byte `protobuf:"bytes,23,opt,name=bytes_oneof2,json=bytesOneof2,oneof"` |
| } |
| |
| func (*OtherProto2_StringOneof2) isOtherProto2_OneofField2() {} |
| |
| func (*OtherProto2_IntOneof2) isOtherProto2_OneofField2() {} |
| |
| func (*OtherProto2_MsgOneof2) isOtherProto2_OneofField2() {} |
| |
| func (*OtherProto2_EnumOneof2) isOtherProto2_OneofField2() {} |
| |
| func (*OtherProto2_BytesOneof2) isOtherProto2_OneofField2() {} |
| |
| type M2Outer struct { |
| state protoimpl.MessageState `protogen:"hybrid.v1"` |
| // Types that are valid to be assigned to OuterOneof: |
| // |
| // *M2Outer_InnerMsg |
| // *M2Outer_StringOneof |
| OuterOneof isM2Outer_OuterOneof `protobuf_oneof:"outer_oneof"` |
| unknownFields protoimpl.UnknownFields |
| sizeCache protoimpl.SizeCache |
| } |
| |
| func (x *M2Outer) Reset() { |
| *x = M2Outer{} |
| mi := &file_proto2test_proto_msgTypes[3] |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| ms.StoreMessageInfo(mi) |
| } |
| |
| func (x *M2Outer) String() string { |
| return protoimpl.X.MessageStringOf(x) |
| } |
| |
| func (*M2Outer) ProtoMessage() {} |
| |
| func (x *M2Outer) ProtoReflect() protoreflect.Message { |
| mi := &file_proto2test_proto_msgTypes[3] |
| if x != nil { |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| if ms.LoadMessageInfo() == nil { |
| ms.StoreMessageInfo(mi) |
| } |
| return ms |
| } |
| return mi.MessageOf(x) |
| } |
| |
| func (x *M2Outer) GetOuterOneof() isM2Outer_OuterOneof { |
| if x != nil { |
| return x.OuterOneof |
| } |
| return nil |
| } |
| |
| func (x *M2Outer) GetInnerMsg() *M2Outer_MInner { |
| if x != nil { |
| if x, ok := x.OuterOneof.(*M2Outer_InnerMsg); ok { |
| return x.InnerMsg |
| } |
| } |
| return nil |
| } |
| |
| func (x *M2Outer) GetStringOneof() string { |
| if x != nil { |
| if x, ok := x.OuterOneof.(*M2Outer_StringOneof); ok { |
| return x.StringOneof |
| } |
| } |
| return "" |
| } |
| |
| func (x *M2Outer) SetInnerMsg(v *M2Outer_MInner) { |
| if v == nil { |
| x.OuterOneof = nil |
| return |
| } |
| x.OuterOneof = &M2Outer_InnerMsg{v} |
| } |
| |
| func (x *M2Outer) SetStringOneof(v string) { |
| x.OuterOneof = &M2Outer_StringOneof{v} |
| } |
| |
| func (x *M2Outer) HasOuterOneof() bool { |
| if x == nil { |
| return false |
| } |
| return x.OuterOneof != nil |
| } |
| |
| func (x *M2Outer) HasInnerMsg() bool { |
| if x == nil { |
| return false |
| } |
| _, ok := x.OuterOneof.(*M2Outer_InnerMsg) |
| return ok |
| } |
| |
| func (x *M2Outer) HasStringOneof() bool { |
| if x == nil { |
| return false |
| } |
| _, ok := x.OuterOneof.(*M2Outer_StringOneof) |
| return ok |
| } |
| |
| func (x *M2Outer) ClearOuterOneof() { |
| x.OuterOneof = nil |
| } |
| |
| func (x *M2Outer) ClearInnerMsg() { |
| if _, ok := x.OuterOneof.(*M2Outer_InnerMsg); ok { |
| x.OuterOneof = nil |
| } |
| } |
| |
| func (x *M2Outer) ClearStringOneof() { |
| if _, ok := x.OuterOneof.(*M2Outer_StringOneof); ok { |
| x.OuterOneof = nil |
| } |
| } |
| |
| const M2Outer_OuterOneof_not_set_case case_M2Outer_OuterOneof = 0 |
| const M2Outer_InnerMsg_case case_M2Outer_OuterOneof = 1 |
| const M2Outer_StringOneof_case case_M2Outer_OuterOneof = 2 |
| |
| func (x *M2Outer) WhichOuterOneof() case_M2Outer_OuterOneof { |
| if x == nil { |
| return M2Outer_OuterOneof_not_set_case |
| } |
| switch x.OuterOneof.(type) { |
| case *M2Outer_InnerMsg: |
| return M2Outer_InnerMsg_case |
| case *M2Outer_StringOneof: |
| return M2Outer_StringOneof_case |
| default: |
| return M2Outer_OuterOneof_not_set_case |
| } |
| } |
| |
| type M2Outer_builder struct { |
| _ [0]func() // Prevents comparability and use of unkeyed literals for the builder. |
| |
| // Fields of oneof OuterOneof: |
| InnerMsg *M2Outer_MInner |
| StringOneof *string |
| // -- end of OuterOneof |
| } |
| |
| func (b0 M2Outer_builder) Build() *M2Outer { |
| m0 := &M2Outer{} |
| b, x := &b0, m0 |
| _, _ = b, x |
| if b.InnerMsg != nil { |
| x.OuterOneof = &M2Outer_InnerMsg{b.InnerMsg} |
| } |
| if b.StringOneof != nil { |
| x.OuterOneof = &M2Outer_StringOneof{*b.StringOneof} |
| } |
| return m0 |
| } |
| |
| type case_M2Outer_OuterOneof protoreflect.FieldNumber |
| |
| func (x case_M2Outer_OuterOneof) String() string { |
| md := file_proto2test_proto_msgTypes[3].Descriptor() |
| if x == 0 { |
| return "not set" |
| } |
| return protoimpl.X.MessageFieldStringOf(md, protoreflect.FieldNumber(x)) |
| } |
| |
| type isM2Outer_OuterOneof interface { |
| isM2Outer_OuterOneof() |
| } |
| |
| type M2Outer_InnerMsg struct { |
| InnerMsg *M2Outer_MInner `protobuf:"bytes,1,opt,name=inner_msg,json=innerMsg,oneof"` |
| } |
| |
| type M2Outer_StringOneof struct { |
| StringOneof string `protobuf:"bytes,2,opt,name=string_oneof,json=stringOneof,oneof"` |
| } |
| |
| func (*M2Outer_InnerMsg) isM2Outer_OuterOneof() {} |
| |
| func (*M2Outer_StringOneof) isM2Outer_OuterOneof() {} |
| |
| type ConflictingOneof struct { |
| state protoimpl.MessageState `protogen:"hybrid.v1"` |
| // Types that are valid to be assigned to Included: |
| // |
| // *ConflictingOneof_Sub_ |
| // *ConflictingOneof_Otherwise |
| Included isConflictingOneof_Included `protobuf_oneof:"included"` |
| unknownFields protoimpl.UnknownFields |
| sizeCache protoimpl.SizeCache |
| } |
| |
| func (x *ConflictingOneof) Reset() { |
| *x = ConflictingOneof{} |
| mi := &file_proto2test_proto_msgTypes[4] |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| ms.StoreMessageInfo(mi) |
| } |
| |
| func (x *ConflictingOneof) String() string { |
| return protoimpl.X.MessageStringOf(x) |
| } |
| |
| func (*ConflictingOneof) ProtoMessage() {} |
| |
| func (x *ConflictingOneof) ProtoReflect() protoreflect.Message { |
| mi := &file_proto2test_proto_msgTypes[4] |
| if x != nil { |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| if ms.LoadMessageInfo() == nil { |
| ms.StoreMessageInfo(mi) |
| } |
| return ms |
| } |
| return mi.MessageOf(x) |
| } |
| |
| func (x *ConflictingOneof) GetIncluded() isConflictingOneof_Included { |
| if x != nil { |
| return x.Included |
| } |
| return nil |
| } |
| |
| func (x *ConflictingOneof) GetSub() *ConflictingOneof_Sub { |
| if x != nil { |
| if x, ok := x.Included.(*ConflictingOneof_Sub_); ok { |
| return x.Sub |
| } |
| } |
| return nil |
| } |
| |
| func (x *ConflictingOneof) GetOtherwise() string { |
| if x != nil { |
| if x, ok := x.Included.(*ConflictingOneof_Otherwise); ok { |
| return x.Otherwise |
| } |
| } |
| return "" |
| } |
| |
| func (x *ConflictingOneof) SetSub(v *ConflictingOneof_Sub) { |
| if v == nil { |
| x.Included = nil |
| return |
| } |
| x.Included = &ConflictingOneof_Sub_{v} |
| } |
| |
| func (x *ConflictingOneof) SetOtherwise(v string) { |
| x.Included = &ConflictingOneof_Otherwise{v} |
| } |
| |
| func (x *ConflictingOneof) HasIncluded() bool { |
| if x == nil { |
| return false |
| } |
| return x.Included != nil |
| } |
| |
| func (x *ConflictingOneof) HasSub() bool { |
| if x == nil { |
| return false |
| } |
| _, ok := x.Included.(*ConflictingOneof_Sub_) |
| return ok |
| } |
| |
| func (x *ConflictingOneof) HasOtherwise() bool { |
| if x == nil { |
| return false |
| } |
| _, ok := x.Included.(*ConflictingOneof_Otherwise) |
| return ok |
| } |
| |
| func (x *ConflictingOneof) ClearIncluded() { |
| x.Included = nil |
| } |
| |
| func (x *ConflictingOneof) ClearSub() { |
| if _, ok := x.Included.(*ConflictingOneof_Sub_); ok { |
| x.Included = nil |
| } |
| } |
| |
| func (x *ConflictingOneof) ClearOtherwise() { |
| if _, ok := x.Included.(*ConflictingOneof_Otherwise); ok { |
| x.Included = nil |
| } |
| } |
| |
| const ConflictingOneof_Included_not_set_case case_ConflictingOneof_Included = 0 |
| const ConflictingOneof_Sub_case case_ConflictingOneof_Included = 1 |
| const ConflictingOneof_Otherwise_case case_ConflictingOneof_Included = 2 |
| |
| func (x *ConflictingOneof) WhichIncluded() case_ConflictingOneof_Included { |
| if x == nil { |
| return ConflictingOneof_Included_not_set_case |
| } |
| switch x.Included.(type) { |
| case *ConflictingOneof_Sub_: |
| return ConflictingOneof_Sub_case |
| case *ConflictingOneof_Otherwise: |
| return ConflictingOneof_Otherwise_case |
| default: |
| return ConflictingOneof_Included_not_set_case |
| } |
| } |
| |
| type ConflictingOneof_builder struct { |
| _ [0]func() // Prevents comparability and use of unkeyed literals for the builder. |
| |
| // Fields of oneof Included: |
| Sub *ConflictingOneof_Sub |
| Otherwise *string |
| // -- end of Included |
| } |
| |
| func (b0 ConflictingOneof_builder) Build() *ConflictingOneof { |
| m0 := &ConflictingOneof{} |
| b, x := &b0, m0 |
| _, _ = b, x |
| if b.Sub != nil { |
| x.Included = &ConflictingOneof_Sub_{b.Sub} |
| } |
| if b.Otherwise != nil { |
| x.Included = &ConflictingOneof_Otherwise{*b.Otherwise} |
| } |
| return m0 |
| } |
| |
| type case_ConflictingOneof_Included protoreflect.FieldNumber |
| |
| func (x case_ConflictingOneof_Included) String() string { |
| md := file_proto2test_proto_msgTypes[4].Descriptor() |
| if x == 0 { |
| return "not set" |
| } |
| return protoimpl.X.MessageFieldStringOf(md, protoreflect.FieldNumber(x)) |
| } |
| |
| type isConflictingOneof_Included interface { |
| isConflictingOneof_Included() |
| } |
| |
| type ConflictingOneof_Sub_ struct { |
| Sub *ConflictingOneof_Sub `protobuf:"bytes,1,opt,name=sub,oneof"` |
| } |
| |
| type ConflictingOneof_Otherwise struct { |
| Otherwise string `protobuf:"bytes,2,opt,name=otherwise,oneof"` |
| } |
| |
| func (*ConflictingOneof_Sub_) isConflictingOneof_Included() {} |
| |
| func (*ConflictingOneof_Otherwise) isConflictingOneof_Included() {} |
| |
| type SetterNameConflict struct { |
| state protoimpl.MessageState `protogen:"hybrid.v1"` |
| Stat *int32 `protobuf:"varint,1,opt,name=stat" json:"stat,omitempty"` |
| SetStat *int32 `protobuf:"varint,2,opt,name=set_stat,json=setStat" json:"set_stat,omitempty"` |
| GetStat_ *int32 `protobuf:"varint,3,opt,name=get_stat,json=getStat" json:"get_stat,omitempty"` |
| HasStat *int32 `protobuf:"varint,4,opt,name=has_stat,json=hasStat" json:"has_stat,omitempty"` |
| ClearStat *int32 `protobuf:"varint,5,opt,name=clear_stat,json=clearStat" json:"clear_stat,omitempty"` |
| unknownFields protoimpl.UnknownFields |
| sizeCache protoimpl.SizeCache |
| } |
| |
| func (x *SetterNameConflict) Reset() { |
| *x = SetterNameConflict{} |
| mi := &file_proto2test_proto_msgTypes[5] |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| ms.StoreMessageInfo(mi) |
| } |
| |
| func (x *SetterNameConflict) String() string { |
| return protoimpl.X.MessageStringOf(x) |
| } |
| |
| func (*SetterNameConflict) ProtoMessage() {} |
| |
| func (x *SetterNameConflict) ProtoReflect() protoreflect.Message { |
| mi := &file_proto2test_proto_msgTypes[5] |
| if x != nil { |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| if ms.LoadMessageInfo() == nil { |
| ms.StoreMessageInfo(mi) |
| } |
| return ms |
| } |
| return mi.MessageOf(x) |
| } |
| |
| func (x *SetterNameConflict) Get_Stat() int32 { |
| if x != nil && x.Stat != nil { |
| return *x.Stat |
| } |
| return 0 |
| } |
| |
| // Deprecated: Use Get_Stat instead. |
| func (x *SetterNameConflict) GetStat() int32 { |
| return x.Get_Stat() |
| } |
| |
| func (x *SetterNameConflict) GetSetStat() int32 { |
| if x != nil && x.SetStat != nil { |
| return *x.SetStat |
| } |
| return 0 |
| } |
| |
| func (x *SetterNameConflict) GetGetStat() int32 { |
| if x != nil && x.GetStat_ != nil { |
| return *x.GetStat_ |
| } |
| return 0 |
| } |
| |
| // Deprecated: Use GetGetStat instead. |
| func (x *SetterNameConflict) GetGetStat_() int32 { |
| return x.GetGetStat() |
| } |
| |
| func (x *SetterNameConflict) GetHasStat() int32 { |
| if x != nil && x.HasStat != nil { |
| return *x.HasStat |
| } |
| return 0 |
| } |
| |
| func (x *SetterNameConflict) GetClearStat() int32 { |
| if x != nil && x.ClearStat != nil { |
| return *x.ClearStat |
| } |
| return 0 |
| } |
| |
| func (x *SetterNameConflict) Set_Stat(v int32) { |
| x.Stat = &v |
| } |
| |
| func (x *SetterNameConflict) SetSetStat(v int32) { |
| x.SetStat = &v |
| } |
| |
| func (x *SetterNameConflict) SetGetStat(v int32) { |
| x.GetStat_ = &v |
| } |
| |
| func (x *SetterNameConflict) SetHasStat(v int32) { |
| x.HasStat = &v |
| } |
| |
| func (x *SetterNameConflict) SetClearStat(v int32) { |
| x.ClearStat = &v |
| } |
| |
| func (x *SetterNameConflict) Has_Stat() bool { |
| if x == nil { |
| return false |
| } |
| return x.Stat != nil |
| } |
| |
| func (x *SetterNameConflict) HasSetStat() bool { |
| if x == nil { |
| return false |
| } |
| return x.SetStat != nil |
| } |
| |
| func (x *SetterNameConflict) HasGetStat() bool { |
| if x == nil { |
| return false |
| } |
| return x.GetStat_ != nil |
| } |
| |
| func (x *SetterNameConflict) HasHasStat() bool { |
| if x == nil { |
| return false |
| } |
| return x.HasStat != nil |
| } |
| |
| func (x *SetterNameConflict) HasClearStat() bool { |
| if x == nil { |
| return false |
| } |
| return x.ClearStat != nil |
| } |
| |
| func (x *SetterNameConflict) Clear_Stat() { |
| x.Stat = nil |
| } |
| |
| func (x *SetterNameConflict) ClearSetStat() { |
| x.SetStat = nil |
| } |
| |
| func (x *SetterNameConflict) ClearGetStat() { |
| x.GetStat_ = nil |
| } |
| |
| func (x *SetterNameConflict) ClearHasStat() { |
| x.HasStat = nil |
| } |
| |
| func (x *SetterNameConflict) ClearClearStat() { |
| x.ClearStat = nil |
| } |
| |
| type SetterNameConflict_builder struct { |
| _ [0]func() // Prevents comparability and use of unkeyed literals for the builder. |
| |
| Stat *int32 |
| SetStat *int32 |
| GetStat *int32 |
| HasStat *int32 |
| ClearStat *int32 |
| } |
| |
| func (b0 SetterNameConflict_builder) Build() *SetterNameConflict { |
| m0 := &SetterNameConflict{} |
| b, x := &b0, m0 |
| _, _ = b, x |
| x.Stat = b.Stat |
| x.SetStat = b.SetStat |
| x.GetStat_ = b.GetStat |
| x.HasStat = b.HasStat |
| x.ClearStat = b.ClearStat |
| return m0 |
| } |
| |
| type M2Outer_MInner struct { |
| state protoimpl.MessageState `protogen:"hybrid.v1"` |
| // Types that are valid to be assigned to InnerOneof: |
| // |
| // *M2Outer_MInner_StringInner |
| // *M2Outer_MInner_IntInner |
| InnerOneof isM2Outer_MInner_InnerOneof `protobuf_oneof:"inner_oneof"` |
| unknownFields protoimpl.UnknownFields |
| sizeCache protoimpl.SizeCache |
| } |
| |
| func (x *M2Outer_MInner) Reset() { |
| *x = M2Outer_MInner{} |
| mi := &file_proto2test_proto_msgTypes[8] |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| ms.StoreMessageInfo(mi) |
| } |
| |
| func (x *M2Outer_MInner) String() string { |
| return protoimpl.X.MessageStringOf(x) |
| } |
| |
| func (*M2Outer_MInner) ProtoMessage() {} |
| |
| func (x *M2Outer_MInner) ProtoReflect() protoreflect.Message { |
| mi := &file_proto2test_proto_msgTypes[8] |
| if x != nil { |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| if ms.LoadMessageInfo() == nil { |
| ms.StoreMessageInfo(mi) |
| } |
| return ms |
| } |
| return mi.MessageOf(x) |
| } |
| |
| func (x *M2Outer_MInner) GetInnerOneof() isM2Outer_MInner_InnerOneof { |
| if x != nil { |
| return x.InnerOneof |
| } |
| return nil |
| } |
| |
| func (x *M2Outer_MInner) GetStringInner() string { |
| if x != nil { |
| if x, ok := x.InnerOneof.(*M2Outer_MInner_StringInner); ok { |
| return x.StringInner |
| } |
| } |
| return "" |
| } |
| |
| func (x *M2Outer_MInner) GetIntInner() int64 { |
| if x != nil { |
| if x, ok := x.InnerOneof.(*M2Outer_MInner_IntInner); ok { |
| return x.IntInner |
| } |
| } |
| return 0 |
| } |
| |
| func (x *M2Outer_MInner) SetStringInner(v string) { |
| x.InnerOneof = &M2Outer_MInner_StringInner{v} |
| } |
| |
| func (x *M2Outer_MInner) SetIntInner(v int64) { |
| x.InnerOneof = &M2Outer_MInner_IntInner{v} |
| } |
| |
| func (x *M2Outer_MInner) HasInnerOneof() bool { |
| if x == nil { |
| return false |
| } |
| return x.InnerOneof != nil |
| } |
| |
| func (x *M2Outer_MInner) HasStringInner() bool { |
| if x == nil { |
| return false |
| } |
| _, ok := x.InnerOneof.(*M2Outer_MInner_StringInner) |
| return ok |
| } |
| |
| func (x *M2Outer_MInner) HasIntInner() bool { |
| if x == nil { |
| return false |
| } |
| _, ok := x.InnerOneof.(*M2Outer_MInner_IntInner) |
| return ok |
| } |
| |
| func (x *M2Outer_MInner) ClearInnerOneof() { |
| x.InnerOneof = nil |
| } |
| |
| func (x *M2Outer_MInner) ClearStringInner() { |
| if _, ok := x.InnerOneof.(*M2Outer_MInner_StringInner); ok { |
| x.InnerOneof = nil |
| } |
| } |
| |
| func (x *M2Outer_MInner) ClearIntInner() { |
| if _, ok := x.InnerOneof.(*M2Outer_MInner_IntInner); ok { |
| x.InnerOneof = nil |
| } |
| } |
| |
| const M2Outer_MInner_InnerOneof_not_set_case case_M2Outer_MInner_InnerOneof = 0 |
| const M2Outer_MInner_StringInner_case case_M2Outer_MInner_InnerOneof = 19 |
| const M2Outer_MInner_IntInner_case case_M2Outer_MInner_InnerOneof = 20 |
| |
| func (x *M2Outer_MInner) WhichInnerOneof() case_M2Outer_MInner_InnerOneof { |
| if x == nil { |
| return M2Outer_MInner_InnerOneof_not_set_case |
| } |
| switch x.InnerOneof.(type) { |
| case *M2Outer_MInner_StringInner: |
| return M2Outer_MInner_StringInner_case |
| case *M2Outer_MInner_IntInner: |
| return M2Outer_MInner_IntInner_case |
| default: |
| return M2Outer_MInner_InnerOneof_not_set_case |
| } |
| } |
| |
| type M2Outer_MInner_builder struct { |
| _ [0]func() // Prevents comparability and use of unkeyed literals for the builder. |
| |
| // Fields of oneof InnerOneof: |
| StringInner *string |
| IntInner *int64 |
| // -- end of InnerOneof |
| } |
| |
| func (b0 M2Outer_MInner_builder) Build() *M2Outer_MInner { |
| m0 := &M2Outer_MInner{} |
| b, x := &b0, m0 |
| _, _ = b, x |
| if b.StringInner != nil { |
| x.InnerOneof = &M2Outer_MInner_StringInner{*b.StringInner} |
| } |
| if b.IntInner != nil { |
| x.InnerOneof = &M2Outer_MInner_IntInner{*b.IntInner} |
| } |
| return m0 |
| } |
| |
| type case_M2Outer_MInner_InnerOneof protoreflect.FieldNumber |
| |
| func (x case_M2Outer_MInner_InnerOneof) String() string { |
| md := file_proto2test_proto_msgTypes[8].Descriptor() |
| if x == 0 { |
| return "not set" |
| } |
| return protoimpl.X.MessageFieldStringOf(md, protoreflect.FieldNumber(x)) |
| } |
| |
| type isM2Outer_MInner_InnerOneof interface { |
| isM2Outer_MInner_InnerOneof() |
| } |
| |
| type M2Outer_MInner_StringInner struct { |
| StringInner string `protobuf:"bytes,19,opt,name=string_inner,json=stringInner,oneof"` |
| } |
| |
| type M2Outer_MInner_IntInner struct { |
| IntInner int64 `protobuf:"varint,20,opt,name=int_inner,json=intInner,oneof"` |
| } |
| |
| func (*M2Outer_MInner_StringInner) isM2Outer_MInner_InnerOneof() {} |
| |
| func (*M2Outer_MInner_IntInner) isM2Outer_MInner_InnerOneof() {} |
| |
| type ConflictingOneof_Sub struct { |
| state protoimpl.MessageState `protogen:"hybrid.v1"` |
| unknownFields protoimpl.UnknownFields |
| sizeCache protoimpl.SizeCache |
| } |
| |
| func (x *ConflictingOneof_Sub) Reset() { |
| *x = ConflictingOneof_Sub{} |
| mi := &file_proto2test_proto_msgTypes[9] |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| ms.StoreMessageInfo(mi) |
| } |
| |
| func (x *ConflictingOneof_Sub) String() string { |
| return protoimpl.X.MessageStringOf(x) |
| } |
| |
| func (*ConflictingOneof_Sub) ProtoMessage() {} |
| |
| func (x *ConflictingOneof_Sub) ProtoReflect() protoreflect.Message { |
| mi := &file_proto2test_proto_msgTypes[9] |
| if x != nil { |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| if ms.LoadMessageInfo() == nil { |
| ms.StoreMessageInfo(mi) |
| } |
| return ms |
| } |
| return mi.MessageOf(x) |
| } |
| |
| type ConflictingOneof_Sub_builder struct { |
| _ [0]func() // Prevents comparability and use of unkeyed literals for the builder. |
| |
| } |
| |
| func (b0 ConflictingOneof_Sub_builder) Build() *ConflictingOneof_Sub { |
| m0 := &ConflictingOneof_Sub{} |
| b, x := &b0, m0 |
| _, _ = b, x |
| return m0 |
| } |
| |
| type ConflictingOneof_DeepSub struct { |
| state protoimpl.MessageState `protogen:"hybrid.v1"` |
| // Types that are valid to be assigned to DeeplyIncluded: |
| // |
| // *ConflictingOneof_DeepSub_Sub_ |
| // *ConflictingOneof_DeepSub_Otherwise |
| DeeplyIncluded isConflictingOneof_DeepSub_DeeplyIncluded `protobuf_oneof:"deeply_included"` |
| unknownFields protoimpl.UnknownFields |
| sizeCache protoimpl.SizeCache |
| } |
| |
| func (x *ConflictingOneof_DeepSub) Reset() { |
| *x = ConflictingOneof_DeepSub{} |
| mi := &file_proto2test_proto_msgTypes[10] |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| ms.StoreMessageInfo(mi) |
| } |
| |
| func (x *ConflictingOneof_DeepSub) String() string { |
| return protoimpl.X.MessageStringOf(x) |
| } |
| |
| func (*ConflictingOneof_DeepSub) ProtoMessage() {} |
| |
| func (x *ConflictingOneof_DeepSub) ProtoReflect() protoreflect.Message { |
| mi := &file_proto2test_proto_msgTypes[10] |
| if x != nil { |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| if ms.LoadMessageInfo() == nil { |
| ms.StoreMessageInfo(mi) |
| } |
| return ms |
| } |
| return mi.MessageOf(x) |
| } |
| |
| func (x *ConflictingOneof_DeepSub) GetDeeplyIncluded() isConflictingOneof_DeepSub_DeeplyIncluded { |
| if x != nil { |
| return x.DeeplyIncluded |
| } |
| return nil |
| } |
| |
| func (x *ConflictingOneof_DeepSub) GetSub() *ConflictingOneof_DeepSub_Sub { |
| if x != nil { |
| if x, ok := x.DeeplyIncluded.(*ConflictingOneof_DeepSub_Sub_); ok { |
| return x.Sub |
| } |
| } |
| return nil |
| } |
| |
| func (x *ConflictingOneof_DeepSub) GetOtherwise() string { |
| if x != nil { |
| if x, ok := x.DeeplyIncluded.(*ConflictingOneof_DeepSub_Otherwise); ok { |
| return x.Otherwise |
| } |
| } |
| return "" |
| } |
| |
| func (x *ConflictingOneof_DeepSub) SetSub(v *ConflictingOneof_DeepSub_Sub) { |
| if v == nil { |
| x.DeeplyIncluded = nil |
| return |
| } |
| x.DeeplyIncluded = &ConflictingOneof_DeepSub_Sub_{v} |
| } |
| |
| func (x *ConflictingOneof_DeepSub) SetOtherwise(v string) { |
| x.DeeplyIncluded = &ConflictingOneof_DeepSub_Otherwise{v} |
| } |
| |
| func (x *ConflictingOneof_DeepSub) HasDeeplyIncluded() bool { |
| if x == nil { |
| return false |
| } |
| return x.DeeplyIncluded != nil |
| } |
| |
| func (x *ConflictingOneof_DeepSub) HasSub() bool { |
| if x == nil { |
| return false |
| } |
| _, ok := x.DeeplyIncluded.(*ConflictingOneof_DeepSub_Sub_) |
| return ok |
| } |
| |
| func (x *ConflictingOneof_DeepSub) HasOtherwise() bool { |
| if x == nil { |
| return false |
| } |
| _, ok := x.DeeplyIncluded.(*ConflictingOneof_DeepSub_Otherwise) |
| return ok |
| } |
| |
| func (x *ConflictingOneof_DeepSub) ClearDeeplyIncluded() { |
| x.DeeplyIncluded = nil |
| } |
| |
| func (x *ConflictingOneof_DeepSub) ClearSub() { |
| if _, ok := x.DeeplyIncluded.(*ConflictingOneof_DeepSub_Sub_); ok { |
| x.DeeplyIncluded = nil |
| } |
| } |
| |
| func (x *ConflictingOneof_DeepSub) ClearOtherwise() { |
| if _, ok := x.DeeplyIncluded.(*ConflictingOneof_DeepSub_Otherwise); ok { |
| x.DeeplyIncluded = nil |
| } |
| } |
| |
| const ConflictingOneof_DeepSub_DeeplyIncluded_not_set_case case_ConflictingOneof_DeepSub_DeeplyIncluded = 0 |
| const ConflictingOneof_DeepSub_Sub_case case_ConflictingOneof_DeepSub_DeeplyIncluded = 1 |
| const ConflictingOneof_DeepSub_Otherwise_case case_ConflictingOneof_DeepSub_DeeplyIncluded = 3 |
| |
| func (x *ConflictingOneof_DeepSub) WhichDeeplyIncluded() case_ConflictingOneof_DeepSub_DeeplyIncluded { |
| if x == nil { |
| return ConflictingOneof_DeepSub_DeeplyIncluded_not_set_case |
| } |
| switch x.DeeplyIncluded.(type) { |
| case *ConflictingOneof_DeepSub_Sub_: |
| return ConflictingOneof_DeepSub_Sub_case |
| case *ConflictingOneof_DeepSub_Otherwise: |
| return ConflictingOneof_DeepSub_Otherwise_case |
| default: |
| return ConflictingOneof_DeepSub_DeeplyIncluded_not_set_case |
| } |
| } |
| |
| type ConflictingOneof_DeepSub_builder struct { |
| _ [0]func() // Prevents comparability and use of unkeyed literals for the builder. |
| |
| // Fields of oneof DeeplyIncluded: |
| Sub *ConflictingOneof_DeepSub_Sub |
| Otherwise *string |
| // -- end of DeeplyIncluded |
| } |
| |
| func (b0 ConflictingOneof_DeepSub_builder) Build() *ConflictingOneof_DeepSub { |
| m0 := &ConflictingOneof_DeepSub{} |
| b, x := &b0, m0 |
| _, _ = b, x |
| if b.Sub != nil { |
| x.DeeplyIncluded = &ConflictingOneof_DeepSub_Sub_{b.Sub} |
| } |
| if b.Otherwise != nil { |
| x.DeeplyIncluded = &ConflictingOneof_DeepSub_Otherwise{*b.Otherwise} |
| } |
| return m0 |
| } |
| |
| type case_ConflictingOneof_DeepSub_DeeplyIncluded protoreflect.FieldNumber |
| |
| func (x case_ConflictingOneof_DeepSub_DeeplyIncluded) String() string { |
| md := file_proto2test_proto_msgTypes[10].Descriptor() |
| if x == 0 { |
| return "not set" |
| } |
| return protoimpl.X.MessageFieldStringOf(md, protoreflect.FieldNumber(x)) |
| } |
| |
| type isConflictingOneof_DeepSub_DeeplyIncluded interface { |
| isConflictingOneof_DeepSub_DeeplyIncluded() |
| } |
| |
| type ConflictingOneof_DeepSub_Sub_ struct { |
| Sub *ConflictingOneof_DeepSub_Sub `protobuf:"bytes,1,opt,name=sub,oneof"` |
| } |
| |
| type ConflictingOneof_DeepSub_Otherwise struct { |
| Otherwise string `protobuf:"bytes,3,opt,name=otherwise,oneof"` |
| } |
| |
| func (*ConflictingOneof_DeepSub_Sub_) isConflictingOneof_DeepSub_DeeplyIncluded() {} |
| |
| func (*ConflictingOneof_DeepSub_Otherwise) isConflictingOneof_DeepSub_DeeplyIncluded() {} |
| |
| type ConflictingOneof_DeepSub_Sub struct { |
| state protoimpl.MessageState `protogen:"hybrid.v1"` |
| unknownFields protoimpl.UnknownFields |
| sizeCache protoimpl.SizeCache |
| } |
| |
| func (x *ConflictingOneof_DeepSub_Sub) Reset() { |
| *x = ConflictingOneof_DeepSub_Sub{} |
| mi := &file_proto2test_proto_msgTypes[11] |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| ms.StoreMessageInfo(mi) |
| } |
| |
| func (x *ConflictingOneof_DeepSub_Sub) String() string { |
| return protoimpl.X.MessageStringOf(x) |
| } |
| |
| func (*ConflictingOneof_DeepSub_Sub) ProtoMessage() {} |
| |
| func (x *ConflictingOneof_DeepSub_Sub) ProtoReflect() protoreflect.Message { |
| mi := &file_proto2test_proto_msgTypes[11] |
| if x != nil { |
| ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) |
| if ms.LoadMessageInfo() == nil { |
| ms.StoreMessageInfo(mi) |
| } |
| return ms |
| } |
| return mi.MessageOf(x) |
| } |
| |
| type ConflictingOneof_DeepSub_Sub_builder struct { |
| _ [0]func() // Prevents comparability and use of unkeyed literals for the builder. |
| |
| } |
| |
| func (b0 ConflictingOneof_DeepSub_Sub_builder) Build() *ConflictingOneof_DeepSub_Sub { |
| m0 := &ConflictingOneof_DeepSub_Sub{} |
| b, x := &b0, m0 |
| _, _ = b, x |
| return m0 |
| } |
| |
| var File_proto2test_proto protoreflect.FileDescriptor |
| |
| const file_proto2test_proto_rawDesc = "" + |
| "\n" + |
| "\x10proto2test.proto\x12\"net.proto2.go.open2opaque.o2o.test\x1a!google/protobuf/go_features.proto\x1a\x1bgoogle/protobuf/empty.proto\"'\n" + |
| "\x0eDoNotMigrateMe\x12\f\n" + |
| "\x01b\x18\x01 \x01(\bR\x01b:\ab\x05\xd2>\x02\x10\x01\"\xdb\t\n" + |
| "\x02M2\x12\f\n" + |
| "\x01b\x18\x01 \x01(\bR\x01b\x12\x14\n" + |
| "\x05bytes\x18\x02 \x01(\fR\x05bytes\x12\x10\n" + |
| "\x03f32\x18\x03 \x01(\x02R\x03f32\x12\x10\n" + |
| "\x03f64\x18\x04 \x01(\x01R\x03f64\x12\x10\n" + |
| "\x03i32\x18\x05 \x01(\x05R\x03i32\x12\x10\n" + |
| "\x03i64\x18\x06 \x01(\x03R\x03i64\x12\x12\n" + |
| "\x04ui32\x18\a \x01(\rR\x04ui32\x12\x12\n" + |
| "\x04ui64\x18\b \x01(\x04R\x04ui64\x12\f\n" + |
| "\x01s\x18\t \x01(\tR\x01s\x124\n" + |
| "\x01m\x18\n" + |
| " \x01(\v2&.net.proto2.go.open2opaque.o2o.test.M2R\x01m\x12\x0e\n" + |
| "\x02is\x18\v \x03(\x05R\x02is\x126\n" + |
| "\x02ms\x18\f \x03(\v2&.net.proto2.go.open2opaque.o2o.test.M2R\x02ms\x12A\n" + |
| "\x03map\x18\x1d \x03(\v2/.net.proto2.go.open2opaque.o2o.test.M2.MapEntryR\x03map\x129\n" + |
| "\x01e\x18\r \x01(\x0e2+.net.proto2.go.open2opaque.o2o.test.M2.EnumR\x01e\x12#\n" + |
| "\fstring_oneof\x18\x0e \x01(\tH\x00R\vstringOneof\x12\x1d\n" + |
| "\tint_oneof\x18\x0f \x01(\x03H\x00R\bintOneof\x12E\n" + |
| "\tmsg_oneof\x18\x10 \x01(\v2&.net.proto2.go.open2opaque.o2o.test.M2H\x00R\bmsgOneof\x12L\n" + |
| "\n" + |
| "enum_oneof\x18\x11 \x01(\x0e2+.net.proto2.go.open2opaque.o2o.test.M2.EnumH\x00R\tenumOneof\x12!\n" + |
| "\vbytes_oneof\x18\x12 \x01(\fH\x00R\n" + |
| "bytesOneof\x129\n" + |
| "\vempty_oneof\x18c \x01(\v2\x16.google.protobuf.EmptyH\x00R\n" + |
| "emptyOneof\x12%\n" + |
| "\rstring_oneof2\x18\x13 \x01(\tH\x01R\fstringOneof2\x12\x1f\n" + |
| "\n" + |
| "int_oneof2\x18\x14 \x01(\x03H\x01R\tintOneof2\x12G\n" + |
| "\n" + |
| "msg_oneof2\x18\x15 \x01(\v2&.net.proto2.go.open2opaque.o2o.test.M2H\x01R\tmsgOneof2\x12N\n" + |
| "\venum_oneof2\x18\x16 \x01(\x0e2+.net.proto2.go.open2opaque.o2o.test.M2.EnumH\x01R\n" + |
| "enumOneof2\x12#\n" + |
| "\fbytes_oneof2\x18\x17 \x01(\fH\x01R\vbytesOneof2\x12\x14\n" + |
| "\x05build\x18\x18 \x01(\x05R\x05build\x12#\n" + |
| "\rproto_message\x18\x19 \x01(\x05R\fprotoMessage\x12\x14\n" + |
| "\x05reset\x18\x1a \x01(\x05R\x05reset\x12\x16\n" + |
| "\x06string\x18\x1b \x01(\x05R\x06string\x12\x1e\n" + |
| "\n" + |
| "descriptor\x18\x1c \x01(\x05R\n" + |
| "descriptor\x1a6\n" + |
| "\bMapEntry\x12\x10\n" + |
| "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + |
| "\x05value\x18\x02 \x01(\bR\x05value:\x028\x01\"\x11\n" + |
| "\x04Enum\x12\t\n" + |
| "\x05E_VAL\x10\x00:\ab\x05\xd2>\x02\x10\x02B\r\n" + |
| "\voneof_fieldB\x0e\n" + |
| "\foneof_field2\"\x85\n" + |
| "\n" + |
| "\vOtherProto2\x12\f\n" + |
| "\x01b\x18\x01 \x01(\bR\x01b\x12\x14\n" + |
| "\x05bytes\x18\x02 \x01(\fR\x05bytes\x12\x10\n" + |
| "\x03f32\x18\x03 \x01(\x02R\x03f32\x12\x10\n" + |
| "\x03f64\x18\x04 \x01(\x01R\x03f64\x12\x10\n" + |
| "\x03i32\x18\x05 \x01(\x05R\x03i32\x12\x10\n" + |
| "\x03i64\x18\x06 \x01(\x03R\x03i64\x12\x12\n" + |
| "\x04ui32\x18\a \x01(\rR\x04ui32\x12\x12\n" + |
| "\x04ui64\x18\b \x01(\x04R\x04ui64\x12\f\n" + |
| "\x01s\x18\t \x01(\tR\x01s\x12=\n" + |
| "\x01m\x18\n" + |
| " \x01(\v2/.net.proto2.go.open2opaque.o2o.test.OtherProto2R\x01m\x12\x0e\n" + |
| "\x02is\x18\v \x03(\x05R\x02is\x12?\n" + |
| "\x02ms\x18\f \x03(\v2/.net.proto2.go.open2opaque.o2o.test.OtherProto2R\x02ms\x12J\n" + |
| "\x03map\x18\x1d \x03(\v28.net.proto2.go.open2opaque.o2o.test.OtherProto2.MapEntryR\x03map\x12G\n" + |
| "\x01e\x18\r \x01(\x0e29.net.proto2.go.open2opaque.o2o.test.OtherProto2.OtherEnumR\x01e\x12#\n" + |
| "\fstring_oneof\x18\x0e \x01(\tH\x00R\vstringOneof\x12\x1d\n" + |
| "\tint_oneof\x18\x0f \x01(\x03H\x00R\bintOneof\x12N\n" + |
| "\tmsg_oneof\x18\x10 \x01(\v2/.net.proto2.go.open2opaque.o2o.test.OtherProto2H\x00R\bmsgOneof\x12Z\n" + |
| "\n" + |
| "enum_oneof\x18\x11 \x01(\x0e29.net.proto2.go.open2opaque.o2o.test.OtherProto2.OtherEnumH\x00R\tenumOneof\x12!\n" + |
| "\vbytes_oneof\x18\x12 \x01(\fH\x00R\n" + |
| "bytesOneof\x12%\n" + |
| "\rstring_oneof2\x18\x13 \x01(\tH\x01R\fstringOneof2\x12\x1f\n" + |
| "\n" + |
| "int_oneof2\x18\x14 \x01(\x03H\x01R\tintOneof2\x12P\n" + |
| "\n" + |
| "msg_oneof2\x18\x15 \x01(\v2/.net.proto2.go.open2opaque.o2o.test.OtherProto2H\x01R\tmsgOneof2\x12\\\n" + |
| "\venum_oneof2\x18\x16 \x01(\x0e29.net.proto2.go.open2opaque.o2o.test.OtherProto2.OtherEnumH\x01R\n" + |
| "enumOneof2\x12#\n" + |
| "\fbytes_oneof2\x18\x17 \x01(\fH\x01R\vbytesOneof2\x12\x14\n" + |
| "\x05build\x18\x18 \x01(\x05R\x05build\x12#\n" + |
| "\rproto_message\x18\x19 \x01(\x05R\fprotoMessage\x12\x14\n" + |
| "\x05reset\x18\x1a \x01(\x05R\x05reset\x12\x16\n" + |
| "\x06string\x18\x1b \x01(\x05R\x06string\x12\x1e\n" + |
| "\n" + |
| "descriptor\x18\x1c \x01(\x05R\n" + |
| "descriptor\x1a6\n" + |
| "\bMapEntry\x12\x10\n" + |
| "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + |
| "\x05value\x18\x02 \x01(\bR\x05value:\x028\x01\"\x16\n" + |
| "\tOtherEnum\x12\t\n" + |
| "\x05E_VAL\x10\x00:\ab\x05\xd2>\x02\x10\x02B\r\n" + |
| "\voneof_fieldB\x0e\n" + |
| "\foneof_field2\"\xff\x01\n" + |
| "\aM2Outer\x12Q\n" + |
| "\tinner_msg\x18\x01 \x01(\v22.net.proto2.go.open2opaque.o2o.test.M2Outer.MInnerH\x00R\binnerMsg\x12#\n" + |
| "\fstring_oneof\x18\x02 \x01(\tH\x00R\vstringOneof\x1ad\n" + |
| "\x06MInner\x12#\n" + |
| "\fstring_inner\x18\x13 \x01(\tH\x00R\vstringInner\x12\x1d\n" + |
| "\tint_inner\x18\x14 \x01(\x03H\x00R\bintInner:\ab\x05\xd2>\x02\x10\x02B\r\n" + |
| "\vinner_oneof:\ab\x05\xd2>\x02\x10\x02B\r\n" + |
| "\vouter_oneof\"\xd3\x02\n" + |
| "\x10ConflictingOneof\x12L\n" + |
| "\x03sub\x18\x01 \x01(\v28.net.proto2.go.open2opaque.o2o.test.ConflictingOneof.SubH\x00R\x03sub\x12\x1e\n" + |
| "\totherwise\x18\x02 \x01(\tH\x00R\totherwise\x1a\x0e\n" + |
| "\x03Sub:\ab\x05\xd2>\x02\x10\x02\x1a\xab\x01\n" + |
| "\aDeepSub\x12T\n" + |
| "\x03sub\x18\x01 \x01(\v2@.net.proto2.go.open2opaque.o2o.test.ConflictingOneof.DeepSub.SubH\x00R\x03sub\x12\x1e\n" + |
| "\totherwise\x18\x03 \x01(\tH\x00R\totherwise\x1a\x0e\n" + |
| "\x03Sub:\ab\x05\xd2>\x02\x10\x02:\ab\x05\xd2>\x02\x10\x02B\x11\n" + |
| "\x0fdeeply_included:\ab\x05\xd2>\x02\x10\x02B\n" + |
| "\n" + |
| "\bincluded\"\xa1\x01\n" + |
| "\x12SetterNameConflict\x12\x12\n" + |
| "\x04stat\x18\x01 \x01(\x05R\x04stat\x12\x19\n" + |
| "\bset_stat\x18\x02 \x01(\x05R\asetStat\x12\x19\n" + |
| "\bget_stat\x18\x03 \x01(\x05R\agetStat\x12\x19\n" + |
| "\bhas_stat\x18\x04 \x01(\x05R\ahasStat\x12\x1d\n" + |
| "\n" + |
| "clear_stat\x18\x05 \x01(\x05R\tclearStat:\ab\x05\xd2>\x02\x10\x02b\beditionsp\xe8\a" |
| |
| var ( |
| file_proto2test_proto_rawDescOnce sync.Once |
| file_proto2test_proto_rawDescData []byte |
| ) |
| |
| func file_proto2test_proto_rawDescGZIP() []byte { |
| file_proto2test_proto_rawDescOnce.Do(func() { |
| file_proto2test_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_proto2test_proto_rawDesc), len(file_proto2test_proto_rawDesc))) |
| }) |
| return file_proto2test_proto_rawDescData |
| } |
| |
| var file_proto2test_proto_enumTypes = make([]protoimpl.EnumInfo, 2) |
| var file_proto2test_proto_msgTypes = make([]protoimpl.MessageInfo, 12) |
| var file_proto2test_proto_goTypes = []any{ |
| (M2_Enum)(0), // 0: net.proto2.go.open2opaque.o2o.test.M2.Enum |
| (OtherProto2_OtherEnum)(0), // 1: net.proto2.go.open2opaque.o2o.test.OtherProto2.OtherEnum |
| (*DoNotMigrateMe)(nil), // 2: net.proto2.go.open2opaque.o2o.test.DoNotMigrateMe |
| (*M2)(nil), // 3: net.proto2.go.open2opaque.o2o.test.M2 |
| (*OtherProto2)(nil), // 4: net.proto2.go.open2opaque.o2o.test.OtherProto2 |
| (*M2Outer)(nil), // 5: net.proto2.go.open2opaque.o2o.test.M2Outer |
| (*ConflictingOneof)(nil), // 6: net.proto2.go.open2opaque.o2o.test.ConflictingOneof |
| (*SetterNameConflict)(nil), // 7: net.proto2.go.open2opaque.o2o.test.SetterNameConflict |
| nil, // 8: net.proto2.go.open2opaque.o2o.test.M2.MapEntry |
| nil, // 9: net.proto2.go.open2opaque.o2o.test.OtherProto2.MapEntry |
| (*M2Outer_MInner)(nil), // 10: net.proto2.go.open2opaque.o2o.test.M2Outer.MInner |
| (*ConflictingOneof_Sub)(nil), // 11: net.proto2.go.open2opaque.o2o.test.ConflictingOneof.Sub |
| (*ConflictingOneof_DeepSub)(nil), // 12: net.proto2.go.open2opaque.o2o.test.ConflictingOneof.DeepSub |
| (*ConflictingOneof_DeepSub_Sub)(nil), // 13: net.proto2.go.open2opaque.o2o.test.ConflictingOneof.DeepSub.Sub |
| (*emptypb.Empty)(nil), // 14: google.protobuf.Empty |
| } |
| var file_proto2test_proto_depIdxs = []int32{ |
| 3, // 0: net.proto2.go.open2opaque.o2o.test.M2.m:type_name -> net.proto2.go.open2opaque.o2o.test.M2 |
| 3, // 1: net.proto2.go.open2opaque.o2o.test.M2.ms:type_name -> net.proto2.go.open2opaque.o2o.test.M2 |
| 8, // 2: net.proto2.go.open2opaque.o2o.test.M2.map:type_name -> net.proto2.go.open2opaque.o2o.test.M2.MapEntry |
| 0, // 3: net.proto2.go.open2opaque.o2o.test.M2.e:type_name -> net.proto2.go.open2opaque.o2o.test.M2.Enum |
| 3, // 4: net.proto2.go.open2opaque.o2o.test.M2.msg_oneof:type_name -> net.proto2.go.open2opaque.o2o.test.M2 |
| 0, // 5: net.proto2.go.open2opaque.o2o.test.M2.enum_oneof:type_name -> net.proto2.go.open2opaque.o2o.test.M2.Enum |
| 14, // 6: net.proto2.go.open2opaque.o2o.test.M2.empty_oneof:type_name -> google.protobuf.Empty |
| 3, // 7: net.proto2.go.open2opaque.o2o.test.M2.msg_oneof2:type_name -> net.proto2.go.open2opaque.o2o.test.M2 |
| 0, // 8: net.proto2.go.open2opaque.o2o.test.M2.enum_oneof2:type_name -> net.proto2.go.open2opaque.o2o.test.M2.Enum |
| 4, // 9: net.proto2.go.open2opaque.o2o.test.OtherProto2.m:type_name -> net.proto2.go.open2opaque.o2o.test.OtherProto2 |
| 4, // 10: net.proto2.go.open2opaque.o2o.test.OtherProto2.ms:type_name -> net.proto2.go.open2opaque.o2o.test.OtherProto2 |
| 9, // 11: net.proto2.go.open2opaque.o2o.test.OtherProto2.map:type_name -> net.proto2.go.open2opaque.o2o.test.OtherProto2.MapEntry |
| 1, // 12: net.proto2.go.open2opaque.o2o.test.OtherProto2.e:type_name -> net.proto2.go.open2opaque.o2o.test.OtherProto2.OtherEnum |
| 4, // 13: net.proto2.go.open2opaque.o2o.test.OtherProto2.msg_oneof:type_name -> net.proto2.go.open2opaque.o2o.test.OtherProto2 |
| 1, // 14: net.proto2.go.open2opaque.o2o.test.OtherProto2.enum_oneof:type_name -> net.proto2.go.open2opaque.o2o.test.OtherProto2.OtherEnum |
| 4, // 15: net.proto2.go.open2opaque.o2o.test.OtherProto2.msg_oneof2:type_name -> net.proto2.go.open2opaque.o2o.test.OtherProto2 |
| 1, // 16: net.proto2.go.open2opaque.o2o.test.OtherProto2.enum_oneof2:type_name -> net.proto2.go.open2opaque.o2o.test.OtherProto2.OtherEnum |
| 10, // 17: net.proto2.go.open2opaque.o2o.test.M2Outer.inner_msg:type_name -> net.proto2.go.open2opaque.o2o.test.M2Outer.MInner |
| 11, // 18: net.proto2.go.open2opaque.o2o.test.ConflictingOneof.sub:type_name -> net.proto2.go.open2opaque.o2o.test.ConflictingOneof.Sub |
| 13, // 19: net.proto2.go.open2opaque.o2o.test.ConflictingOneof.DeepSub.sub:type_name -> net.proto2.go.open2opaque.o2o.test.ConflictingOneof.DeepSub.Sub |
| 20, // [20:20] is the sub-list for method output_type |
| 20, // [20:20] is the sub-list for method input_type |
| 20, // [20:20] is the sub-list for extension type_name |
| 20, // [20:20] is the sub-list for extension extendee |
| 0, // [0:20] is the sub-list for field type_name |
| } |
| |
| func init() { file_proto2test_proto_init() } |
| func file_proto2test_proto_init() { |
| if File_proto2test_proto != nil { |
| return |
| } |
| file_proto2test_proto_msgTypes[1].OneofWrappers = []any{ |
| (*M2_StringOneof)(nil), |
| (*M2_IntOneof)(nil), |
| (*M2_MsgOneof)(nil), |
| (*M2_EnumOneof)(nil), |
| (*M2_BytesOneof)(nil), |
| (*M2_EmptyOneof)(nil), |
| (*M2_StringOneof2)(nil), |
| (*M2_IntOneof2)(nil), |
| (*M2_MsgOneof2)(nil), |
| (*M2_EnumOneof2)(nil), |
| (*M2_BytesOneof2)(nil), |
| } |
| file_proto2test_proto_msgTypes[2].OneofWrappers = []any{ |
| (*OtherProto2_StringOneof)(nil), |
| (*OtherProto2_IntOneof)(nil), |
| (*OtherProto2_MsgOneof)(nil), |
| (*OtherProto2_EnumOneof)(nil), |
| (*OtherProto2_BytesOneof)(nil), |
| (*OtherProto2_StringOneof2)(nil), |
| (*OtherProto2_IntOneof2)(nil), |
| (*OtherProto2_MsgOneof2)(nil), |
| (*OtherProto2_EnumOneof2)(nil), |
| (*OtherProto2_BytesOneof2)(nil), |
| } |
| file_proto2test_proto_msgTypes[3].OneofWrappers = []any{ |
| (*M2Outer_InnerMsg)(nil), |
| (*M2Outer_StringOneof)(nil), |
| } |
| file_proto2test_proto_msgTypes[4].OneofWrappers = []any{ |
| (*ConflictingOneof_Sub_)(nil), |
| (*ConflictingOneof_Otherwise)(nil), |
| } |
| file_proto2test_proto_msgTypes[8].OneofWrappers = []any{ |
| (*M2Outer_MInner_StringInner)(nil), |
| (*M2Outer_MInner_IntInner)(nil), |
| } |
| file_proto2test_proto_msgTypes[10].OneofWrappers = []any{ |
| (*ConflictingOneof_DeepSub_Sub_)(nil), |
| (*ConflictingOneof_DeepSub_Otherwise)(nil), |
| } |
| type x struct{} |
| out := protoimpl.TypeBuilder{ |
| File: protoimpl.DescBuilder{ |
| GoPackagePath: reflect.TypeOf(x{}).PkgPath(), |
| RawDescriptor: unsafe.Slice(unsafe.StringData(file_proto2test_proto_rawDesc), len(file_proto2test_proto_rawDesc)), |
| NumEnums: 2, |
| NumMessages: 12, |
| NumExtensions: 0, |
| NumServices: 0, |
| }, |
| GoTypes: file_proto2test_proto_goTypes, |
| DependencyIndexes: file_proto2test_proto_depIdxs, |
| EnumInfos: file_proto2test_proto_enumTypes, |
| MessageInfos: file_proto2test_proto_msgTypes, |
| }.Build() |
| File_proto2test_proto = out.File |
| file_proto2test_proto_goTypes = nil |
| file_proto2test_proto_depIdxs = nil |
| } |