1// Code generated by protoc-gen-gogo. DO NOT EDIT. 2// source: opentelemetry/proto/common/v1/common.proto 3 4package v1 5 6import ( 7 encoding_binary "encoding/binary" 8 fmt "fmt" 9 proto "github.com/gogo/protobuf/proto" 10 io "io" 11 math "math" 12 math_bits "math/bits" 13) 14 15// Reference imports to suppress errors if they are not otherwise used. 16var _ = proto.Marshal 17var _ = fmt.Errorf 18var _ = math.Inf 19 20// This is a compile-time assertion to ensure that this generated file 21// is compatible with the proto package it is being compiled against. 22// A compilation error at this line likely means your copy of the 23// proto package needs to be updated. 24const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package 25 26// AnyValue is used to represent any type of attribute value. AnyValue may contain a 27// primitive value such as a string or integer or it may contain an arbitrary nested 28// object containing arrays, key-value lists and primitives. 29type AnyValue struct { 30 // The value is one of the listed fields. It is valid for all values to be unspecified 31 // in which case this AnyValue is considered to be "null". 32 // 33 // Types that are valid to be assigned to Value: 34 // *AnyValue_StringValue 35 // *AnyValue_BoolValue 36 // *AnyValue_IntValue 37 // *AnyValue_DoubleValue 38 // *AnyValue_ArrayValue 39 // *AnyValue_KvlistValue 40 Value isAnyValue_Value `protobuf_oneof:"value"` 41 XXX_NoUnkeyedLiteral struct{} `json:"-"` 42 XXX_unrecognized []byte `json:"-"` 43 XXX_sizecache int32 `json:"-"` 44} 45 46func (m *AnyValue) Reset() { *m = AnyValue{} } 47func (m *AnyValue) String() string { return proto.CompactTextString(m) } 48func (*AnyValue) ProtoMessage() {} 49func (*AnyValue) Descriptor() ([]byte, []int) { 50 return fileDescriptor_62ba46dcb97aa817, []int{0} 51} 52func (m *AnyValue) XXX_Unmarshal(b []byte) error { 53 return m.Unmarshal(b) 54} 55func (m *AnyValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 56 if deterministic { 57 return xxx_messageInfo_AnyValue.Marshal(b, m, deterministic) 58 } else { 59 b = b[:cap(b)] 60 n, err := m.MarshalToSizedBuffer(b) 61 if err != nil { 62 return nil, err 63 } 64 return b[:n], nil 65 } 66} 67func (m *AnyValue) XXX_Merge(src proto.Message) { 68 xxx_messageInfo_AnyValue.Merge(m, src) 69} 70func (m *AnyValue) XXX_Size() int { 71 return m.Size() 72} 73func (m *AnyValue) XXX_DiscardUnknown() { 74 xxx_messageInfo_AnyValue.DiscardUnknown(m) 75} 76 77var xxx_messageInfo_AnyValue proto.InternalMessageInfo 78 79type isAnyValue_Value interface { 80 isAnyValue_Value() 81 MarshalTo([]byte) (int, error) 82 Size() int 83} 84 85type AnyValue_StringValue struct { 86 StringValue string `protobuf:"bytes,1,opt,name=string_value,json=stringValue,proto3,oneof" json:"string_value,omitempty"` 87} 88type AnyValue_BoolValue struct { 89 BoolValue bool `protobuf:"varint,2,opt,name=bool_value,json=boolValue,proto3,oneof" json:"bool_value,omitempty"` 90} 91type AnyValue_IntValue struct { 92 IntValue int64 `protobuf:"varint,3,opt,name=int_value,json=intValue,proto3,oneof" json:"int_value,omitempty"` 93} 94type AnyValue_DoubleValue struct { 95 DoubleValue float64 `protobuf:"fixed64,4,opt,name=double_value,json=doubleValue,proto3,oneof" json:"double_value,omitempty"` 96} 97type AnyValue_ArrayValue struct { 98 ArrayValue *ArrayValue `protobuf:"bytes,5,opt,name=array_value,json=arrayValue,proto3,oneof" json:"array_value,omitempty"` 99} 100type AnyValue_KvlistValue struct { 101 KvlistValue *KeyValueList `protobuf:"bytes,6,opt,name=kvlist_value,json=kvlistValue,proto3,oneof" json:"kvlist_value,omitempty"` 102} 103 104func (*AnyValue_StringValue) isAnyValue_Value() {} 105func (*AnyValue_BoolValue) isAnyValue_Value() {} 106func (*AnyValue_IntValue) isAnyValue_Value() {} 107func (*AnyValue_DoubleValue) isAnyValue_Value() {} 108func (*AnyValue_ArrayValue) isAnyValue_Value() {} 109func (*AnyValue_KvlistValue) isAnyValue_Value() {} 110 111func (m *AnyValue) GetValue() isAnyValue_Value { 112 if m != nil { 113 return m.Value 114 } 115 return nil 116} 117 118func (m *AnyValue) GetStringValue() string { 119 if x, ok := m.GetValue().(*AnyValue_StringValue); ok { 120 return x.StringValue 121 } 122 return "" 123} 124 125func (m *AnyValue) GetBoolValue() bool { 126 if x, ok := m.GetValue().(*AnyValue_BoolValue); ok { 127 return x.BoolValue 128 } 129 return false 130} 131 132func (m *AnyValue) GetIntValue() int64 { 133 if x, ok := m.GetValue().(*AnyValue_IntValue); ok { 134 return x.IntValue 135 } 136 return 0 137} 138 139func (m *AnyValue) GetDoubleValue() float64 { 140 if x, ok := m.GetValue().(*AnyValue_DoubleValue); ok { 141 return x.DoubleValue 142 } 143 return 0 144} 145 146func (m *AnyValue) GetArrayValue() *ArrayValue { 147 if x, ok := m.GetValue().(*AnyValue_ArrayValue); ok { 148 return x.ArrayValue 149 } 150 return nil 151} 152 153func (m *AnyValue) GetKvlistValue() *KeyValueList { 154 if x, ok := m.GetValue().(*AnyValue_KvlistValue); ok { 155 return x.KvlistValue 156 } 157 return nil 158} 159 160// XXX_OneofWrappers is for the internal use of the proto package. 161func (*AnyValue) XXX_OneofWrappers() []interface{} { 162 return []interface{}{ 163 (*AnyValue_StringValue)(nil), 164 (*AnyValue_BoolValue)(nil), 165 (*AnyValue_IntValue)(nil), 166 (*AnyValue_DoubleValue)(nil), 167 (*AnyValue_ArrayValue)(nil), 168 (*AnyValue_KvlistValue)(nil), 169 } 170} 171 172// ArrayValue is a list of AnyValue messages. We need ArrayValue as a message 173// since oneof in AnyValue does not allow repeated fields. 174type ArrayValue struct { 175 // Array of values. The array may be empty (contain 0 elements). 176 Values []*AnyValue `protobuf:"bytes,1,rep,name=values,proto3" json:"values,omitempty"` 177 XXX_NoUnkeyedLiteral struct{} `json:"-"` 178 XXX_unrecognized []byte `json:"-"` 179 XXX_sizecache int32 `json:"-"` 180} 181 182func (m *ArrayValue) Reset() { *m = ArrayValue{} } 183func (m *ArrayValue) String() string { return proto.CompactTextString(m) } 184func (*ArrayValue) ProtoMessage() {} 185func (*ArrayValue) Descriptor() ([]byte, []int) { 186 return fileDescriptor_62ba46dcb97aa817, []int{1} 187} 188func (m *ArrayValue) XXX_Unmarshal(b []byte) error { 189 return m.Unmarshal(b) 190} 191func (m *ArrayValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 192 if deterministic { 193 return xxx_messageInfo_ArrayValue.Marshal(b, m, deterministic) 194 } else { 195 b = b[:cap(b)] 196 n, err := m.MarshalToSizedBuffer(b) 197 if err != nil { 198 return nil, err 199 } 200 return b[:n], nil 201 } 202} 203func (m *ArrayValue) XXX_Merge(src proto.Message) { 204 xxx_messageInfo_ArrayValue.Merge(m, src) 205} 206func (m *ArrayValue) XXX_Size() int { 207 return m.Size() 208} 209func (m *ArrayValue) XXX_DiscardUnknown() { 210 xxx_messageInfo_ArrayValue.DiscardUnknown(m) 211} 212 213var xxx_messageInfo_ArrayValue proto.InternalMessageInfo 214 215func (m *ArrayValue) GetValues() []*AnyValue { 216 if m != nil { 217 return m.Values 218 } 219 return nil 220} 221 222// KeyValueList is a list of KeyValue messages. We need KeyValueList as a message 223// since `oneof` in AnyValue does not allow repeated fields. Everywhere else where we need 224// a list of KeyValue messages (e.g. in Span) we use `repeated KeyValue` directly to 225// avoid unnecessary extra wrapping (which slows down the protocol). The 2 approaches 226// are semantically equivalent. 227type KeyValueList struct { 228 // A collection of key/value pairs of key-value pairs. The list may be empty (may 229 // contain 0 elements). 230 Values []*KeyValue `protobuf:"bytes,1,rep,name=values,proto3" json:"values,omitempty"` 231 XXX_NoUnkeyedLiteral struct{} `json:"-"` 232 XXX_unrecognized []byte `json:"-"` 233 XXX_sizecache int32 `json:"-"` 234} 235 236func (m *KeyValueList) Reset() { *m = KeyValueList{} } 237func (m *KeyValueList) String() string { return proto.CompactTextString(m) } 238func (*KeyValueList) ProtoMessage() {} 239func (*KeyValueList) Descriptor() ([]byte, []int) { 240 return fileDescriptor_62ba46dcb97aa817, []int{2} 241} 242func (m *KeyValueList) XXX_Unmarshal(b []byte) error { 243 return m.Unmarshal(b) 244} 245func (m *KeyValueList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 246 if deterministic { 247 return xxx_messageInfo_KeyValueList.Marshal(b, m, deterministic) 248 } else { 249 b = b[:cap(b)] 250 n, err := m.MarshalToSizedBuffer(b) 251 if err != nil { 252 return nil, err 253 } 254 return b[:n], nil 255 } 256} 257func (m *KeyValueList) XXX_Merge(src proto.Message) { 258 xxx_messageInfo_KeyValueList.Merge(m, src) 259} 260func (m *KeyValueList) XXX_Size() int { 261 return m.Size() 262} 263func (m *KeyValueList) XXX_DiscardUnknown() { 264 xxx_messageInfo_KeyValueList.DiscardUnknown(m) 265} 266 267var xxx_messageInfo_KeyValueList proto.InternalMessageInfo 268 269func (m *KeyValueList) GetValues() []*KeyValue { 270 if m != nil { 271 return m.Values 272 } 273 return nil 274} 275 276// KeyValue is a key-value pair that is used to store Span attributes, Link 277// attributes, etc. 278type KeyValue struct { 279 Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` 280 Value *AnyValue `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` 281 XXX_NoUnkeyedLiteral struct{} `json:"-"` 282 XXX_unrecognized []byte `json:"-"` 283 XXX_sizecache int32 `json:"-"` 284} 285 286func (m *KeyValue) Reset() { *m = KeyValue{} } 287func (m *KeyValue) String() string { return proto.CompactTextString(m) } 288func (*KeyValue) ProtoMessage() {} 289func (*KeyValue) Descriptor() ([]byte, []int) { 290 return fileDescriptor_62ba46dcb97aa817, []int{3} 291} 292func (m *KeyValue) XXX_Unmarshal(b []byte) error { 293 return m.Unmarshal(b) 294} 295func (m *KeyValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 296 if deterministic { 297 return xxx_messageInfo_KeyValue.Marshal(b, m, deterministic) 298 } else { 299 b = b[:cap(b)] 300 n, err := m.MarshalToSizedBuffer(b) 301 if err != nil { 302 return nil, err 303 } 304 return b[:n], nil 305 } 306} 307func (m *KeyValue) XXX_Merge(src proto.Message) { 308 xxx_messageInfo_KeyValue.Merge(m, src) 309} 310func (m *KeyValue) XXX_Size() int { 311 return m.Size() 312} 313func (m *KeyValue) XXX_DiscardUnknown() { 314 xxx_messageInfo_KeyValue.DiscardUnknown(m) 315} 316 317var xxx_messageInfo_KeyValue proto.InternalMessageInfo 318 319func (m *KeyValue) GetKey() string { 320 if m != nil { 321 return m.Key 322 } 323 return "" 324} 325 326func (m *KeyValue) GetValue() *AnyValue { 327 if m != nil { 328 return m.Value 329 } 330 return nil 331} 332 333// StringKeyValue is a pair of key/value strings. This is the simpler (and faster) version 334// of KeyValue that only supports string values. 335type StringKeyValue struct { 336 Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` 337 Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` 338 XXX_NoUnkeyedLiteral struct{} `json:"-"` 339 XXX_unrecognized []byte `json:"-"` 340 XXX_sizecache int32 `json:"-"` 341} 342 343func (m *StringKeyValue) Reset() { *m = StringKeyValue{} } 344func (m *StringKeyValue) String() string { return proto.CompactTextString(m) } 345func (*StringKeyValue) ProtoMessage() {} 346func (*StringKeyValue) Descriptor() ([]byte, []int) { 347 return fileDescriptor_62ba46dcb97aa817, []int{4} 348} 349func (m *StringKeyValue) XXX_Unmarshal(b []byte) error { 350 return m.Unmarshal(b) 351} 352func (m *StringKeyValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 353 if deterministic { 354 return xxx_messageInfo_StringKeyValue.Marshal(b, m, deterministic) 355 } else { 356 b = b[:cap(b)] 357 n, err := m.MarshalToSizedBuffer(b) 358 if err != nil { 359 return nil, err 360 } 361 return b[:n], nil 362 } 363} 364func (m *StringKeyValue) XXX_Merge(src proto.Message) { 365 xxx_messageInfo_StringKeyValue.Merge(m, src) 366} 367func (m *StringKeyValue) XXX_Size() int { 368 return m.Size() 369} 370func (m *StringKeyValue) XXX_DiscardUnknown() { 371 xxx_messageInfo_StringKeyValue.DiscardUnknown(m) 372} 373 374var xxx_messageInfo_StringKeyValue proto.InternalMessageInfo 375 376func (m *StringKeyValue) GetKey() string { 377 if m != nil { 378 return m.Key 379 } 380 return "" 381} 382 383func (m *StringKeyValue) GetValue() string { 384 if m != nil { 385 return m.Value 386 } 387 return "" 388} 389 390// InstrumentationLibrary is a message representing the instrumentation library information 391// such as the fully qualified name and version. 392type InstrumentationLibrary struct { 393 Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` 394 Version string `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"` 395 XXX_NoUnkeyedLiteral struct{} `json:"-"` 396 XXX_unrecognized []byte `json:"-"` 397 XXX_sizecache int32 `json:"-"` 398} 399 400func (m *InstrumentationLibrary) Reset() { *m = InstrumentationLibrary{} } 401func (m *InstrumentationLibrary) String() string { return proto.CompactTextString(m) } 402func (*InstrumentationLibrary) ProtoMessage() {} 403func (*InstrumentationLibrary) Descriptor() ([]byte, []int) { 404 return fileDescriptor_62ba46dcb97aa817, []int{5} 405} 406func (m *InstrumentationLibrary) XXX_Unmarshal(b []byte) error { 407 return m.Unmarshal(b) 408} 409func (m *InstrumentationLibrary) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 410 if deterministic { 411 return xxx_messageInfo_InstrumentationLibrary.Marshal(b, m, deterministic) 412 } else { 413 b = b[:cap(b)] 414 n, err := m.MarshalToSizedBuffer(b) 415 if err != nil { 416 return nil, err 417 } 418 return b[:n], nil 419 } 420} 421func (m *InstrumentationLibrary) XXX_Merge(src proto.Message) { 422 xxx_messageInfo_InstrumentationLibrary.Merge(m, src) 423} 424func (m *InstrumentationLibrary) XXX_Size() int { 425 return m.Size() 426} 427func (m *InstrumentationLibrary) XXX_DiscardUnknown() { 428 xxx_messageInfo_InstrumentationLibrary.DiscardUnknown(m) 429} 430 431var xxx_messageInfo_InstrumentationLibrary proto.InternalMessageInfo 432 433func (m *InstrumentationLibrary) GetName() string { 434 if m != nil { 435 return m.Name 436 } 437 return "" 438} 439 440func (m *InstrumentationLibrary) GetVersion() string { 441 if m != nil { 442 return m.Version 443 } 444 return "" 445} 446 447func init() { 448 proto.RegisterType((*AnyValue)(nil), "opentelemetry.proto.common.v1.AnyValue") 449 proto.RegisterType((*ArrayValue)(nil), "opentelemetry.proto.common.v1.ArrayValue") 450 proto.RegisterType((*KeyValueList)(nil), "opentelemetry.proto.common.v1.KeyValueList") 451 proto.RegisterType((*KeyValue)(nil), "opentelemetry.proto.common.v1.KeyValue") 452 proto.RegisterType((*StringKeyValue)(nil), "opentelemetry.proto.common.v1.StringKeyValue") 453 proto.RegisterType((*InstrumentationLibrary)(nil), "opentelemetry.proto.common.v1.InstrumentationLibrary") 454} 455 456func init() { 457 proto.RegisterFile("opentelemetry/proto/common/v1/common.proto", fileDescriptor_62ba46dcb97aa817) 458} 459 460var fileDescriptor_62ba46dcb97aa817 = []byte{ 461 // 443 bytes of a gzipped FileDescriptorProto 462 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x53, 0x4f, 0x8b, 0x13, 0x31, 463 0x14, 0x6f, 0xb6, 0xbb, 0xdd, 0xf6, 0x4d, 0x11, 0x09, 0x22, 0xbd, 0x6c, 0x1d, 0xea, 0xc1, 0x51, 464 0xd9, 0x09, 0xbb, 0x5e, 0xbc, 0x88, 0x6c, 0x05, 0x19, 0xb1, 0x62, 0x89, 0xe0, 0x41, 0x0f, 0x92, 465 0xd1, 0x50, 0xc2, 0x66, 0x92, 0x21, 0x93, 0x0e, 0xce, 0xc7, 0xf0, 0x03, 0x79, 0xf7, 0xe8, 0x47, 466 0x90, 0x7e, 0x12, 0x99, 0x24, 0xd3, 0xfd, 0x73, 0xe8, 0xd2, 0xdb, 0x7b, 0xbf, 0xf9, 0xfd, 0x79, 467 0x6f, 0x92, 0xc0, 0x33, 0x5d, 0x72, 0x65, 0xb9, 0xe4, 0x05, 0xb7, 0xa6, 0x21, 0xa5, 0xd1, 0x56, 468 0x93, 0xef, 0xba, 0x28, 0xb4, 0x22, 0xf5, 0x59, 0xa8, 0x52, 0x07, 0xe3, 0x93, 0x1b, 0x5c, 0x0f, 469 0xa6, 0x81, 0x51, 0x9f, 0xcd, 0x7e, 0x1f, 0xc0, 0xf0, 0x42, 0x35, 0x9f, 0x99, 0x5c, 0x73, 0xfc, 470 0x18, 0xc6, 0x95, 0x35, 0x42, 0xad, 0xbe, 0xd5, 0x6d, 0x3f, 0x41, 0x31, 0x4a, 0x46, 0x59, 0x8f, 471 0x46, 0x1e, 0xf5, 0xa4, 0x47, 0x00, 0xb9, 0xd6, 0x32, 0x50, 0x0e, 0x62, 0x94, 0x0c, 0xb3, 0x1e, 472 0x1d, 0xb5, 0x98, 0x27, 0x9c, 0xc0, 0x48, 0x28, 0x1b, 0xbe, 0xf7, 0x63, 0x94, 0xf4, 0xb3, 0x1e, 473 0x1d, 0x0a, 0x65, 0xb7, 0x21, 0x3f, 0xf4, 0x3a, 0x97, 0x3c, 0x30, 0x0e, 0x63, 0x94, 0xa0, 0x36, 474 0xc4, 0xa3, 0x9e, 0xb4, 0x80, 0x88, 0x19, 0xc3, 0x9a, 0xc0, 0x39, 0x8a, 0x51, 0x12, 0x9d, 0x3f, 475 0x4d, 0x77, 0xee, 0x92, 0x5e, 0xb4, 0x0a, 0xa7, 0xcf, 0x7a, 0x14, 0xd8, 0xb6, 0xc3, 0x4b, 0x18, 476 0x5f, 0xd6, 0x52, 0x54, 0xdd, 0x50, 0x03, 0x67, 0xf7, 0xfc, 0x0e, 0xbb, 0xf7, 0xdc, 0xcb, 0x17, 477 0xa2, 0xb2, 0xed, 0x7c, 0xde, 0xc2, 0x41, 0xf3, 0x63, 0x38, 0x72, 0x56, 0xb3, 0x0f, 0x00, 0x57, 478 0xb1, 0xf8, 0x35, 0x0c, 0x1c, 0x5c, 0x4d, 0x50, 0xdc, 0x4f, 0xa2, 0xf3, 0x27, 0x77, 0x4d, 0x1c, 479 0xfe, 0x3c, 0x0d, 0xb2, 0xd9, 0x47, 0x18, 0x5f, 0x8f, 0xdd, 0xdb, 0xb0, 0x13, 0x6f, 0x0d, 0xbf, 480 0xc2, 0xb0, 0xc3, 0xf0, 0x7d, 0xe8, 0x5f, 0xf2, 0xc6, 0x9f, 0x2a, 0x6d, 0x4b, 0xfc, 0x2a, 0xac, 481 0xe1, 0x8e, 0x71, 0x8f, 0x71, 0xc3, 0xf2, 0x2f, 0xe1, 0xde, 0x27, 0x77, 0x33, 0x76, 0x44, 0x3c, 482 0xb8, 0x1e, 0x31, 0xea, 0x94, 0x6f, 0xe1, 0xe1, 0x3b, 0x55, 0x59, 0xb3, 0x2e, 0xb8, 0xb2, 0xcc, 483 0x0a, 0xad, 0x16, 0x22, 0x37, 0xcc, 0x34, 0x18, 0xc3, 0xa1, 0x62, 0x45, 0xb8, 0x7b, 0xd4, 0xd5, 484 0x78, 0x02, 0xc7, 0x35, 0x37, 0x95, 0xd0, 0x2a, 0xb8, 0x74, 0xed, 0xfc, 0x17, 0xfa, 0xb3, 0x99, 485 0xa2, 0xbf, 0x9b, 0x29, 0xfa, 0xb7, 0x99, 0x22, 0x88, 0x85, 0xde, 0xbd, 0xc2, 0x3c, 0x7a, 0xe3, 486 0xca, 0x65, 0x0b, 0x2f, 0xd1, 0x17, 0xba, 0xba, 0x2d, 0x10, 0x9a, 0x68, 0xcb, 0x25, 0xe1, 0x3f, 487 0x4b, 0x6d, 0x2c, 0x37, 0x15, 0xd1, 0x56, 0x96, 0x44, 0x28, 0xcb, 0x8d, 0x62, 0x92, 0xdc, 0x60, 488 0x9f, 0x3a, 0xfb, 0xd3, 0x15, 0x57, 0x57, 0xcf, 0x2f, 0x1f, 0x38, 0xf0, 0xc5, 0xff, 0x00, 0x00, 489 0x00, 0xff, 0xff, 0x0e, 0x09, 0x81, 0x21, 0xa6, 0x03, 0x00, 0x00, 490} 491 492func (m *AnyValue) Marshal() (dAtA []byte, err error) { 493 size := m.Size() 494 dAtA = make([]byte, size) 495 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 496 if err != nil { 497 return nil, err 498 } 499 return dAtA[:n], nil 500} 501 502func (m *AnyValue) MarshalTo(dAtA []byte) (int, error) { 503 size := m.Size() 504 return m.MarshalToSizedBuffer(dAtA[:size]) 505} 506 507func (m *AnyValue) MarshalToSizedBuffer(dAtA []byte) (int, error) { 508 i := len(dAtA) 509 _ = i 510 var l int 511 _ = l 512 if m.XXX_unrecognized != nil { 513 i -= len(m.XXX_unrecognized) 514 copy(dAtA[i:], m.XXX_unrecognized) 515 } 516 if m.Value != nil { 517 { 518 size := m.Value.Size() 519 i -= size 520 if _, err := m.Value.MarshalTo(dAtA[i:]); err != nil { 521 return 0, err 522 } 523 } 524 } 525 return len(dAtA) - i, nil 526} 527 528func (m *AnyValue_StringValue) MarshalTo(dAtA []byte) (int, error) { 529 size := m.Size() 530 return m.MarshalToSizedBuffer(dAtA[:size]) 531} 532 533func (m *AnyValue_StringValue) MarshalToSizedBuffer(dAtA []byte) (int, error) { 534 i := len(dAtA) 535 i -= len(m.StringValue) 536 copy(dAtA[i:], m.StringValue) 537 i = encodeVarintCommon(dAtA, i, uint64(len(m.StringValue))) 538 i-- 539 dAtA[i] = 0xa 540 return len(dAtA) - i, nil 541} 542func (m *AnyValue_BoolValue) MarshalTo(dAtA []byte) (int, error) { 543 size := m.Size() 544 return m.MarshalToSizedBuffer(dAtA[:size]) 545} 546 547func (m *AnyValue_BoolValue) MarshalToSizedBuffer(dAtA []byte) (int, error) { 548 i := len(dAtA) 549 i-- 550 if m.BoolValue { 551 dAtA[i] = 1 552 } else { 553 dAtA[i] = 0 554 } 555 i-- 556 dAtA[i] = 0x10 557 return len(dAtA) - i, nil 558} 559func (m *AnyValue_IntValue) MarshalTo(dAtA []byte) (int, error) { 560 size := m.Size() 561 return m.MarshalToSizedBuffer(dAtA[:size]) 562} 563 564func (m *AnyValue_IntValue) MarshalToSizedBuffer(dAtA []byte) (int, error) { 565 i := len(dAtA) 566 i = encodeVarintCommon(dAtA, i, uint64(m.IntValue)) 567 i-- 568 dAtA[i] = 0x18 569 return len(dAtA) - i, nil 570} 571func (m *AnyValue_DoubleValue) MarshalTo(dAtA []byte) (int, error) { 572 size := m.Size() 573 return m.MarshalToSizedBuffer(dAtA[:size]) 574} 575 576func (m *AnyValue_DoubleValue) MarshalToSizedBuffer(dAtA []byte) (int, error) { 577 i := len(dAtA) 578 i -= 8 579 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.DoubleValue)))) 580 i-- 581 dAtA[i] = 0x21 582 return len(dAtA) - i, nil 583} 584func (m *AnyValue_ArrayValue) MarshalTo(dAtA []byte) (int, error) { 585 size := m.Size() 586 return m.MarshalToSizedBuffer(dAtA[:size]) 587} 588 589func (m *AnyValue_ArrayValue) MarshalToSizedBuffer(dAtA []byte) (int, error) { 590 i := len(dAtA) 591 if m.ArrayValue != nil { 592 { 593 size, err := m.ArrayValue.MarshalToSizedBuffer(dAtA[:i]) 594 if err != nil { 595 return 0, err 596 } 597 i -= size 598 i = encodeVarintCommon(dAtA, i, uint64(size)) 599 } 600 i-- 601 dAtA[i] = 0x2a 602 } 603 return len(dAtA) - i, nil 604} 605func (m *AnyValue_KvlistValue) MarshalTo(dAtA []byte) (int, error) { 606 size := m.Size() 607 return m.MarshalToSizedBuffer(dAtA[:size]) 608} 609 610func (m *AnyValue_KvlistValue) MarshalToSizedBuffer(dAtA []byte) (int, error) { 611 i := len(dAtA) 612 if m.KvlistValue != nil { 613 { 614 size, err := m.KvlistValue.MarshalToSizedBuffer(dAtA[:i]) 615 if err != nil { 616 return 0, err 617 } 618 i -= size 619 i = encodeVarintCommon(dAtA, i, uint64(size)) 620 } 621 i-- 622 dAtA[i] = 0x32 623 } 624 return len(dAtA) - i, nil 625} 626func (m *ArrayValue) Marshal() (dAtA []byte, err error) { 627 size := m.Size() 628 dAtA = make([]byte, size) 629 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 630 if err != nil { 631 return nil, err 632 } 633 return dAtA[:n], nil 634} 635 636func (m *ArrayValue) MarshalTo(dAtA []byte) (int, error) { 637 size := m.Size() 638 return m.MarshalToSizedBuffer(dAtA[:size]) 639} 640 641func (m *ArrayValue) MarshalToSizedBuffer(dAtA []byte) (int, error) { 642 i := len(dAtA) 643 _ = i 644 var l int 645 _ = l 646 if m.XXX_unrecognized != nil { 647 i -= len(m.XXX_unrecognized) 648 copy(dAtA[i:], m.XXX_unrecognized) 649 } 650 if len(m.Values) > 0 { 651 for iNdEx := len(m.Values) - 1; iNdEx >= 0; iNdEx-- { 652 { 653 size, err := m.Values[iNdEx].MarshalToSizedBuffer(dAtA[:i]) 654 if err != nil { 655 return 0, err 656 } 657 i -= size 658 i = encodeVarintCommon(dAtA, i, uint64(size)) 659 } 660 i-- 661 dAtA[i] = 0xa 662 } 663 } 664 return len(dAtA) - i, nil 665} 666 667func (m *KeyValueList) Marshal() (dAtA []byte, err error) { 668 size := m.Size() 669 dAtA = make([]byte, size) 670 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 671 if err != nil { 672 return nil, err 673 } 674 return dAtA[:n], nil 675} 676 677func (m *KeyValueList) MarshalTo(dAtA []byte) (int, error) { 678 size := m.Size() 679 return m.MarshalToSizedBuffer(dAtA[:size]) 680} 681 682func (m *KeyValueList) MarshalToSizedBuffer(dAtA []byte) (int, error) { 683 i := len(dAtA) 684 _ = i 685 var l int 686 _ = l 687 if m.XXX_unrecognized != nil { 688 i -= len(m.XXX_unrecognized) 689 copy(dAtA[i:], m.XXX_unrecognized) 690 } 691 if len(m.Values) > 0 { 692 for iNdEx := len(m.Values) - 1; iNdEx >= 0; iNdEx-- { 693 { 694 size, err := m.Values[iNdEx].MarshalToSizedBuffer(dAtA[:i]) 695 if err != nil { 696 return 0, err 697 } 698 i -= size 699 i = encodeVarintCommon(dAtA, i, uint64(size)) 700 } 701 i-- 702 dAtA[i] = 0xa 703 } 704 } 705 return len(dAtA) - i, nil 706} 707 708func (m *KeyValue) Marshal() (dAtA []byte, err error) { 709 size := m.Size() 710 dAtA = make([]byte, size) 711 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 712 if err != nil { 713 return nil, err 714 } 715 return dAtA[:n], nil 716} 717 718func (m *KeyValue) MarshalTo(dAtA []byte) (int, error) { 719 size := m.Size() 720 return m.MarshalToSizedBuffer(dAtA[:size]) 721} 722 723func (m *KeyValue) MarshalToSizedBuffer(dAtA []byte) (int, error) { 724 i := len(dAtA) 725 _ = i 726 var l int 727 _ = l 728 if m.XXX_unrecognized != nil { 729 i -= len(m.XXX_unrecognized) 730 copy(dAtA[i:], m.XXX_unrecognized) 731 } 732 if m.Value != nil { 733 { 734 size, err := m.Value.MarshalToSizedBuffer(dAtA[:i]) 735 if err != nil { 736 return 0, err 737 } 738 i -= size 739 i = encodeVarintCommon(dAtA, i, uint64(size)) 740 } 741 i-- 742 dAtA[i] = 0x12 743 } 744 if len(m.Key) > 0 { 745 i -= len(m.Key) 746 copy(dAtA[i:], m.Key) 747 i = encodeVarintCommon(dAtA, i, uint64(len(m.Key))) 748 i-- 749 dAtA[i] = 0xa 750 } 751 return len(dAtA) - i, nil 752} 753 754func (m *StringKeyValue) Marshal() (dAtA []byte, err error) { 755 size := m.Size() 756 dAtA = make([]byte, size) 757 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 758 if err != nil { 759 return nil, err 760 } 761 return dAtA[:n], nil 762} 763 764func (m *StringKeyValue) MarshalTo(dAtA []byte) (int, error) { 765 size := m.Size() 766 return m.MarshalToSizedBuffer(dAtA[:size]) 767} 768 769func (m *StringKeyValue) MarshalToSizedBuffer(dAtA []byte) (int, error) { 770 i := len(dAtA) 771 _ = i 772 var l int 773 _ = l 774 if m.XXX_unrecognized != nil { 775 i -= len(m.XXX_unrecognized) 776 copy(dAtA[i:], m.XXX_unrecognized) 777 } 778 if len(m.Value) > 0 { 779 i -= len(m.Value) 780 copy(dAtA[i:], m.Value) 781 i = encodeVarintCommon(dAtA, i, uint64(len(m.Value))) 782 i-- 783 dAtA[i] = 0x12 784 } 785 if len(m.Key) > 0 { 786 i -= len(m.Key) 787 copy(dAtA[i:], m.Key) 788 i = encodeVarintCommon(dAtA, i, uint64(len(m.Key))) 789 i-- 790 dAtA[i] = 0xa 791 } 792 return len(dAtA) - i, nil 793} 794 795func (m *InstrumentationLibrary) Marshal() (dAtA []byte, err error) { 796 size := m.Size() 797 dAtA = make([]byte, size) 798 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 799 if err != nil { 800 return nil, err 801 } 802 return dAtA[:n], nil 803} 804 805func (m *InstrumentationLibrary) MarshalTo(dAtA []byte) (int, error) { 806 size := m.Size() 807 return m.MarshalToSizedBuffer(dAtA[:size]) 808} 809 810func (m *InstrumentationLibrary) MarshalToSizedBuffer(dAtA []byte) (int, error) { 811 i := len(dAtA) 812 _ = i 813 var l int 814 _ = l 815 if m.XXX_unrecognized != nil { 816 i -= len(m.XXX_unrecognized) 817 copy(dAtA[i:], m.XXX_unrecognized) 818 } 819 if len(m.Version) > 0 { 820 i -= len(m.Version) 821 copy(dAtA[i:], m.Version) 822 i = encodeVarintCommon(dAtA, i, uint64(len(m.Version))) 823 i-- 824 dAtA[i] = 0x12 825 } 826 if len(m.Name) > 0 { 827 i -= len(m.Name) 828 copy(dAtA[i:], m.Name) 829 i = encodeVarintCommon(dAtA, i, uint64(len(m.Name))) 830 i-- 831 dAtA[i] = 0xa 832 } 833 return len(dAtA) - i, nil 834} 835 836func encodeVarintCommon(dAtA []byte, offset int, v uint64) int { 837 offset -= sovCommon(v) 838 base := offset 839 for v >= 1<<7 { 840 dAtA[offset] = uint8(v&0x7f | 0x80) 841 v >>= 7 842 offset++ 843 } 844 dAtA[offset] = uint8(v) 845 return base 846} 847func (m *AnyValue) Size() (n int) { 848 if m == nil { 849 return 0 850 } 851 var l int 852 _ = l 853 if m.Value != nil { 854 n += m.Value.Size() 855 } 856 if m.XXX_unrecognized != nil { 857 n += len(m.XXX_unrecognized) 858 } 859 return n 860} 861 862func (m *AnyValue_StringValue) Size() (n int) { 863 if m == nil { 864 return 0 865 } 866 var l int 867 _ = l 868 l = len(m.StringValue) 869 n += 1 + l + sovCommon(uint64(l)) 870 return n 871} 872func (m *AnyValue_BoolValue) Size() (n int) { 873 if m == nil { 874 return 0 875 } 876 var l int 877 _ = l 878 n += 2 879 return n 880} 881func (m *AnyValue_IntValue) Size() (n int) { 882 if m == nil { 883 return 0 884 } 885 var l int 886 _ = l 887 n += 1 + sovCommon(uint64(m.IntValue)) 888 return n 889} 890func (m *AnyValue_DoubleValue) Size() (n int) { 891 if m == nil { 892 return 0 893 } 894 var l int 895 _ = l 896 n += 9 897 return n 898} 899func (m *AnyValue_ArrayValue) Size() (n int) { 900 if m == nil { 901 return 0 902 } 903 var l int 904 _ = l 905 if m.ArrayValue != nil { 906 l = m.ArrayValue.Size() 907 n += 1 + l + sovCommon(uint64(l)) 908 } 909 return n 910} 911func (m *AnyValue_KvlistValue) Size() (n int) { 912 if m == nil { 913 return 0 914 } 915 var l int 916 _ = l 917 if m.KvlistValue != nil { 918 l = m.KvlistValue.Size() 919 n += 1 + l + sovCommon(uint64(l)) 920 } 921 return n 922} 923func (m *ArrayValue) Size() (n int) { 924 if m == nil { 925 return 0 926 } 927 var l int 928 _ = l 929 if len(m.Values) > 0 { 930 for _, e := range m.Values { 931 l = e.Size() 932 n += 1 + l + sovCommon(uint64(l)) 933 } 934 } 935 if m.XXX_unrecognized != nil { 936 n += len(m.XXX_unrecognized) 937 } 938 return n 939} 940 941func (m *KeyValueList) Size() (n int) { 942 if m == nil { 943 return 0 944 } 945 var l int 946 _ = l 947 if len(m.Values) > 0 { 948 for _, e := range m.Values { 949 l = e.Size() 950 n += 1 + l + sovCommon(uint64(l)) 951 } 952 } 953 if m.XXX_unrecognized != nil { 954 n += len(m.XXX_unrecognized) 955 } 956 return n 957} 958 959func (m *KeyValue) Size() (n int) { 960 if m == nil { 961 return 0 962 } 963 var l int 964 _ = l 965 l = len(m.Key) 966 if l > 0 { 967 n += 1 + l + sovCommon(uint64(l)) 968 } 969 if m.Value != nil { 970 l = m.Value.Size() 971 n += 1 + l + sovCommon(uint64(l)) 972 } 973 if m.XXX_unrecognized != nil { 974 n += len(m.XXX_unrecognized) 975 } 976 return n 977} 978 979func (m *StringKeyValue) Size() (n int) { 980 if m == nil { 981 return 0 982 } 983 var l int 984 _ = l 985 l = len(m.Key) 986 if l > 0 { 987 n += 1 + l + sovCommon(uint64(l)) 988 } 989 l = len(m.Value) 990 if l > 0 { 991 n += 1 + l + sovCommon(uint64(l)) 992 } 993 if m.XXX_unrecognized != nil { 994 n += len(m.XXX_unrecognized) 995 } 996 return n 997} 998 999func (m *InstrumentationLibrary) Size() (n int) { 1000 if m == nil { 1001 return 0 1002 } 1003 var l int 1004 _ = l 1005 l = len(m.Name) 1006 if l > 0 { 1007 n += 1 + l + sovCommon(uint64(l)) 1008 } 1009 l = len(m.Version) 1010 if l > 0 { 1011 n += 1 + l + sovCommon(uint64(l)) 1012 } 1013 if m.XXX_unrecognized != nil { 1014 n += len(m.XXX_unrecognized) 1015 } 1016 return n 1017} 1018 1019func sovCommon(x uint64) (n int) { 1020 return (math_bits.Len64(x|1) + 6) / 7 1021} 1022func sozCommon(x uint64) (n int) { 1023 return sovCommon(uint64((x << 1) ^ uint64((int64(x) >> 63)))) 1024} 1025func (m *AnyValue) Unmarshal(dAtA []byte) error { 1026 l := len(dAtA) 1027 iNdEx := 0 1028 for iNdEx < l { 1029 preIndex := iNdEx 1030 var wire uint64 1031 for shift := uint(0); ; shift += 7 { 1032 if shift >= 64 { 1033 return ErrIntOverflowCommon 1034 } 1035 if iNdEx >= l { 1036 return io.ErrUnexpectedEOF 1037 } 1038 b := dAtA[iNdEx] 1039 iNdEx++ 1040 wire |= uint64(b&0x7F) << shift 1041 if b < 0x80 { 1042 break 1043 } 1044 } 1045 fieldNum := int32(wire >> 3) 1046 wireType := int(wire & 0x7) 1047 if wireType == 4 { 1048 return fmt.Errorf("proto: AnyValue: wiretype end group for non-group") 1049 } 1050 if fieldNum <= 0 { 1051 return fmt.Errorf("proto: AnyValue: illegal tag %d (wire type %d)", fieldNum, wire) 1052 } 1053 switch fieldNum { 1054 case 1: 1055 if wireType != 2 { 1056 return fmt.Errorf("proto: wrong wireType = %d for field StringValue", wireType) 1057 } 1058 var stringLen uint64 1059 for shift := uint(0); ; shift += 7 { 1060 if shift >= 64 { 1061 return ErrIntOverflowCommon 1062 } 1063 if iNdEx >= l { 1064 return io.ErrUnexpectedEOF 1065 } 1066 b := dAtA[iNdEx] 1067 iNdEx++ 1068 stringLen |= uint64(b&0x7F) << shift 1069 if b < 0x80 { 1070 break 1071 } 1072 } 1073 intStringLen := int(stringLen) 1074 if intStringLen < 0 { 1075 return ErrInvalidLengthCommon 1076 } 1077 postIndex := iNdEx + intStringLen 1078 if postIndex < 0 { 1079 return ErrInvalidLengthCommon 1080 } 1081 if postIndex > l { 1082 return io.ErrUnexpectedEOF 1083 } 1084 m.Value = &AnyValue_StringValue{string(dAtA[iNdEx:postIndex])} 1085 iNdEx = postIndex 1086 case 2: 1087 if wireType != 0 { 1088 return fmt.Errorf("proto: wrong wireType = %d for field BoolValue", wireType) 1089 } 1090 var v int 1091 for shift := uint(0); ; shift += 7 { 1092 if shift >= 64 { 1093 return ErrIntOverflowCommon 1094 } 1095 if iNdEx >= l { 1096 return io.ErrUnexpectedEOF 1097 } 1098 b := dAtA[iNdEx] 1099 iNdEx++ 1100 v |= int(b&0x7F) << shift 1101 if b < 0x80 { 1102 break 1103 } 1104 } 1105 b := bool(v != 0) 1106 m.Value = &AnyValue_BoolValue{b} 1107 case 3: 1108 if wireType != 0 { 1109 return fmt.Errorf("proto: wrong wireType = %d for field IntValue", wireType) 1110 } 1111 var v int64 1112 for shift := uint(0); ; shift += 7 { 1113 if shift >= 64 { 1114 return ErrIntOverflowCommon 1115 } 1116 if iNdEx >= l { 1117 return io.ErrUnexpectedEOF 1118 } 1119 b := dAtA[iNdEx] 1120 iNdEx++ 1121 v |= int64(b&0x7F) << shift 1122 if b < 0x80 { 1123 break 1124 } 1125 } 1126 m.Value = &AnyValue_IntValue{v} 1127 case 4: 1128 if wireType != 1 { 1129 return fmt.Errorf("proto: wrong wireType = %d for field DoubleValue", wireType) 1130 } 1131 var v uint64 1132 if (iNdEx + 8) > l { 1133 return io.ErrUnexpectedEOF 1134 } 1135 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) 1136 iNdEx += 8 1137 m.Value = &AnyValue_DoubleValue{float64(math.Float64frombits(v))} 1138 case 5: 1139 if wireType != 2 { 1140 return fmt.Errorf("proto: wrong wireType = %d for field ArrayValue", wireType) 1141 } 1142 var msglen int 1143 for shift := uint(0); ; shift += 7 { 1144 if shift >= 64 { 1145 return ErrIntOverflowCommon 1146 } 1147 if iNdEx >= l { 1148 return io.ErrUnexpectedEOF 1149 } 1150 b := dAtA[iNdEx] 1151 iNdEx++ 1152 msglen |= int(b&0x7F) << shift 1153 if b < 0x80 { 1154 break 1155 } 1156 } 1157 if msglen < 0 { 1158 return ErrInvalidLengthCommon 1159 } 1160 postIndex := iNdEx + msglen 1161 if postIndex < 0 { 1162 return ErrInvalidLengthCommon 1163 } 1164 if postIndex > l { 1165 return io.ErrUnexpectedEOF 1166 } 1167 v := &ArrayValue{} 1168 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 1169 return err 1170 } 1171 m.Value = &AnyValue_ArrayValue{v} 1172 iNdEx = postIndex 1173 case 6: 1174 if wireType != 2 { 1175 return fmt.Errorf("proto: wrong wireType = %d for field KvlistValue", wireType) 1176 } 1177 var msglen int 1178 for shift := uint(0); ; shift += 7 { 1179 if shift >= 64 { 1180 return ErrIntOverflowCommon 1181 } 1182 if iNdEx >= l { 1183 return io.ErrUnexpectedEOF 1184 } 1185 b := dAtA[iNdEx] 1186 iNdEx++ 1187 msglen |= int(b&0x7F) << shift 1188 if b < 0x80 { 1189 break 1190 } 1191 } 1192 if msglen < 0 { 1193 return ErrInvalidLengthCommon 1194 } 1195 postIndex := iNdEx + msglen 1196 if postIndex < 0 { 1197 return ErrInvalidLengthCommon 1198 } 1199 if postIndex > l { 1200 return io.ErrUnexpectedEOF 1201 } 1202 v := &KeyValueList{} 1203 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 1204 return err 1205 } 1206 m.Value = &AnyValue_KvlistValue{v} 1207 iNdEx = postIndex 1208 default: 1209 iNdEx = preIndex 1210 skippy, err := skipCommon(dAtA[iNdEx:]) 1211 if err != nil { 1212 return err 1213 } 1214 if skippy < 0 { 1215 return ErrInvalidLengthCommon 1216 } 1217 if (iNdEx + skippy) < 0 { 1218 return ErrInvalidLengthCommon 1219 } 1220 if (iNdEx + skippy) > l { 1221 return io.ErrUnexpectedEOF 1222 } 1223 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 1224 iNdEx += skippy 1225 } 1226 } 1227 1228 if iNdEx > l { 1229 return io.ErrUnexpectedEOF 1230 } 1231 return nil 1232} 1233func (m *ArrayValue) Unmarshal(dAtA []byte) error { 1234 l := len(dAtA) 1235 iNdEx := 0 1236 for iNdEx < l { 1237 preIndex := iNdEx 1238 var wire uint64 1239 for shift := uint(0); ; shift += 7 { 1240 if shift >= 64 { 1241 return ErrIntOverflowCommon 1242 } 1243 if iNdEx >= l { 1244 return io.ErrUnexpectedEOF 1245 } 1246 b := dAtA[iNdEx] 1247 iNdEx++ 1248 wire |= uint64(b&0x7F) << shift 1249 if b < 0x80 { 1250 break 1251 } 1252 } 1253 fieldNum := int32(wire >> 3) 1254 wireType := int(wire & 0x7) 1255 if wireType == 4 { 1256 return fmt.Errorf("proto: ArrayValue: wiretype end group for non-group") 1257 } 1258 if fieldNum <= 0 { 1259 return fmt.Errorf("proto: ArrayValue: illegal tag %d (wire type %d)", fieldNum, wire) 1260 } 1261 switch fieldNum { 1262 case 1: 1263 if wireType != 2 { 1264 return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType) 1265 } 1266 var msglen int 1267 for shift := uint(0); ; shift += 7 { 1268 if shift >= 64 { 1269 return ErrIntOverflowCommon 1270 } 1271 if iNdEx >= l { 1272 return io.ErrUnexpectedEOF 1273 } 1274 b := dAtA[iNdEx] 1275 iNdEx++ 1276 msglen |= int(b&0x7F) << shift 1277 if b < 0x80 { 1278 break 1279 } 1280 } 1281 if msglen < 0 { 1282 return ErrInvalidLengthCommon 1283 } 1284 postIndex := iNdEx + msglen 1285 if postIndex < 0 { 1286 return ErrInvalidLengthCommon 1287 } 1288 if postIndex > l { 1289 return io.ErrUnexpectedEOF 1290 } 1291 m.Values = append(m.Values, &AnyValue{}) 1292 if err := m.Values[len(m.Values)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 1293 return err 1294 } 1295 iNdEx = postIndex 1296 default: 1297 iNdEx = preIndex 1298 skippy, err := skipCommon(dAtA[iNdEx:]) 1299 if err != nil { 1300 return err 1301 } 1302 if skippy < 0 { 1303 return ErrInvalidLengthCommon 1304 } 1305 if (iNdEx + skippy) < 0 { 1306 return ErrInvalidLengthCommon 1307 } 1308 if (iNdEx + skippy) > l { 1309 return io.ErrUnexpectedEOF 1310 } 1311 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 1312 iNdEx += skippy 1313 } 1314 } 1315 1316 if iNdEx > l { 1317 return io.ErrUnexpectedEOF 1318 } 1319 return nil 1320} 1321func (m *KeyValueList) Unmarshal(dAtA []byte) error { 1322 l := len(dAtA) 1323 iNdEx := 0 1324 for iNdEx < l { 1325 preIndex := iNdEx 1326 var wire uint64 1327 for shift := uint(0); ; shift += 7 { 1328 if shift >= 64 { 1329 return ErrIntOverflowCommon 1330 } 1331 if iNdEx >= l { 1332 return io.ErrUnexpectedEOF 1333 } 1334 b := dAtA[iNdEx] 1335 iNdEx++ 1336 wire |= uint64(b&0x7F) << shift 1337 if b < 0x80 { 1338 break 1339 } 1340 } 1341 fieldNum := int32(wire >> 3) 1342 wireType := int(wire & 0x7) 1343 if wireType == 4 { 1344 return fmt.Errorf("proto: KeyValueList: wiretype end group for non-group") 1345 } 1346 if fieldNum <= 0 { 1347 return fmt.Errorf("proto: KeyValueList: illegal tag %d (wire type %d)", fieldNum, wire) 1348 } 1349 switch fieldNum { 1350 case 1: 1351 if wireType != 2 { 1352 return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType) 1353 } 1354 var msglen int 1355 for shift := uint(0); ; shift += 7 { 1356 if shift >= 64 { 1357 return ErrIntOverflowCommon 1358 } 1359 if iNdEx >= l { 1360 return io.ErrUnexpectedEOF 1361 } 1362 b := dAtA[iNdEx] 1363 iNdEx++ 1364 msglen |= int(b&0x7F) << shift 1365 if b < 0x80 { 1366 break 1367 } 1368 } 1369 if msglen < 0 { 1370 return ErrInvalidLengthCommon 1371 } 1372 postIndex := iNdEx + msglen 1373 if postIndex < 0 { 1374 return ErrInvalidLengthCommon 1375 } 1376 if postIndex > l { 1377 return io.ErrUnexpectedEOF 1378 } 1379 m.Values = append(m.Values, &KeyValue{}) 1380 if err := m.Values[len(m.Values)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 1381 return err 1382 } 1383 iNdEx = postIndex 1384 default: 1385 iNdEx = preIndex 1386 skippy, err := skipCommon(dAtA[iNdEx:]) 1387 if err != nil { 1388 return err 1389 } 1390 if skippy < 0 { 1391 return ErrInvalidLengthCommon 1392 } 1393 if (iNdEx + skippy) < 0 { 1394 return ErrInvalidLengthCommon 1395 } 1396 if (iNdEx + skippy) > l { 1397 return io.ErrUnexpectedEOF 1398 } 1399 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 1400 iNdEx += skippy 1401 } 1402 } 1403 1404 if iNdEx > l { 1405 return io.ErrUnexpectedEOF 1406 } 1407 return nil 1408} 1409func (m *KeyValue) Unmarshal(dAtA []byte) error { 1410 l := len(dAtA) 1411 iNdEx := 0 1412 for iNdEx < l { 1413 preIndex := iNdEx 1414 var wire uint64 1415 for shift := uint(0); ; shift += 7 { 1416 if shift >= 64 { 1417 return ErrIntOverflowCommon 1418 } 1419 if iNdEx >= l { 1420 return io.ErrUnexpectedEOF 1421 } 1422 b := dAtA[iNdEx] 1423 iNdEx++ 1424 wire |= uint64(b&0x7F) << shift 1425 if b < 0x80 { 1426 break 1427 } 1428 } 1429 fieldNum := int32(wire >> 3) 1430 wireType := int(wire & 0x7) 1431 if wireType == 4 { 1432 return fmt.Errorf("proto: KeyValue: wiretype end group for non-group") 1433 } 1434 if fieldNum <= 0 { 1435 return fmt.Errorf("proto: KeyValue: illegal tag %d (wire type %d)", fieldNum, wire) 1436 } 1437 switch fieldNum { 1438 case 1: 1439 if wireType != 2 { 1440 return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) 1441 } 1442 var stringLen uint64 1443 for shift := uint(0); ; shift += 7 { 1444 if shift >= 64 { 1445 return ErrIntOverflowCommon 1446 } 1447 if iNdEx >= l { 1448 return io.ErrUnexpectedEOF 1449 } 1450 b := dAtA[iNdEx] 1451 iNdEx++ 1452 stringLen |= uint64(b&0x7F) << shift 1453 if b < 0x80 { 1454 break 1455 } 1456 } 1457 intStringLen := int(stringLen) 1458 if intStringLen < 0 { 1459 return ErrInvalidLengthCommon 1460 } 1461 postIndex := iNdEx + intStringLen 1462 if postIndex < 0 { 1463 return ErrInvalidLengthCommon 1464 } 1465 if postIndex > l { 1466 return io.ErrUnexpectedEOF 1467 } 1468 m.Key = string(dAtA[iNdEx:postIndex]) 1469 iNdEx = postIndex 1470 case 2: 1471 if wireType != 2 { 1472 return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) 1473 } 1474 var msglen int 1475 for shift := uint(0); ; shift += 7 { 1476 if shift >= 64 { 1477 return ErrIntOverflowCommon 1478 } 1479 if iNdEx >= l { 1480 return io.ErrUnexpectedEOF 1481 } 1482 b := dAtA[iNdEx] 1483 iNdEx++ 1484 msglen |= int(b&0x7F) << shift 1485 if b < 0x80 { 1486 break 1487 } 1488 } 1489 if msglen < 0 { 1490 return ErrInvalidLengthCommon 1491 } 1492 postIndex := iNdEx + msglen 1493 if postIndex < 0 { 1494 return ErrInvalidLengthCommon 1495 } 1496 if postIndex > l { 1497 return io.ErrUnexpectedEOF 1498 } 1499 if m.Value == nil { 1500 m.Value = &AnyValue{} 1501 } 1502 if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 1503 return err 1504 } 1505 iNdEx = postIndex 1506 default: 1507 iNdEx = preIndex 1508 skippy, err := skipCommon(dAtA[iNdEx:]) 1509 if err != nil { 1510 return err 1511 } 1512 if skippy < 0 { 1513 return ErrInvalidLengthCommon 1514 } 1515 if (iNdEx + skippy) < 0 { 1516 return ErrInvalidLengthCommon 1517 } 1518 if (iNdEx + skippy) > l { 1519 return io.ErrUnexpectedEOF 1520 } 1521 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 1522 iNdEx += skippy 1523 } 1524 } 1525 1526 if iNdEx > l { 1527 return io.ErrUnexpectedEOF 1528 } 1529 return nil 1530} 1531func (m *StringKeyValue) Unmarshal(dAtA []byte) error { 1532 l := len(dAtA) 1533 iNdEx := 0 1534 for iNdEx < l { 1535 preIndex := iNdEx 1536 var wire uint64 1537 for shift := uint(0); ; shift += 7 { 1538 if shift >= 64 { 1539 return ErrIntOverflowCommon 1540 } 1541 if iNdEx >= l { 1542 return io.ErrUnexpectedEOF 1543 } 1544 b := dAtA[iNdEx] 1545 iNdEx++ 1546 wire |= uint64(b&0x7F) << shift 1547 if b < 0x80 { 1548 break 1549 } 1550 } 1551 fieldNum := int32(wire >> 3) 1552 wireType := int(wire & 0x7) 1553 if wireType == 4 { 1554 return fmt.Errorf("proto: StringKeyValue: wiretype end group for non-group") 1555 } 1556 if fieldNum <= 0 { 1557 return fmt.Errorf("proto: StringKeyValue: illegal tag %d (wire type %d)", fieldNum, wire) 1558 } 1559 switch fieldNum { 1560 case 1: 1561 if wireType != 2 { 1562 return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) 1563 } 1564 var stringLen uint64 1565 for shift := uint(0); ; shift += 7 { 1566 if shift >= 64 { 1567 return ErrIntOverflowCommon 1568 } 1569 if iNdEx >= l { 1570 return io.ErrUnexpectedEOF 1571 } 1572 b := dAtA[iNdEx] 1573 iNdEx++ 1574 stringLen |= uint64(b&0x7F) << shift 1575 if b < 0x80 { 1576 break 1577 } 1578 } 1579 intStringLen := int(stringLen) 1580 if intStringLen < 0 { 1581 return ErrInvalidLengthCommon 1582 } 1583 postIndex := iNdEx + intStringLen 1584 if postIndex < 0 { 1585 return ErrInvalidLengthCommon 1586 } 1587 if postIndex > l { 1588 return io.ErrUnexpectedEOF 1589 } 1590 m.Key = string(dAtA[iNdEx:postIndex]) 1591 iNdEx = postIndex 1592 case 2: 1593 if wireType != 2 { 1594 return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) 1595 } 1596 var stringLen uint64 1597 for shift := uint(0); ; shift += 7 { 1598 if shift >= 64 { 1599 return ErrIntOverflowCommon 1600 } 1601 if iNdEx >= l { 1602 return io.ErrUnexpectedEOF 1603 } 1604 b := dAtA[iNdEx] 1605 iNdEx++ 1606 stringLen |= uint64(b&0x7F) << shift 1607 if b < 0x80 { 1608 break 1609 } 1610 } 1611 intStringLen := int(stringLen) 1612 if intStringLen < 0 { 1613 return ErrInvalidLengthCommon 1614 } 1615 postIndex := iNdEx + intStringLen 1616 if postIndex < 0 { 1617 return ErrInvalidLengthCommon 1618 } 1619 if postIndex > l { 1620 return io.ErrUnexpectedEOF 1621 } 1622 m.Value = string(dAtA[iNdEx:postIndex]) 1623 iNdEx = postIndex 1624 default: 1625 iNdEx = preIndex 1626 skippy, err := skipCommon(dAtA[iNdEx:]) 1627 if err != nil { 1628 return err 1629 } 1630 if skippy < 0 { 1631 return ErrInvalidLengthCommon 1632 } 1633 if (iNdEx + skippy) < 0 { 1634 return ErrInvalidLengthCommon 1635 } 1636 if (iNdEx + skippy) > l { 1637 return io.ErrUnexpectedEOF 1638 } 1639 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 1640 iNdEx += skippy 1641 } 1642 } 1643 1644 if iNdEx > l { 1645 return io.ErrUnexpectedEOF 1646 } 1647 return nil 1648} 1649func (m *InstrumentationLibrary) Unmarshal(dAtA []byte) error { 1650 l := len(dAtA) 1651 iNdEx := 0 1652 for iNdEx < l { 1653 preIndex := iNdEx 1654 var wire uint64 1655 for shift := uint(0); ; shift += 7 { 1656 if shift >= 64 { 1657 return ErrIntOverflowCommon 1658 } 1659 if iNdEx >= l { 1660 return io.ErrUnexpectedEOF 1661 } 1662 b := dAtA[iNdEx] 1663 iNdEx++ 1664 wire |= uint64(b&0x7F) << shift 1665 if b < 0x80 { 1666 break 1667 } 1668 } 1669 fieldNum := int32(wire >> 3) 1670 wireType := int(wire & 0x7) 1671 if wireType == 4 { 1672 return fmt.Errorf("proto: InstrumentationLibrary: wiretype end group for non-group") 1673 } 1674 if fieldNum <= 0 { 1675 return fmt.Errorf("proto: InstrumentationLibrary: illegal tag %d (wire type %d)", fieldNum, wire) 1676 } 1677 switch fieldNum { 1678 case 1: 1679 if wireType != 2 { 1680 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) 1681 } 1682 var stringLen uint64 1683 for shift := uint(0); ; shift += 7 { 1684 if shift >= 64 { 1685 return ErrIntOverflowCommon 1686 } 1687 if iNdEx >= l { 1688 return io.ErrUnexpectedEOF 1689 } 1690 b := dAtA[iNdEx] 1691 iNdEx++ 1692 stringLen |= uint64(b&0x7F) << shift 1693 if b < 0x80 { 1694 break 1695 } 1696 } 1697 intStringLen := int(stringLen) 1698 if intStringLen < 0 { 1699 return ErrInvalidLengthCommon 1700 } 1701 postIndex := iNdEx + intStringLen 1702 if postIndex < 0 { 1703 return ErrInvalidLengthCommon 1704 } 1705 if postIndex > l { 1706 return io.ErrUnexpectedEOF 1707 } 1708 m.Name = string(dAtA[iNdEx:postIndex]) 1709 iNdEx = postIndex 1710 case 2: 1711 if wireType != 2 { 1712 return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) 1713 } 1714 var stringLen uint64 1715 for shift := uint(0); ; shift += 7 { 1716 if shift >= 64 { 1717 return ErrIntOverflowCommon 1718 } 1719 if iNdEx >= l { 1720 return io.ErrUnexpectedEOF 1721 } 1722 b := dAtA[iNdEx] 1723 iNdEx++ 1724 stringLen |= uint64(b&0x7F) << shift 1725 if b < 0x80 { 1726 break 1727 } 1728 } 1729 intStringLen := int(stringLen) 1730 if intStringLen < 0 { 1731 return ErrInvalidLengthCommon 1732 } 1733 postIndex := iNdEx + intStringLen 1734 if postIndex < 0 { 1735 return ErrInvalidLengthCommon 1736 } 1737 if postIndex > l { 1738 return io.ErrUnexpectedEOF 1739 } 1740 m.Version = string(dAtA[iNdEx:postIndex]) 1741 iNdEx = postIndex 1742 default: 1743 iNdEx = preIndex 1744 skippy, err := skipCommon(dAtA[iNdEx:]) 1745 if err != nil { 1746 return err 1747 } 1748 if skippy < 0 { 1749 return ErrInvalidLengthCommon 1750 } 1751 if (iNdEx + skippy) < 0 { 1752 return ErrInvalidLengthCommon 1753 } 1754 if (iNdEx + skippy) > l { 1755 return io.ErrUnexpectedEOF 1756 } 1757 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 1758 iNdEx += skippy 1759 } 1760 } 1761 1762 if iNdEx > l { 1763 return io.ErrUnexpectedEOF 1764 } 1765 return nil 1766} 1767func skipCommon(dAtA []byte) (n int, err error) { 1768 l := len(dAtA) 1769 iNdEx := 0 1770 depth := 0 1771 for iNdEx < l { 1772 var wire uint64 1773 for shift := uint(0); ; shift += 7 { 1774 if shift >= 64 { 1775 return 0, ErrIntOverflowCommon 1776 } 1777 if iNdEx >= l { 1778 return 0, io.ErrUnexpectedEOF 1779 } 1780 b := dAtA[iNdEx] 1781 iNdEx++ 1782 wire |= (uint64(b) & 0x7F) << shift 1783 if b < 0x80 { 1784 break 1785 } 1786 } 1787 wireType := int(wire & 0x7) 1788 switch wireType { 1789 case 0: 1790 for shift := uint(0); ; shift += 7 { 1791 if shift >= 64 { 1792 return 0, ErrIntOverflowCommon 1793 } 1794 if iNdEx >= l { 1795 return 0, io.ErrUnexpectedEOF 1796 } 1797 iNdEx++ 1798 if dAtA[iNdEx-1] < 0x80 { 1799 break 1800 } 1801 } 1802 case 1: 1803 iNdEx += 8 1804 case 2: 1805 var length int 1806 for shift := uint(0); ; shift += 7 { 1807 if shift >= 64 { 1808 return 0, ErrIntOverflowCommon 1809 } 1810 if iNdEx >= l { 1811 return 0, io.ErrUnexpectedEOF 1812 } 1813 b := dAtA[iNdEx] 1814 iNdEx++ 1815 length |= (int(b) & 0x7F) << shift 1816 if b < 0x80 { 1817 break 1818 } 1819 } 1820 if length < 0 { 1821 return 0, ErrInvalidLengthCommon 1822 } 1823 iNdEx += length 1824 case 3: 1825 depth++ 1826 case 4: 1827 if depth == 0 { 1828 return 0, ErrUnexpectedEndOfGroupCommon 1829 } 1830 depth-- 1831 case 5: 1832 iNdEx += 4 1833 default: 1834 return 0, fmt.Errorf("proto: illegal wireType %d", wireType) 1835 } 1836 if iNdEx < 0 { 1837 return 0, ErrInvalidLengthCommon 1838 } 1839 if depth == 0 { 1840 return iNdEx, nil 1841 } 1842 } 1843 return 0, io.ErrUnexpectedEOF 1844} 1845 1846var ( 1847 ErrInvalidLengthCommon = fmt.Errorf("proto: negative length found during unmarshaling") 1848 ErrIntOverflowCommon = fmt.Errorf("proto: integer overflow") 1849 ErrUnexpectedEndOfGroupCommon = fmt.Errorf("proto: unexpected end of group") 1850) 1851