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