// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: util/proto/test/test.proto package test import ( fmt "fmt" proto "github.com/golang/protobuf/proto" io "io" math "math" math_bits "math/bits" ) // Reference imports to suppress errors if they are not otherwise used. var _ = proto.Marshal var _ = fmt.Errorf var _ = math.Inf // This is a compile-time assertion to ensure that this generated file // is compatible with the proto package it is being compiled against. // A compilation error at this line likely means your copy of the // proto package needs to be updated. const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package type Primitives_SomeEnum int32 const ( Primitives_UNKNOWN Primitives_SomeEnum = 0 Primitives_POSITIVE Primitives_SomeEnum = 1 Primitives_NEGATIVE Primitives_SomeEnum = -1 ) var Primitives_SomeEnum_name = map[int32]string{ 0: "UNKNOWN", 1: "POSITIVE", -1: "NEGATIVE", } var Primitives_SomeEnum_value = map[string]int32{ "UNKNOWN": 0, "POSITIVE": 1, "NEGATIVE": -1, } func (x Primitives_SomeEnum) String() string { return proto.EnumName(Primitives_SomeEnum_name, int32(x)) } func (Primitives_SomeEnum) EnumDescriptor() ([]byte, []int) { return fileDescriptor_998ad0e1a3de8558, []int{0, 0} } type Primitives struct { FieldA []byte `protobuf:"bytes,1,opt,name=field_a,json=fieldA,proto3" json:"field_a,omitempty"` FieldB string `protobuf:"bytes,2,opt,name=field_b,json=fieldB,proto3" json:"field_b,omitempty"` FieldC bool `protobuf:"varint,200,opt,name=field_c,json=fieldC,proto3" json:"field_c,omitempty"` FieldD int32 `protobuf:"varint,201,opt,name=field_d,json=fieldD,proto3" json:"field_d,omitempty"` FieldE uint32 `protobuf:"varint,202,opt,name=field_e,json=fieldE,proto3" json:"field_e,omitempty"` FieldF int64 `protobuf:"varint,203,opt,name=field_f,json=fieldF,proto3" json:"field_f,omitempty"` FieldG uint64 `protobuf:"varint,204,opt,name=field_g,json=fieldG,proto3" json:"field_g,omitempty"` FieldH Primitives_SomeEnum `protobuf:"varint,300,opt,name=field_h,json=fieldH,proto3,enum=test.Primitives_SomeEnum" json:"field_h,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Primitives) Reset() { *m = Primitives{} } func (m *Primitives) String() string { return proto.CompactTextString(m) } func (*Primitives) ProtoMessage() {} func (*Primitives) Descriptor() ([]byte, []int) { return fileDescriptor_998ad0e1a3de8558, []int{0} } func (m *Primitives) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Primitives) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Primitives.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *Primitives) XXX_Merge(src proto.Message) { xxx_messageInfo_Primitives.Merge(m, src) } func (m *Primitives) XXX_Size() int { return m.Size() } func (m *Primitives) XXX_DiscardUnknown() { xxx_messageInfo_Primitives.DiscardUnknown(m) } var xxx_messageInfo_Primitives proto.InternalMessageInfo func (m *Primitives) GetFieldA() []byte { if m != nil { return m.FieldA } return nil } func (m *Primitives) GetFieldB() string { if m != nil { return m.FieldB } return "" } func (m *Primitives) GetFieldC() bool { if m != nil { return m.FieldC } return false } func (m *Primitives) GetFieldD() int32 { if m != nil { return m.FieldD } return 0 } func (m *Primitives) GetFieldE() uint32 { if m != nil { return m.FieldE } return 0 } func (m *Primitives) GetFieldF() int64 { if m != nil { return m.FieldF } return 0 } func (m *Primitives) GetFieldG() uint64 { if m != nil { return m.FieldG } return 0 } func (m *Primitives) GetFieldH() Primitives_SomeEnum { if m != nil { return m.FieldH } return Primitives_UNKNOWN } type RepPrimitives struct { FieldA [][]byte `protobuf:"bytes,1,rep,name=field_a,json=fieldA,proto3" json:"field_a,omitempty"` FieldB []string `protobuf:"bytes,2,rep,name=field_b,json=fieldB,proto3" json:"field_b,omitempty"` FieldC []int32 `protobuf:"varint,3,rep,packed,name=field_c,json=fieldC,proto3" json:"field_c,omitempty"` FieldD []uint32 `protobuf:"varint,4,rep,packed,name=field_d,json=fieldD,proto3" json:"field_d,omitempty"` FieldE []int64 `protobuf:"varint,5,rep,packed,name=field_e,json=fieldE,proto3" json:"field_e,omitempty"` FieldF []uint64 `protobuf:"varint,6,rep,packed,name=field_f,json=fieldF,proto3" json:"field_f,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RepPrimitives) Reset() { *m = RepPrimitives{} } func (m *RepPrimitives) String() string { return proto.CompactTextString(m) } func (*RepPrimitives) ProtoMessage() {} func (*RepPrimitives) Descriptor() ([]byte, []int) { return fileDescriptor_998ad0e1a3de8558, []int{1} } func (m *RepPrimitives) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RepPrimitives) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RepPrimitives.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) if err != nil { return nil, err } return b[:n], nil } } func (m *RepPrimitives) XXX_Merge(src proto.Message) { xxx_messageInfo_RepPrimitives.Merge(m, src) } func (m *RepPrimitives) XXX_Size() int { return m.Size() } func (m *RepPrimitives) XXX_DiscardUnknown() { xxx_messageInfo_RepPrimitives.DiscardUnknown(m) } var xxx_messageInfo_RepPrimitives proto.InternalMessageInfo func (m *RepPrimitives) GetFieldA() [][]byte { if m != nil { return m.FieldA } return nil } func (m *RepPrimitives) GetFieldB() []string { if m != nil { return m.FieldB } return nil } func (m *RepPrimitives) GetFieldC() []int32 { if m != nil { return m.FieldC } return nil } func (m *RepPrimitives) GetFieldD() []uint32 { if m != nil { return m.FieldD } return nil } func (m *RepPrimitives) GetFieldE() []int64 { if m != nil { return m.FieldE } return nil } func (m *RepPrimitives) GetFieldF() []uint64 { if m != nil { return m.FieldF } return nil } func init() { proto.RegisterEnum("test.Primitives_SomeEnum", Primitives_SomeEnum_name, Primitives_SomeEnum_value) proto.RegisterType((*Primitives)(nil), "test.Primitives") proto.RegisterType((*RepPrimitives)(nil), "test.RepPrimitives") } func init() { proto.RegisterFile("util/proto/test/test.proto", fileDescriptor_998ad0e1a3de8558) } var fileDescriptor_998ad0e1a3de8558 = []byte{ // 312 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x2a, 0x2d, 0xc9, 0xcc, 0xd1, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0xd7, 0x2f, 0x49, 0x2d, 0x2e, 0x01, 0x13, 0x7a, 0x60, 0xbe, 0x10, 0x0b, 0x88, 0xad, 0xb4, 0x99, 0x89, 0x8b, 0x2b, 0xa0, 0x28, 0x33, 0x37, 0xb3, 0x24, 0xb3, 0x2c, 0xb5, 0x58, 0x48, 0x9c, 0x8b, 0x3d, 0x2d, 0x33, 0x35, 0x27, 0x25, 0x3e, 0x51, 0x82, 0x51, 0x81, 0x51, 0x83, 0x27, 0x88, 0x0d, 0xcc, 0x75, 0x44, 0x48, 0x24, 0x49, 0x30, 0x29, 0x30, 0x6a, 0x70, 0x42, 0x25, 0x9c, 0x84, 0x24, 0x60, 0x12, 0xc9, 0x12, 0x27, 0x40, 0x5a, 0x38, 0xa0, 0x32, 0xce, 0x08, 0x99, 0x14, 0x89, 0x93, 0x20, 0x19, 0x56, 0xa8, 0x8c, 0x0b, 0x42, 0x26, 0x55, 0xe2, 0x14, 0x48, 0x86, 0x17, 0x2a, 0xe3, 0x8a, 0x90, 0x49, 0x93, 0x38, 0x0d, 0x92, 0x61, 0x86, 0xca, 0xb8, 0x21, 0x64, 0xd2, 0x25, 0xce, 0x80, 0x64, 0x58, 0xa0, 0x32, 0xee, 0x42, 0xc6, 0x30, 0x99, 0x0c, 0x89, 0x35, 0x20, 0xb7, 0xf1, 0x19, 0x49, 0xea, 0x81, 0xfd, 0x89, 0xf0, 0x97, 0x5e, 0x70, 0x7e, 0x6e, 0xaa, 0x6b, 0x5e, 0x69, 0x2e, 0x54, 0x93, 0x87, 0x92, 0x0d, 0x17, 0x07, 0x4c, 0x4c, 0x88, 0x9b, 0x8b, 0x3d, 0xd4, 0xcf, 0xdb, 0xcf, 0x3f, 0xdc, 0x4f, 0x80, 0x41, 0x88, 0x87, 0x8b, 0x23, 0xc0, 0x3f, 0xd8, 0x33, 0xc4, 0x33, 0xcc, 0x55, 0x80, 0x51, 0x48, 0x94, 0x8b, 0xc3, 0xcf, 0xd5, 0xdd, 0x11, 0xcc, 0xfb, 0x0f, 0x03, 0x8c, 0x4a, 0x4b, 0x19, 0xb9, 0x78, 0x83, 0x52, 0x0b, 0x70, 0x05, 0x1c, 0x33, 0xae, 0x80, 0x63, 0x46, 0x0a, 0x38, 0x71, 0x44, 0xc0, 0x31, 0x2b, 0x30, 0xc3, 0x43, 0xc7, 0x19, 0x21, 0x91, 0x22, 0xc1, 0xa2, 0xc0, 0x0c, 0x0f, 0x1c, 0x17, 0x84, 0x44, 0xaa, 0x04, 0xab, 0x02, 0x33, 0x3c, 0x6c, 0x5c, 0x11, 0x12, 0x69, 0x12, 0x6c, 0x0a, 0xcc, 0xf0, 0xa0, 0x71, 0x73, 0x12, 0x38, 0xf1, 0x48, 0x8e, 0xf1, 0xc2, 0x23, 0x39, 0xc6, 0x07, 0x8f, 0xe4, 0x18, 0x67, 0x3c, 0x96, 0x63, 0x48, 0x62, 0x03, 0x47, 0xbe, 0x31, 0x20, 0x00, 0x00, 0xff, 0xff, 0x56, 0x51, 0xcb, 0xb3, 0x1a, 0x02, 0x00, 0x00, } func (m *Primitives) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *Primitives) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *Primitives) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if m.FieldH != 0 { i = encodeVarintTest(dAtA, i, uint64(m.FieldH)) i-- dAtA[i] = 0x12 i-- dAtA[i] = 0xe0 } if m.FieldG != 0 { i = encodeVarintTest(dAtA, i, uint64(m.FieldG)) i-- dAtA[i] = 0xc i-- dAtA[i] = 0xe0 } if m.FieldF != 0 { i = encodeVarintTest(dAtA, i, uint64(m.FieldF)) i-- dAtA[i] = 0xc i-- dAtA[i] = 0xd8 } if m.FieldE != 0 { i = encodeVarintTest(dAtA, i, uint64(m.FieldE)) i-- dAtA[i] = 0xc i-- dAtA[i] = 0xd0 } if m.FieldD != 0 { i = encodeVarintTest(dAtA, i, uint64(m.FieldD)) i-- dAtA[i] = 0xc i-- dAtA[i] = 0xc8 } if m.FieldC { i-- if m.FieldC { dAtA[i] = 1 } else { dAtA[i] = 0 } i-- dAtA[i] = 0xc i-- dAtA[i] = 0xc0 } if len(m.FieldB) > 0 { i -= len(m.FieldB) copy(dAtA[i:], m.FieldB) i = encodeVarintTest(dAtA, i, uint64(len(m.FieldB))) i-- dAtA[i] = 0x12 } if len(m.FieldA) > 0 { i -= len(m.FieldA) copy(dAtA[i:], m.FieldA) i = encodeVarintTest(dAtA, i, uint64(len(m.FieldA))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *RepPrimitives) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *RepPrimitives) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *RepPrimitives) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.XXX_unrecognized != nil { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } if len(m.FieldF) > 0 { dAtA2 := make([]byte, len(m.FieldF)*10) var j1 int for _, num := range m.FieldF { for num >= 1<<7 { dAtA2[j1] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 j1++ } dAtA2[j1] = uint8(num) j1++ } i -= j1 copy(dAtA[i:], dAtA2[:j1]) i = encodeVarintTest(dAtA, i, uint64(j1)) i-- dAtA[i] = 0x32 } if len(m.FieldE) > 0 { dAtA4 := make([]byte, len(m.FieldE)*10) var j3 int for _, num1 := range m.FieldE { num := uint64(num1) for num >= 1<<7 { dAtA4[j3] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 j3++ } dAtA4[j3] = uint8(num) j3++ } i -= j3 copy(dAtA[i:], dAtA4[:j3]) i = encodeVarintTest(dAtA, i, uint64(j3)) i-- dAtA[i] = 0x2a } if len(m.FieldD) > 0 { dAtA6 := make([]byte, len(m.FieldD)*10) var j5 int for _, num := range m.FieldD { for num >= 1<<7 { dAtA6[j5] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 j5++ } dAtA6[j5] = uint8(num) j5++ } i -= j5 copy(dAtA[i:], dAtA6[:j5]) i = encodeVarintTest(dAtA, i, uint64(j5)) i-- dAtA[i] = 0x22 } if len(m.FieldC) > 0 { dAtA8 := make([]byte, len(m.FieldC)*10) var j7 int for _, num1 := range m.FieldC { num := uint64(num1) for num >= 1<<7 { dAtA8[j7] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 j7++ } dAtA8[j7] = uint8(num) j7++ } i -= j7 copy(dAtA[i:], dAtA8[:j7]) i = encodeVarintTest(dAtA, i, uint64(j7)) i-- dAtA[i] = 0x1a } if len(m.FieldB) > 0 { for iNdEx := len(m.FieldB) - 1; iNdEx >= 0; iNdEx-- { i -= len(m.FieldB[iNdEx]) copy(dAtA[i:], m.FieldB[iNdEx]) i = encodeVarintTest(dAtA, i, uint64(len(m.FieldB[iNdEx]))) i-- dAtA[i] = 0x12 } } if len(m.FieldA) > 0 { for iNdEx := len(m.FieldA) - 1; iNdEx >= 0; iNdEx-- { i -= len(m.FieldA[iNdEx]) copy(dAtA[i:], m.FieldA[iNdEx]) i = encodeVarintTest(dAtA, i, uint64(len(m.FieldA[iNdEx]))) i-- dAtA[i] = 0xa } } return len(dAtA) - i, nil } func encodeVarintTest(dAtA []byte, offset int, v uint64) int { offset -= sovTest(v) base := offset for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } dAtA[offset] = uint8(v) return base } func (m *Primitives) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.FieldA) if l > 0 { n += 1 + l + sovTest(uint64(l)) } l = len(m.FieldB) if l > 0 { n += 1 + l + sovTest(uint64(l)) } if m.FieldC { n += 3 } if m.FieldD != 0 { n += 2 + sovTest(uint64(m.FieldD)) } if m.FieldE != 0 { n += 2 + sovTest(uint64(m.FieldE)) } if m.FieldF != 0 { n += 2 + sovTest(uint64(m.FieldF)) } if m.FieldG != 0 { n += 2 + sovTest(uint64(m.FieldG)) } if m.FieldH != 0 { n += 2 + sovTest(uint64(m.FieldH)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func (m *RepPrimitives) Size() (n int) { if m == nil { return 0 } var l int _ = l if len(m.FieldA) > 0 { for _, b := range m.FieldA { l = len(b) n += 1 + l + sovTest(uint64(l)) } } if len(m.FieldB) > 0 { for _, s := range m.FieldB { l = len(s) n += 1 + l + sovTest(uint64(l)) } } if len(m.FieldC) > 0 { l = 0 for _, e := range m.FieldC { l += sovTest(uint64(e)) } n += 1 + sovTest(uint64(l)) + l } if len(m.FieldD) > 0 { l = 0 for _, e := range m.FieldD { l += sovTest(uint64(e)) } n += 1 + sovTest(uint64(l)) + l } if len(m.FieldE) > 0 { l = 0 for _, e := range m.FieldE { l += sovTest(uint64(e)) } n += 1 + sovTest(uint64(l)) + l } if len(m.FieldF) > 0 { l = 0 for _, e := range m.FieldF { l += sovTest(uint64(e)) } n += 1 + sovTest(uint64(l)) + l } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } func sovTest(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } func sozTest(x uint64) (n int) { return sovTest(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } func (m *Primitives) Unmarshal(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 ErrIntOverflowTest } 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: Primitives: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Primitives: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field FieldA", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTest } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthTest } postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthTest } if postIndex > l { return io.ErrUnexpectedEOF } m.FieldA = append(m.FieldA[:0], dAtA[iNdEx:postIndex]...) if m.FieldA == nil { m.FieldA = []byte{} } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field FieldB", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTest } 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 ErrInvalidLengthTest } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTest } if postIndex > l { return io.ErrUnexpectedEOF } m.FieldB = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 200: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field FieldC", wireType) } var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTest } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= int(b&0x7F) << shift if b < 0x80 { break } } m.FieldC = bool(v != 0) case 201: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field FieldD", wireType) } m.FieldD = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTest } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.FieldD |= int32(b&0x7F) << shift if b < 0x80 { break } } case 202: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field FieldE", wireType) } m.FieldE = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTest } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.FieldE |= uint32(b&0x7F) << shift if b < 0x80 { break } } case 203: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field FieldF", wireType) } m.FieldF = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTest } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.FieldF |= int64(b&0x7F) << shift if b < 0x80 { break } } case 204: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field FieldG", wireType) } m.FieldG = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTest } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.FieldG |= uint64(b&0x7F) << shift if b < 0x80 { break } } case 300: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field FieldH", wireType) } m.FieldH = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTest } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.FieldH |= Primitives_SomeEnum(b&0x7F) << shift if b < 0x80 { break } } default: iNdEx = preIndex skippy, err := skipTest(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthTest } if (iNdEx + skippy) < 0 { return ErrInvalidLengthTest } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func (m *RepPrimitives) Unmarshal(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 ErrIntOverflowTest } 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: RepPrimitives: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RepPrimitives: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field FieldA", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTest } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthTest } postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthTest } if postIndex > l { return io.ErrUnexpectedEOF } m.FieldA = append(m.FieldA, make([]byte, postIndex-iNdEx)) copy(m.FieldA[len(m.FieldA)-1], dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field FieldB", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTest } 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 ErrInvalidLengthTest } postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTest } if postIndex > l { return io.ErrUnexpectedEOF } m.FieldB = append(m.FieldB, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex case 3: if wireType == 0 { var v int32 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTest } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= int32(b&0x7F) << shift if b < 0x80 { break } } m.FieldC = append(m.FieldC, v) } else if wireType == 2 { var packedLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTest } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ packedLen |= int(b&0x7F) << shift if b < 0x80 { break } } if packedLen < 0 { return ErrInvalidLengthTest } postIndex := iNdEx + packedLen if postIndex < 0 { return ErrInvalidLengthTest } if postIndex > l { return io.ErrUnexpectedEOF } var elementCount int var count int for _, integer := range dAtA[iNdEx:postIndex] { if integer < 128 { count++ } } elementCount = count if elementCount != 0 && len(m.FieldC) == 0 { m.FieldC = make([]int32, 0, elementCount) } for iNdEx < postIndex { var v int32 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTest } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= int32(b&0x7F) << shift if b < 0x80 { break } } m.FieldC = append(m.FieldC, v) } } else { return fmt.Errorf("proto: wrong wireType = %d for field FieldC", wireType) } case 4: if wireType == 0 { var v uint32 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTest } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= uint32(b&0x7F) << shift if b < 0x80 { break } } m.FieldD = append(m.FieldD, v) } else if wireType == 2 { var packedLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTest } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ packedLen |= int(b&0x7F) << shift if b < 0x80 { break } } if packedLen < 0 { return ErrInvalidLengthTest } postIndex := iNdEx + packedLen if postIndex < 0 { return ErrInvalidLengthTest } if postIndex > l { return io.ErrUnexpectedEOF } var elementCount int var count int for _, integer := range dAtA[iNdEx:postIndex] { if integer < 128 { count++ } } elementCount = count if elementCount != 0 && len(m.FieldD) == 0 { m.FieldD = make([]uint32, 0, elementCount) } for iNdEx < postIndex { var v uint32 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTest } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= uint32(b&0x7F) << shift if b < 0x80 { break } } m.FieldD = append(m.FieldD, v) } } else { return fmt.Errorf("proto: wrong wireType = %d for field FieldD", wireType) } case 5: if wireType == 0 { var v int64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTest } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= int64(b&0x7F) << shift if b < 0x80 { break } } m.FieldE = append(m.FieldE, v) } else if wireType == 2 { var packedLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTest } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ packedLen |= int(b&0x7F) << shift if b < 0x80 { break } } if packedLen < 0 { return ErrInvalidLengthTest } postIndex := iNdEx + packedLen if postIndex < 0 { return ErrInvalidLengthTest } if postIndex > l { return io.ErrUnexpectedEOF } var elementCount int var count int for _, integer := range dAtA[iNdEx:postIndex] { if integer < 128 { count++ } } elementCount = count if elementCount != 0 && len(m.FieldE) == 0 { m.FieldE = make([]int64, 0, elementCount) } for iNdEx < postIndex { var v int64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTest } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= int64(b&0x7F) << shift if b < 0x80 { break } } m.FieldE = append(m.FieldE, v) } } else { return fmt.Errorf("proto: wrong wireType = %d for field FieldE", wireType) } case 6: if wireType == 0 { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTest } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= uint64(b&0x7F) << shift if b < 0x80 { break } } m.FieldF = append(m.FieldF, v) } else if wireType == 2 { var packedLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTest } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ packedLen |= int(b&0x7F) << shift if b < 0x80 { break } } if packedLen < 0 { return ErrInvalidLengthTest } postIndex := iNdEx + packedLen if postIndex < 0 { return ErrInvalidLengthTest } if postIndex > l { return io.ErrUnexpectedEOF } var elementCount int var count int for _, integer := range dAtA[iNdEx:postIndex] { if integer < 128 { count++ } } elementCount = count if elementCount != 0 && len(m.FieldF) == 0 { m.FieldF = make([]uint64, 0, elementCount) } for iNdEx < postIndex { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTest } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= uint64(b&0x7F) << shift if b < 0x80 { break } } m.FieldF = append(m.FieldF, v) } } else { return fmt.Errorf("proto: wrong wireType = %d for field FieldF", wireType) } default: iNdEx = preIndex skippy, err := skipTest(dAtA[iNdEx:]) if err != nil { return err } if skippy < 0 { return ErrInvalidLengthTest } if (iNdEx + skippy) < 0 { return ErrInvalidLengthTest } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } if iNdEx > l { return io.ErrUnexpectedEOF } return nil } func skipTest(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 depth := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowTest } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } wireType := int(wire & 0x7) switch wireType { case 0: for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowTest } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } iNdEx++ if dAtA[iNdEx-1] < 0x80 { break } } case 1: iNdEx += 8 case 2: var length int for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowTest } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if length < 0 { return 0, ErrInvalidLengthTest } iNdEx += length case 3: depth++ case 4: if depth == 0 { return 0, ErrUnexpectedEndOfGroupTest } depth-- case 5: iNdEx += 4 default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } if iNdEx < 0 { return 0, ErrInvalidLengthTest } if depth == 0 { return iNdEx, nil } } return 0, io.ErrUnexpectedEOF } var ( ErrInvalidLengthTest = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowTest = fmt.Errorf("proto: integer overflow") ErrUnexpectedEndOfGroupTest = fmt.Errorf("proto: unexpected end of group") )