// Code generated by protoc-gen-go-vtproto. DO NOT EDIT. // protoc-gen-go-vtproto version: (devel) // source: unsafe/unsafe.proto package unsafe import ( fmt "fmt" protohelpers "github.com/planetscale/vtprotobuf/protohelpers" proto "google.golang.org/protobuf/proto" protoimpl "google.golang.org/protobuf/runtime/protoimpl" io "io" 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) ) func (m *UnsafeTest_Sub1) CloneVT() *UnsafeTest_Sub1 { if m == nil { return (*UnsafeTest_Sub1)(nil) } r := new(UnsafeTest_Sub1) r.S = m.S if rhs := m.B; rhs != nil { tmpBytes := make([]byte, len(rhs)) copy(tmpBytes, rhs) r.B = tmpBytes } if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) } return r } func (m *UnsafeTest_Sub1) CloneMessageVT() proto.Message { return m.CloneVT() } func (m *UnsafeTest_Sub2) CloneVT() *UnsafeTest_Sub2 { if m == nil { return (*UnsafeTest_Sub2)(nil) } r := new(UnsafeTest_Sub2) if rhs := m.S; rhs != nil { tmpContainer := make([]string, len(rhs)) copy(tmpContainer, rhs) r.S = tmpContainer } if rhs := m.B; rhs != nil { tmpContainer := make([][]byte, len(rhs)) for k, v := range rhs { tmpBytes := make([]byte, len(v)) copy(tmpBytes, v) tmpContainer[k] = tmpBytes } r.B = tmpContainer } if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) } return r } func (m *UnsafeTest_Sub2) CloneMessageVT() proto.Message { return m.CloneVT() } func (m *UnsafeTest_Sub3) CloneVT() *UnsafeTest_Sub3 { if m == nil { return (*UnsafeTest_Sub3)(nil) } r := new(UnsafeTest_Sub3) if rhs := m.Foo; rhs != nil { tmpContainer := make(map[string][]byte, len(rhs)) for k, v := range rhs { tmpBytes := make([]byte, len(v)) copy(tmpBytes, v) tmpContainer[k] = tmpBytes } r.Foo = tmpContainer } if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) } return r } func (m *UnsafeTest_Sub3) CloneMessageVT() proto.Message { return m.CloneVT() } func (m *UnsafeTest_Sub4) CloneVT() *UnsafeTest_Sub4 { if m == nil { return (*UnsafeTest_Sub4)(nil) } r := new(UnsafeTest_Sub4) if m.Foo != nil { r.Foo = m.Foo.(interface{ CloneVT() isUnsafeTest_Sub4_Foo }).CloneVT() } if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) } return r } func (m *UnsafeTest_Sub4) CloneMessageVT() proto.Message { return m.CloneVT() } func (m *UnsafeTest_Sub4_S) CloneVT() isUnsafeTest_Sub4_Foo { if m == nil { return (*UnsafeTest_Sub4_S)(nil) } r := new(UnsafeTest_Sub4_S) r.S = m.S return r } func (m *UnsafeTest_Sub4_B) CloneVT() isUnsafeTest_Sub4_Foo { if m == nil { return (*UnsafeTest_Sub4_B)(nil) } r := new(UnsafeTest_Sub4_B) if rhs := m.B; rhs != nil { tmpBytes := make([]byte, len(rhs)) copy(tmpBytes, rhs) r.B = tmpBytes } return r } func (m *UnsafeTest_Sub5) CloneVT() *UnsafeTest_Sub5 { if m == nil { return (*UnsafeTest_Sub5)(nil) } r := new(UnsafeTest_Sub5) if rhs := m.Foo; rhs != nil { tmpContainer := make(map[string]string, len(rhs)) for k, v := range rhs { tmpContainer[k] = v } r.Foo = tmpContainer } if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) } return r } func (m *UnsafeTest_Sub5) CloneMessageVT() proto.Message { return m.CloneVT() } func (m *UnsafeTest) CloneVT() *UnsafeTest { if m == nil { return (*UnsafeTest)(nil) } r := new(UnsafeTest) if m.Sub != nil { r.Sub = m.Sub.(interface{ CloneVT() isUnsafeTest_Sub }).CloneVT() } if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) } return r } func (m *UnsafeTest) CloneMessageVT() proto.Message { return m.CloneVT() } func (m *UnsafeTest_Sub1_) CloneVT() isUnsafeTest_Sub { if m == nil { return (*UnsafeTest_Sub1_)(nil) } r := new(UnsafeTest_Sub1_) r.Sub1 = m.Sub1.CloneVT() return r } func (m *UnsafeTest_Sub2_) CloneVT() isUnsafeTest_Sub { if m == nil { return (*UnsafeTest_Sub2_)(nil) } r := new(UnsafeTest_Sub2_) r.Sub2 = m.Sub2.CloneVT() return r } func (m *UnsafeTest_Sub3_) CloneVT() isUnsafeTest_Sub { if m == nil { return (*UnsafeTest_Sub3_)(nil) } r := new(UnsafeTest_Sub3_) r.Sub3 = m.Sub3.CloneVT() return r } func (m *UnsafeTest_Sub4_) CloneVT() isUnsafeTest_Sub { if m == nil { return (*UnsafeTest_Sub4_)(nil) } r := new(UnsafeTest_Sub4_) r.Sub4 = m.Sub4.CloneVT() return r } func (m *UnsafeTest_Sub5_) CloneVT() isUnsafeTest_Sub { if m == nil { return (*UnsafeTest_Sub5_)(nil) } r := new(UnsafeTest_Sub5_) r.Sub5 = m.Sub5.CloneVT() return r } func (this *UnsafeTest_Sub1) EqualVT(that *UnsafeTest_Sub1) bool { if this == that { return true } else if this == nil || that == nil { return false } if this.S != that.S { return false } if string(this.B) != string(that.B) { return false } return string(this.unknownFields) == string(that.unknownFields) } func (this *UnsafeTest_Sub1) EqualMessageVT(thatMsg proto.Message) bool { that, ok := thatMsg.(*UnsafeTest_Sub1) if !ok { return false } return this.EqualVT(that) } func (this *UnsafeTest_Sub2) EqualVT(that *UnsafeTest_Sub2) bool { if this == that { return true } else if this == nil || that == nil { return false } if len(this.S) != len(that.S) { return false } for i, vx := range this.S { vy := that.S[i] if vx != vy { return false } } if len(this.B) != len(that.B) { return false } for i, vx := range this.B { vy := that.B[i] if string(vx) != string(vy) { return false } } return string(this.unknownFields) == string(that.unknownFields) } func (this *UnsafeTest_Sub2) EqualMessageVT(thatMsg proto.Message) bool { that, ok := thatMsg.(*UnsafeTest_Sub2) if !ok { return false } return this.EqualVT(that) } func (this *UnsafeTest_Sub3) EqualVT(that *UnsafeTest_Sub3) bool { if this == that { return true } else if this == nil || that == nil { return false } if len(this.Foo) != len(that.Foo) { return false } for i, vx := range this.Foo { vy, ok := that.Foo[i] if !ok { return false } if string(vx) != string(vy) { return false } } return string(this.unknownFields) == string(that.unknownFields) } func (this *UnsafeTest_Sub3) EqualMessageVT(thatMsg proto.Message) bool { that, ok := thatMsg.(*UnsafeTest_Sub3) if !ok { return false } return this.EqualVT(that) } func (this *UnsafeTest_Sub4) EqualVT(that *UnsafeTest_Sub4) bool { if this == that { return true } else if this == nil || that == nil { return false } if this.Foo == nil && that.Foo != nil { return false } else if this.Foo != nil { if that.Foo == nil { return false } if !this.Foo.(interface { EqualVT(isUnsafeTest_Sub4_Foo) bool }).EqualVT(that.Foo) { return false } } return string(this.unknownFields) == string(that.unknownFields) } func (this *UnsafeTest_Sub4) EqualMessageVT(thatMsg proto.Message) bool { that, ok := thatMsg.(*UnsafeTest_Sub4) if !ok { return false } return this.EqualVT(that) } func (this *UnsafeTest_Sub4_S) EqualVT(thatIface isUnsafeTest_Sub4_Foo) bool { that, ok := thatIface.(*UnsafeTest_Sub4_S) if !ok { return false } if this == that { return true } if this == nil && that != nil || this != nil && that == nil { return false } if this.S != that.S { return false } return true } func (this *UnsafeTest_Sub4_B) EqualVT(thatIface isUnsafeTest_Sub4_Foo) bool { that, ok := thatIface.(*UnsafeTest_Sub4_B) if !ok { return false } if this == that { return true } if this == nil && that != nil || this != nil && that == nil { return false } if string(this.B) != string(that.B) { return false } return true } func (this *UnsafeTest_Sub5) EqualVT(that *UnsafeTest_Sub5) bool { if this == that { return true } else if this == nil || that == nil { return false } if len(this.Foo) != len(that.Foo) { return false } for i, vx := range this.Foo { vy, ok := that.Foo[i] if !ok { return false } if vx != vy { return false } } return string(this.unknownFields) == string(that.unknownFields) } func (this *UnsafeTest_Sub5) EqualMessageVT(thatMsg proto.Message) bool { that, ok := thatMsg.(*UnsafeTest_Sub5) if !ok { return false } return this.EqualVT(that) } func (this *UnsafeTest) EqualVT(that *UnsafeTest) bool { if this == that { return true } else if this == nil || that == nil { return false } if this.Sub == nil && that.Sub != nil { return false } else if this.Sub != nil { if that.Sub == nil { return false } if !this.Sub.(interface{ EqualVT(isUnsafeTest_Sub) bool }).EqualVT(that.Sub) { return false } } return string(this.unknownFields) == string(that.unknownFields) } func (this *UnsafeTest) EqualMessageVT(thatMsg proto.Message) bool { that, ok := thatMsg.(*UnsafeTest) if !ok { return false } return this.EqualVT(that) } func (this *UnsafeTest_Sub1_) EqualVT(thatIface isUnsafeTest_Sub) bool { that, ok := thatIface.(*UnsafeTest_Sub1_) if !ok { return false } if this == that { return true } if this == nil && that != nil || this != nil && that == nil { return false } if p, q := this.Sub1, that.Sub1; p != q { if p == nil { p = &UnsafeTest_Sub1{} } if q == nil { q = &UnsafeTest_Sub1{} } if !p.EqualVT(q) { return false } } return true } func (this *UnsafeTest_Sub2_) EqualVT(thatIface isUnsafeTest_Sub) bool { that, ok := thatIface.(*UnsafeTest_Sub2_) if !ok { return false } if this == that { return true } if this == nil && that != nil || this != nil && that == nil { return false } if p, q := this.Sub2, that.Sub2; p != q { if p == nil { p = &UnsafeTest_Sub2{} } if q == nil { q = &UnsafeTest_Sub2{} } if !p.EqualVT(q) { return false } } return true } func (this *UnsafeTest_Sub3_) EqualVT(thatIface isUnsafeTest_Sub) bool { that, ok := thatIface.(*UnsafeTest_Sub3_) if !ok { return false } if this == that { return true } if this == nil && that != nil || this != nil && that == nil { return false } if p, q := this.Sub3, that.Sub3; p != q { if p == nil { p = &UnsafeTest_Sub3{} } if q == nil { q = &UnsafeTest_Sub3{} } if !p.EqualVT(q) { return false } } return true } func (this *UnsafeTest_Sub4_) EqualVT(thatIface isUnsafeTest_Sub) bool { that, ok := thatIface.(*UnsafeTest_Sub4_) if !ok { return false } if this == that { return true } if this == nil && that != nil || this != nil && that == nil { return false } if p, q := this.Sub4, that.Sub4; p != q { if p == nil { p = &UnsafeTest_Sub4{} } if q == nil { q = &UnsafeTest_Sub4{} } if !p.EqualVT(q) { return false } } return true } func (this *UnsafeTest_Sub5_) EqualVT(thatIface isUnsafeTest_Sub) bool { that, ok := thatIface.(*UnsafeTest_Sub5_) if !ok { return false } if this == that { return true } if this == nil && that != nil || this != nil && that == nil { return false } if p, q := this.Sub5, that.Sub5; p != q { if p == nil { p = &UnsafeTest_Sub5{} } if q == nil { q = &UnsafeTest_Sub5{} } if !p.EqualVT(q) { return false } } return true } func (m *UnsafeTest_Sub1) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVT(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *UnsafeTest_Sub1) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *UnsafeTest_Sub1) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } if len(m.B) > 0 { i -= len(m.B) copy(dAtA[i:], m.B) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.B))) i-- dAtA[i] = 0x12 } if len(m.S) > 0 { i -= len(m.S) copy(dAtA[i:], m.S) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.S))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *UnsafeTest_Sub2) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVT(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *UnsafeTest_Sub2) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *UnsafeTest_Sub2) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } if len(m.B) > 0 { for iNdEx := len(m.B) - 1; iNdEx >= 0; iNdEx-- { i -= len(m.B[iNdEx]) copy(dAtA[i:], m.B[iNdEx]) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.B[iNdEx]))) i-- dAtA[i] = 0x12 } } if len(m.S) > 0 { for iNdEx := len(m.S) - 1; iNdEx >= 0; iNdEx-- { i -= len(m.S[iNdEx]) copy(dAtA[i:], m.S[iNdEx]) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.S[iNdEx]))) i-- dAtA[i] = 0xa } } return len(dAtA) - i, nil } func (m *UnsafeTest_Sub3) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVT(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *UnsafeTest_Sub3) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *UnsafeTest_Sub3) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } if len(m.Foo) > 0 { for k := range m.Foo { v := m.Foo[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0xa } } return len(dAtA) - i, nil } func (m *UnsafeTest_Sub4) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVT(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *UnsafeTest_Sub4) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *UnsafeTest_Sub4) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } if vtmsg, ok := m.Foo.(interface { MarshalToSizedBufferVT([]byte) (int, error) }); ok { size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size } return len(dAtA) - i, nil } func (m *UnsafeTest_Sub4_S) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *UnsafeTest_Sub4_S) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i := len(dAtA) i -= len(m.S) copy(dAtA[i:], m.S) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.S))) i-- dAtA[i] = 0xa return len(dAtA) - i, nil } func (m *UnsafeTest_Sub4_B) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *UnsafeTest_Sub4_B) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i := len(dAtA) i -= len(m.B) copy(dAtA[i:], m.B) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.B))) i-- dAtA[i] = 0x12 return len(dAtA) - i, nil } func (m *UnsafeTest_Sub5) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVT(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *UnsafeTest_Sub5) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *UnsafeTest_Sub5) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } if len(m.Foo) > 0 { for k := range m.Foo { v := m.Foo[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0xa } } return len(dAtA) - i, nil } func (m *UnsafeTest) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVT(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *UnsafeTest) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *UnsafeTest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } if vtmsg, ok := m.Sub.(interface { MarshalToSizedBufferVT([]byte) (int, error) }); ok { size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size } return len(dAtA) - i, nil } func (m *UnsafeTest_Sub1_) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *UnsafeTest_Sub1_) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i := len(dAtA) if m.Sub1 != nil { size, err := m.Sub1.MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *UnsafeTest_Sub2_) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *UnsafeTest_Sub2_) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i := len(dAtA) if m.Sub2 != nil { size, err := m.Sub2.MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0x12 } return len(dAtA) - i, nil } func (m *UnsafeTest_Sub3_) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *UnsafeTest_Sub3_) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i := len(dAtA) if m.Sub3 != nil { size, err := m.Sub3.MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0x1a } return len(dAtA) - i, nil } func (m *UnsafeTest_Sub4_) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *UnsafeTest_Sub4_) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i := len(dAtA) if m.Sub4 != nil { size, err := m.Sub4.MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0x22 } return len(dAtA) - i, nil } func (m *UnsafeTest_Sub5_) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } func (m *UnsafeTest_Sub5_) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i := len(dAtA) if m.Sub5 != nil { size, err := m.Sub5.MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0x2a } return len(dAtA) - i, nil } func (m *UnsafeTest_Sub1) MarshalVTStrict() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *UnsafeTest_Sub1) MarshalToVTStrict(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVTStrict(dAtA[:size]) } func (m *UnsafeTest_Sub1) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } if len(m.B) > 0 { i -= len(m.B) copy(dAtA[i:], m.B) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.B))) i-- dAtA[i] = 0x12 } if len(m.S) > 0 { i -= len(m.S) copy(dAtA[i:], m.S) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.S))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *UnsafeTest_Sub2) MarshalVTStrict() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *UnsafeTest_Sub2) MarshalToVTStrict(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVTStrict(dAtA[:size]) } func (m *UnsafeTest_Sub2) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } if len(m.B) > 0 { for iNdEx := len(m.B) - 1; iNdEx >= 0; iNdEx-- { i -= len(m.B[iNdEx]) copy(dAtA[i:], m.B[iNdEx]) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.B[iNdEx]))) i-- dAtA[i] = 0x12 } } if len(m.S) > 0 { for iNdEx := len(m.S) - 1; iNdEx >= 0; iNdEx-- { i -= len(m.S[iNdEx]) copy(dAtA[i:], m.S[iNdEx]) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.S[iNdEx]))) i-- dAtA[i] = 0xa } } return len(dAtA) - i, nil } func (m *UnsafeTest_Sub3) MarshalVTStrict() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *UnsafeTest_Sub3) MarshalToVTStrict(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVTStrict(dAtA[:size]) } func (m *UnsafeTest_Sub3) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } if len(m.Foo) > 0 { for k := range m.Foo { v := m.Foo[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0xa } } return len(dAtA) - i, nil } func (m *UnsafeTest_Sub4) MarshalVTStrict() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *UnsafeTest_Sub4) MarshalToVTStrict(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVTStrict(dAtA[:size]) } func (m *UnsafeTest_Sub4) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } if msg, ok := m.Foo.(*UnsafeTest_Sub4_B); ok { size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i]) if err != nil { return 0, err } i -= size } if msg, ok := m.Foo.(*UnsafeTest_Sub4_S); ok { size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i]) if err != nil { return 0, err } i -= size } return len(dAtA) - i, nil } func (m *UnsafeTest_Sub4_S) MarshalToVTStrict(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVTStrict(dAtA[:size]) } func (m *UnsafeTest_Sub4_S) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) { i := len(dAtA) i -= len(m.S) copy(dAtA[i:], m.S) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.S))) i-- dAtA[i] = 0xa return len(dAtA) - i, nil } func (m *UnsafeTest_Sub4_B) MarshalToVTStrict(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVTStrict(dAtA[:size]) } func (m *UnsafeTest_Sub4_B) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) { i := len(dAtA) i -= len(m.B) copy(dAtA[i:], m.B) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.B))) i-- dAtA[i] = 0x12 return len(dAtA) - i, nil } func (m *UnsafeTest_Sub5) MarshalVTStrict() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *UnsafeTest_Sub5) MarshalToVTStrict(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVTStrict(dAtA[:size]) } func (m *UnsafeTest_Sub5) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } if len(m.Foo) > 0 { for k := range m.Foo { v := m.Foo[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0xa } } return len(dAtA) - i, nil } func (m *UnsafeTest) MarshalVTStrict() (dAtA []byte, err error) { if m == nil { return nil, nil } size := m.SizeVT() dAtA = make([]byte, size) n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *UnsafeTest) MarshalToVTStrict(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVTStrict(dAtA[:size]) } func (m *UnsafeTest) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) { if m == nil { return 0, nil } i := len(dAtA) _ = i var l int _ = l if m.unknownFields != nil { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } if msg, ok := m.Sub.(*UnsafeTest_Sub5_); ok { size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i]) if err != nil { return 0, err } i -= size } if msg, ok := m.Sub.(*UnsafeTest_Sub4_); ok { size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i]) if err != nil { return 0, err } i -= size } if msg, ok := m.Sub.(*UnsafeTest_Sub3_); ok { size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i]) if err != nil { return 0, err } i -= size } if msg, ok := m.Sub.(*UnsafeTest_Sub2_); ok { size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i]) if err != nil { return 0, err } i -= size } if msg, ok := m.Sub.(*UnsafeTest_Sub1_); ok { size, err := msg.MarshalToSizedBufferVTStrict(dAtA[:i]) if err != nil { return 0, err } i -= size } return len(dAtA) - i, nil } func (m *UnsafeTest_Sub1_) MarshalToVTStrict(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVTStrict(dAtA[:size]) } func (m *UnsafeTest_Sub1_) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) { i := len(dAtA) if m.Sub1 != nil { size, err := m.Sub1.MarshalToSizedBufferVTStrict(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *UnsafeTest_Sub2_) MarshalToVTStrict(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVTStrict(dAtA[:size]) } func (m *UnsafeTest_Sub2_) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) { i := len(dAtA) if m.Sub2 != nil { size, err := m.Sub2.MarshalToSizedBufferVTStrict(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0x12 } return len(dAtA) - i, nil } func (m *UnsafeTest_Sub3_) MarshalToVTStrict(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVTStrict(dAtA[:size]) } func (m *UnsafeTest_Sub3_) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) { i := len(dAtA) if m.Sub3 != nil { size, err := m.Sub3.MarshalToSizedBufferVTStrict(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0x1a } return len(dAtA) - i, nil } func (m *UnsafeTest_Sub4_) MarshalToVTStrict(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVTStrict(dAtA[:size]) } func (m *UnsafeTest_Sub4_) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) { i := len(dAtA) if m.Sub4 != nil { size, err := m.Sub4.MarshalToSizedBufferVTStrict(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0x22 } return len(dAtA) - i, nil } func (m *UnsafeTest_Sub5_) MarshalToVTStrict(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVTStrict(dAtA[:size]) } func (m *UnsafeTest_Sub5_) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) { i := len(dAtA) if m.Sub5 != nil { size, err := m.Sub5.MarshalToSizedBufferVTStrict(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0x2a } return len(dAtA) - i, nil } func (m *UnsafeTest_Sub1) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.S) if l > 0 { n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } l = len(m.B) if l > 0 { n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } n += len(m.unknownFields) return n } func (m *UnsafeTest_Sub2) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l if len(m.S) > 0 { for _, s := range m.S { l = len(s) n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } } if len(m.B) > 0 { for _, b := range m.B { l = len(b) n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } } n += len(m.unknownFields) return n } func (m *UnsafeTest_Sub3) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l if len(m.Foo) > 0 { for k, v := range m.Foo { _ = k _ = v l = 1 + len(v) + protohelpers.SizeOfVarint(uint64(len(v))) mapEntrySize := 1 + len(k) + protohelpers.SizeOfVarint(uint64(len(k))) + l n += mapEntrySize + 1 + protohelpers.SizeOfVarint(uint64(mapEntrySize)) } } n += len(m.unknownFields) return n } func (m *UnsafeTest_Sub4) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l if vtmsg, ok := m.Foo.(interface{ SizeVT() int }); ok { n += vtmsg.SizeVT() } n += len(m.unknownFields) return n } func (m *UnsafeTest_Sub4_S) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.S) n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) return n } func (m *UnsafeTest_Sub4_B) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.B) n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) return n } func (m *UnsafeTest_Sub5) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l if len(m.Foo) > 0 { for k, v := range m.Foo { _ = k _ = v mapEntrySize := 1 + len(k) + protohelpers.SizeOfVarint(uint64(len(k))) + 1 + len(v) + protohelpers.SizeOfVarint(uint64(len(v))) n += mapEntrySize + 1 + protohelpers.SizeOfVarint(uint64(mapEntrySize)) } } n += len(m.unknownFields) return n } func (m *UnsafeTest) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l if vtmsg, ok := m.Sub.(interface{ SizeVT() int }); ok { n += vtmsg.SizeVT() } n += len(m.unknownFields) return n } func (m *UnsafeTest_Sub1_) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l if m.Sub1 != nil { l = m.Sub1.SizeVT() n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } return n } func (m *UnsafeTest_Sub2_) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l if m.Sub2 != nil { l = m.Sub2.SizeVT() n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } return n } func (m *UnsafeTest_Sub3_) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l if m.Sub3 != nil { l = m.Sub3.SizeVT() n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } return n } func (m *UnsafeTest_Sub4_) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l if m.Sub4 != nil { l = m.Sub4.SizeVT() n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } return n } func (m *UnsafeTest_Sub5_) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l if m.Sub5 != nil { l = m.Sub5.SizeVT() n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } return n } func (m *UnsafeTest_Sub1) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: UnsafeTest_Sub1: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: UnsafeTest_Sub1: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field S", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + intStringLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.S = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field B", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + byteLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.B = append(m.B[:0], dAtA[iNdEx:postIndex]...) if m.B == nil { m.B = []byte{} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *UnsafeTest_Sub2) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: UnsafeTest_Sub2: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: UnsafeTest_Sub2: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field S", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + intStringLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.S = append(m.S, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field B", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + byteLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.B = append(m.B, make([]byte, postIndex-iNdEx)) copy(m.B[len(m.B)-1], dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *UnsafeTest_Sub3) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: UnsafeTest_Sub3: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: UnsafeTest_Sub3: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Foo", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } if m.Foo == nil { m.Foo = make(map[string][]byte) } var mapkey string var mapvalue []byte for iNdEx < postIndex { entryPreIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return protohelpers.ErrInvalidLength } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return protohelpers.ErrInvalidLength } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var mapbyteLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ mapbyteLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intMapbyteLen := int(mapbyteLen) if intMapbyteLen < 0 { return protohelpers.ErrInvalidLength } postbytesIndex := iNdEx + intMapbyteLen if postbytesIndex < 0 { return protohelpers.ErrInvalidLength } if postbytesIndex > l { return io.ErrUnexpectedEOF } mapvalue = make([]byte, mapbyteLen) copy(mapvalue, dAtA[iNdEx:postbytesIndex]) iNdEx = postbytesIndex } else { iNdEx = entryPreIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Foo[mapkey] = mapvalue iNdEx = postIndex default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *UnsafeTest_Sub4) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: UnsafeTest_Sub4: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: UnsafeTest_Sub4: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field S", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + intStringLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.Foo = &UnsafeTest_Sub4_S{S: string(dAtA[iNdEx:postIndex])} iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field B", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + byteLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } v := make([]byte, postIndex-iNdEx) copy(v, dAtA[iNdEx:postIndex]) m.Foo = &UnsafeTest_Sub4_B{B: v} iNdEx = postIndex default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *UnsafeTest_Sub5) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: UnsafeTest_Sub5: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: UnsafeTest_Sub5: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Foo", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } if m.Foo == nil { m.Foo = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return protohelpers.ErrInvalidLength } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return protohelpers.ErrInvalidLength } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return protohelpers.ErrInvalidLength } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return protohelpers.ErrInvalidLength } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Foo[mapkey] = mapvalue iNdEx = postIndex default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *UnsafeTest) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: UnsafeTest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: UnsafeTest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Sub1", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } if oneof, ok := m.Sub.(*UnsafeTest_Sub1_); ok { if err := oneof.Sub1.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } } else { v := &UnsafeTest_Sub1{} if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } m.Sub = &UnsafeTest_Sub1_{Sub1: v} } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Sub2", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } if oneof, ok := m.Sub.(*UnsafeTest_Sub2_); ok { if err := oneof.Sub2.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } } else { v := &UnsafeTest_Sub2{} if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } m.Sub = &UnsafeTest_Sub2_{Sub2: v} } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Sub3", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } if oneof, ok := m.Sub.(*UnsafeTest_Sub3_); ok { if err := oneof.Sub3.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } } else { v := &UnsafeTest_Sub3{} if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } m.Sub = &UnsafeTest_Sub3_{Sub3: v} } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Sub4", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } if oneof, ok := m.Sub.(*UnsafeTest_Sub4_); ok { if err := oneof.Sub4.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } } else { v := &UnsafeTest_Sub4{} if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } m.Sub = &UnsafeTest_Sub4_{Sub4: v} } iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Sub5", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } if oneof, ok := m.Sub.(*UnsafeTest_Sub5_); ok { if err := oneof.Sub5.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } } else { v := &UnsafeTest_Sub5{} if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } m.Sub = &UnsafeTest_Sub5_{Sub5: v} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *UnsafeTest_Sub1) UnmarshalVTUnsafe(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: UnsafeTest_Sub1: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: UnsafeTest_Sub1: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field S", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + intStringLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } var stringValue string if intStringLen > 0 { stringValue = unsafe.String(&dAtA[iNdEx], intStringLen) } m.S = stringValue iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field B", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + byteLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.B = dAtA[iNdEx:postIndex] iNdEx = postIndex default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *UnsafeTest_Sub2) UnmarshalVTUnsafe(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: UnsafeTest_Sub2: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: UnsafeTest_Sub2: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field S", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + intStringLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } var stringValue string if intStringLen > 0 { stringValue = unsafe.String(&dAtA[iNdEx], intStringLen) } m.S = append(m.S, stringValue) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field B", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + byteLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } m.B = append(m.B, dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *UnsafeTest_Sub3) UnmarshalVTUnsafe(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: UnsafeTest_Sub3: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: UnsafeTest_Sub3: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Foo", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } if m.Foo == nil { m.Foo = make(map[string][]byte) } var mapkey string var mapvalue []byte for iNdEx < postIndex { entryPreIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return protohelpers.ErrInvalidLength } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return protohelpers.ErrInvalidLength } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } if intStringLenmapkey == 0 { mapkey = "" } else { mapkey = unsafe.String(&dAtA[iNdEx], intStringLenmapkey) } iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var mapbyteLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ mapbyteLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intMapbyteLen := int(mapbyteLen) if intMapbyteLen < 0 { return protohelpers.ErrInvalidLength } postbytesIndex := iNdEx + intMapbyteLen if postbytesIndex < 0 { return protohelpers.ErrInvalidLength } if postbytesIndex > l { return io.ErrUnexpectedEOF } mapvalue = dAtA[iNdEx:postbytesIndex] iNdEx = postbytesIndex } else { iNdEx = entryPreIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Foo[mapkey] = mapvalue iNdEx = postIndex default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *UnsafeTest_Sub4) UnmarshalVTUnsafe(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: UnsafeTest_Sub4: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: UnsafeTest_Sub4: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field S", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + intStringLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } var stringValue string if intStringLen > 0 { stringValue = unsafe.String(&dAtA[iNdEx], intStringLen) } m.Foo = &UnsafeTest_Sub4_S{S: stringValue} iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field B", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + byteLen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } v := dAtA[iNdEx:postIndex] m.Foo = &UnsafeTest_Sub4_B{B: v} iNdEx = postIndex default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *UnsafeTest_Sub5) UnmarshalVTUnsafe(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: UnsafeTest_Sub5: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: UnsafeTest_Sub5: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Foo", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } if m.Foo == nil { m.Foo = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return protohelpers.ErrInvalidLength } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return protohelpers.ErrInvalidLength } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } if intStringLenmapkey == 0 { mapkey = "" } else { mapkey = unsafe.String(&dAtA[iNdEx], intStringLenmapkey) } iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return protohelpers.ErrInvalidLength } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return protohelpers.ErrInvalidLength } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } if intStringLenmapvalue == 0 { mapvalue = "" } else { mapvalue = unsafe.String(&dAtA[iNdEx], intStringLenmapvalue) } iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Foo[mapkey] = mapvalue iNdEx = postIndex default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *UnsafeTest) UnmarshalVTUnsafe(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= uint64(b&0x7F) << shift if b < 0x80 { break } } fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { return fmt.Errorf("proto: UnsafeTest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: UnsafeTest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Sub1", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } if oneof, ok := m.Sub.(*UnsafeTest_Sub1_); ok { if err := oneof.Sub1.UnmarshalVTUnsafe(dAtA[iNdEx:postIndex]); err != nil { return err } } else { v := &UnsafeTest_Sub1{} if err := v.UnmarshalVTUnsafe(dAtA[iNdEx:postIndex]); err != nil { return err } m.Sub = &UnsafeTest_Sub1_{Sub1: v} } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Sub2", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } if oneof, ok := m.Sub.(*UnsafeTest_Sub2_); ok { if err := oneof.Sub2.UnmarshalVTUnsafe(dAtA[iNdEx:postIndex]); err != nil { return err } } else { v := &UnsafeTest_Sub2{} if err := v.UnmarshalVTUnsafe(dAtA[iNdEx:postIndex]); err != nil { return err } m.Sub = &UnsafeTest_Sub2_{Sub2: v} } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Sub3", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } if oneof, ok := m.Sub.(*UnsafeTest_Sub3_); ok { if err := oneof.Sub3.UnmarshalVTUnsafe(dAtA[iNdEx:postIndex]); err != nil { return err } } else { v := &UnsafeTest_Sub3{} if err := v.UnmarshalVTUnsafe(dAtA[iNdEx:postIndex]); err != nil { return err } m.Sub = &UnsafeTest_Sub3_{Sub3: v} } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Sub4", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } if oneof, ok := m.Sub.(*UnsafeTest_Sub4_); ok { if err := oneof.Sub4.UnmarshalVTUnsafe(dAtA[iNdEx:postIndex]); err != nil { return err } } else { v := &UnsafeTest_Sub4{} if err := v.UnmarshalVTUnsafe(dAtA[iNdEx:postIndex]); err != nil { return err } m.Sub = &UnsafeTest_Sub4_{Sub4: v} } iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Sub5", wireType) } var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ msglen |= int(b&0x7F) << shift if b < 0x80 { break } } if msglen < 0 { return protohelpers.ErrInvalidLength } postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } if oneof, ok := m.Sub.(*UnsafeTest_Sub5_); ok { if err := oneof.Sub5.UnmarshalVTUnsafe(dAtA[iNdEx:postIndex]); err != nil { return err } } else { v := &UnsafeTest_Sub5{} if err := v.UnmarshalVTUnsafe(dAtA[iNdEx:postIndex]); err != nil { return err } m.Sub = &UnsafeTest_Sub5_{Sub5: v} } iNdEx = postIndex default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return protohelpers.ErrInvalidLength } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil }