github.com/cockroachdb/cockroach@v20.2.0-alpha.1+incompatible/pkg/config/system.pb.go (about)

     1  // Code generated by protoc-gen-gogo. DO NOT EDIT.
     2  // source: config/system.proto
     3  
     4  package config
     5  
     6  import proto "github.com/gogo/protobuf/proto"
     7  import fmt "fmt"
     8  import math "math"
     9  import roachpb "github.com/cockroachdb/cockroach/pkg/roachpb"
    10  
    11  import io "io"
    12  
    13  // Reference imports to suppress errors if they are not otherwise used.
    14  var _ = proto.Marshal
    15  var _ = fmt.Errorf
    16  var _ = math.Inf
    17  
    18  // This is a compile-time assertion to ensure that this generated file
    19  // is compatible with the proto package it is being compiled against.
    20  // A compilation error at this line likely means your copy of the
    21  // proto package needs to be updated.
    22  const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
    23  
    24  type SystemConfigEntries struct {
    25  	Values []roachpb.KeyValue `protobuf:"bytes,1,rep,name=values" json:"values"`
    26  }
    27  
    28  func (m *SystemConfigEntries) Reset()         { *m = SystemConfigEntries{} }
    29  func (m *SystemConfigEntries) String() string { return proto.CompactTextString(m) }
    30  func (*SystemConfigEntries) ProtoMessage()    {}
    31  func (*SystemConfigEntries) Descriptor() ([]byte, []int) {
    32  	return fileDescriptor_system_5254723255d57bbf, []int{0}
    33  }
    34  func (m *SystemConfigEntries) XXX_Unmarshal(b []byte) error {
    35  	return m.Unmarshal(b)
    36  }
    37  func (m *SystemConfigEntries) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    38  	b = b[:cap(b)]
    39  	n, err := m.MarshalTo(b)
    40  	if err != nil {
    41  		return nil, err
    42  	}
    43  	return b[:n], nil
    44  }
    45  func (dst *SystemConfigEntries) XXX_Merge(src proto.Message) {
    46  	xxx_messageInfo_SystemConfigEntries.Merge(dst, src)
    47  }
    48  func (m *SystemConfigEntries) XXX_Size() int {
    49  	return m.Size()
    50  }
    51  func (m *SystemConfigEntries) XXX_DiscardUnknown() {
    52  	xxx_messageInfo_SystemConfigEntries.DiscardUnknown(m)
    53  }
    54  
    55  var xxx_messageInfo_SystemConfigEntries proto.InternalMessageInfo
    56  
    57  func init() {
    58  	proto.RegisterType((*SystemConfigEntries)(nil), "cockroach.config.SystemConfigEntries")
    59  }
    60  func (m *SystemConfigEntries) Marshal() (dAtA []byte, err error) {
    61  	size := m.Size()
    62  	dAtA = make([]byte, size)
    63  	n, err := m.MarshalTo(dAtA)
    64  	if err != nil {
    65  		return nil, err
    66  	}
    67  	return dAtA[:n], nil
    68  }
    69  
    70  func (m *SystemConfigEntries) MarshalTo(dAtA []byte) (int, error) {
    71  	var i int
    72  	_ = i
    73  	var l int
    74  	_ = l
    75  	if len(m.Values) > 0 {
    76  		for _, msg := range m.Values {
    77  			dAtA[i] = 0xa
    78  			i++
    79  			i = encodeVarintSystem(dAtA, i, uint64(msg.Size()))
    80  			n, err := msg.MarshalTo(dAtA[i:])
    81  			if err != nil {
    82  				return 0, err
    83  			}
    84  			i += n
    85  		}
    86  	}
    87  	return i, nil
    88  }
    89  
    90  func encodeVarintSystem(dAtA []byte, offset int, v uint64) int {
    91  	for v >= 1<<7 {
    92  		dAtA[offset] = uint8(v&0x7f | 0x80)
    93  		v >>= 7
    94  		offset++
    95  	}
    96  	dAtA[offset] = uint8(v)
    97  	return offset + 1
    98  }
    99  func (m *SystemConfigEntries) Size() (n int) {
   100  	if m == nil {
   101  		return 0
   102  	}
   103  	var l int
   104  	_ = l
   105  	if len(m.Values) > 0 {
   106  		for _, e := range m.Values {
   107  			l = e.Size()
   108  			n += 1 + l + sovSystem(uint64(l))
   109  		}
   110  	}
   111  	return n
   112  }
   113  
   114  func sovSystem(x uint64) (n int) {
   115  	for {
   116  		n++
   117  		x >>= 7
   118  		if x == 0 {
   119  			break
   120  		}
   121  	}
   122  	return n
   123  }
   124  func sozSystem(x uint64) (n int) {
   125  	return sovSystem(uint64((x << 1) ^ uint64((int64(x) >> 63))))
   126  }
   127  func (m *SystemConfigEntries) Unmarshal(dAtA []byte) error {
   128  	l := len(dAtA)
   129  	iNdEx := 0
   130  	for iNdEx < l {
   131  		preIndex := iNdEx
   132  		var wire uint64
   133  		for shift := uint(0); ; shift += 7 {
   134  			if shift >= 64 {
   135  				return ErrIntOverflowSystem
   136  			}
   137  			if iNdEx >= l {
   138  				return io.ErrUnexpectedEOF
   139  			}
   140  			b := dAtA[iNdEx]
   141  			iNdEx++
   142  			wire |= (uint64(b) & 0x7F) << shift
   143  			if b < 0x80 {
   144  				break
   145  			}
   146  		}
   147  		fieldNum := int32(wire >> 3)
   148  		wireType := int(wire & 0x7)
   149  		if wireType == 4 {
   150  			return fmt.Errorf("proto: SystemConfigEntries: wiretype end group for non-group")
   151  		}
   152  		if fieldNum <= 0 {
   153  			return fmt.Errorf("proto: SystemConfigEntries: illegal tag %d (wire type %d)", fieldNum, wire)
   154  		}
   155  		switch fieldNum {
   156  		case 1:
   157  			if wireType != 2 {
   158  				return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType)
   159  			}
   160  			var msglen int
   161  			for shift := uint(0); ; shift += 7 {
   162  				if shift >= 64 {
   163  					return ErrIntOverflowSystem
   164  				}
   165  				if iNdEx >= l {
   166  					return io.ErrUnexpectedEOF
   167  				}
   168  				b := dAtA[iNdEx]
   169  				iNdEx++
   170  				msglen |= (int(b) & 0x7F) << shift
   171  				if b < 0x80 {
   172  					break
   173  				}
   174  			}
   175  			if msglen < 0 {
   176  				return ErrInvalidLengthSystem
   177  			}
   178  			postIndex := iNdEx + msglen
   179  			if postIndex > l {
   180  				return io.ErrUnexpectedEOF
   181  			}
   182  			m.Values = append(m.Values, roachpb.KeyValue{})
   183  			if err := m.Values[len(m.Values)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
   184  				return err
   185  			}
   186  			iNdEx = postIndex
   187  		default:
   188  			iNdEx = preIndex
   189  			skippy, err := skipSystem(dAtA[iNdEx:])
   190  			if err != nil {
   191  				return err
   192  			}
   193  			if skippy < 0 {
   194  				return ErrInvalidLengthSystem
   195  			}
   196  			if (iNdEx + skippy) > l {
   197  				return io.ErrUnexpectedEOF
   198  			}
   199  			iNdEx += skippy
   200  		}
   201  	}
   202  
   203  	if iNdEx > l {
   204  		return io.ErrUnexpectedEOF
   205  	}
   206  	return nil
   207  }
   208  func skipSystem(dAtA []byte) (n int, err error) {
   209  	l := len(dAtA)
   210  	iNdEx := 0
   211  	for iNdEx < l {
   212  		var wire uint64
   213  		for shift := uint(0); ; shift += 7 {
   214  			if shift >= 64 {
   215  				return 0, ErrIntOverflowSystem
   216  			}
   217  			if iNdEx >= l {
   218  				return 0, io.ErrUnexpectedEOF
   219  			}
   220  			b := dAtA[iNdEx]
   221  			iNdEx++
   222  			wire |= (uint64(b) & 0x7F) << shift
   223  			if b < 0x80 {
   224  				break
   225  			}
   226  		}
   227  		wireType := int(wire & 0x7)
   228  		switch wireType {
   229  		case 0:
   230  			for shift := uint(0); ; shift += 7 {
   231  				if shift >= 64 {
   232  					return 0, ErrIntOverflowSystem
   233  				}
   234  				if iNdEx >= l {
   235  					return 0, io.ErrUnexpectedEOF
   236  				}
   237  				iNdEx++
   238  				if dAtA[iNdEx-1] < 0x80 {
   239  					break
   240  				}
   241  			}
   242  			return iNdEx, nil
   243  		case 1:
   244  			iNdEx += 8
   245  			return iNdEx, nil
   246  		case 2:
   247  			var length int
   248  			for shift := uint(0); ; shift += 7 {
   249  				if shift >= 64 {
   250  					return 0, ErrIntOverflowSystem
   251  				}
   252  				if iNdEx >= l {
   253  					return 0, io.ErrUnexpectedEOF
   254  				}
   255  				b := dAtA[iNdEx]
   256  				iNdEx++
   257  				length |= (int(b) & 0x7F) << shift
   258  				if b < 0x80 {
   259  					break
   260  				}
   261  			}
   262  			iNdEx += length
   263  			if length < 0 {
   264  				return 0, ErrInvalidLengthSystem
   265  			}
   266  			return iNdEx, nil
   267  		case 3:
   268  			for {
   269  				var innerWire uint64
   270  				var start int = iNdEx
   271  				for shift := uint(0); ; shift += 7 {
   272  					if shift >= 64 {
   273  						return 0, ErrIntOverflowSystem
   274  					}
   275  					if iNdEx >= l {
   276  						return 0, io.ErrUnexpectedEOF
   277  					}
   278  					b := dAtA[iNdEx]
   279  					iNdEx++
   280  					innerWire |= (uint64(b) & 0x7F) << shift
   281  					if b < 0x80 {
   282  						break
   283  					}
   284  				}
   285  				innerWireType := int(innerWire & 0x7)
   286  				if innerWireType == 4 {
   287  					break
   288  				}
   289  				next, err := skipSystem(dAtA[start:])
   290  				if err != nil {
   291  					return 0, err
   292  				}
   293  				iNdEx = start + next
   294  			}
   295  			return iNdEx, nil
   296  		case 4:
   297  			return iNdEx, nil
   298  		case 5:
   299  			iNdEx += 4
   300  			return iNdEx, nil
   301  		default:
   302  			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
   303  		}
   304  	}
   305  	panic("unreachable")
   306  }
   307  
   308  var (
   309  	ErrInvalidLengthSystem = fmt.Errorf("proto: negative length found during unmarshaling")
   310  	ErrIntOverflowSystem   = fmt.Errorf("proto: integer overflow")
   311  )
   312  
   313  func init() { proto.RegisterFile("config/system.proto", fileDescriptor_system_5254723255d57bbf) }
   314  
   315  var fileDescriptor_system_5254723255d57bbf = []byte{
   316  	// 181 bytes of a gzipped FileDescriptorProto
   317  	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0x4e, 0xce, 0xcf, 0x4b,
   318  	0xcb, 0x4c, 0xd7, 0x2f, 0xae, 0x2c, 0x2e, 0x49, 0xcd, 0xd5, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17,
   319  	0x12, 0x48, 0xce, 0x4f, 0xce, 0x2e, 0xca, 0x4f, 0x4c, 0xce, 0xd0, 0x83, 0x48, 0x4b, 0x89, 0xa4,
   320  	0xe7, 0xa7, 0xe7, 0x83, 0x25, 0xf5, 0x41, 0x2c, 0x88, 0x3a, 0x29, 0x21, 0xb0, 0x9a, 0x82, 0x24,
   321  	0xfd, 0x94, 0xc4, 0x92, 0x44, 0x88, 0x98, 0x52, 0x00, 0x97, 0x70, 0x30, 0xd8, 0x2c, 0x67, 0xb0,
   322  	0x4e, 0xd7, 0xbc, 0x92, 0xa2, 0xcc, 0xd4, 0x62, 0x21, 0x4b, 0x2e, 0xb6, 0xb2, 0xc4, 0x9c, 0xd2,
   323  	0xd4, 0x62, 0x09, 0x46, 0x05, 0x66, 0x0d, 0x6e, 0x23, 0x69, 0x3d, 0x84, 0x1d, 0x50, 0x53, 0xf4,
   324  	0xbc, 0x53, 0x2b, 0xc3, 0x40, 0x6a, 0x9c, 0x58, 0x4e, 0xdc, 0x93, 0x67, 0x08, 0x82, 0x6a, 0x70,
   325  	0xd2, 0x38, 0xf1, 0x50, 0x8e, 0xe1, 0xc4, 0x23, 0x39, 0xc6, 0x0b, 0x8f, 0xe4, 0x18, 0x6f, 0x3c,
   326  	0x92, 0x63, 0x7c, 0xf0, 0x48, 0x8e, 0x71, 0xc2, 0x63, 0x39, 0x86, 0x0b, 0x8f, 0xe5, 0x18, 0x6e,
   327  	0x3c, 0x96, 0x63, 0x88, 0x62, 0x83, 0xb8, 0x12, 0x10, 0x00, 0x00, 0xff, 0xff, 0x7b, 0x2c, 0xe8,
   328  	0xd9, 0xcd, 0x00, 0x00, 0x00,
   329  }