1// Autogenerated by Thrift Compiler (0.9.3) 2// DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING 3 4package sampling 5 6import ( 7 "bytes" 8 "fmt" 9 "github.com/uber/jaeger-client-go/thrift" 10) 11 12// (needed to ensure safety because of naive import list construction.) 13var _ = thrift.ZERO 14var _ = fmt.Printf 15var _ = bytes.Equal 16 17var GoUnusedProtection__ int 18 19type SamplingStrategyType int64 20 21const ( 22 SamplingStrategyType_PROBABILISTIC SamplingStrategyType = 0 23 SamplingStrategyType_RATE_LIMITING SamplingStrategyType = 1 24) 25 26func (p SamplingStrategyType) String() string { 27 switch p { 28 case SamplingStrategyType_PROBABILISTIC: 29 return "PROBABILISTIC" 30 case SamplingStrategyType_RATE_LIMITING: 31 return "RATE_LIMITING" 32 } 33 return "<UNSET>" 34} 35 36func SamplingStrategyTypeFromString(s string) (SamplingStrategyType, error) { 37 switch s { 38 case "PROBABILISTIC": 39 return SamplingStrategyType_PROBABILISTIC, nil 40 case "RATE_LIMITING": 41 return SamplingStrategyType_RATE_LIMITING, nil 42 } 43 return SamplingStrategyType(0), fmt.Errorf("not a valid SamplingStrategyType string") 44} 45 46func SamplingStrategyTypePtr(v SamplingStrategyType) *SamplingStrategyType { return &v } 47 48func (p SamplingStrategyType) MarshalText() ([]byte, error) { 49 return []byte(p.String()), nil 50} 51 52func (p *SamplingStrategyType) UnmarshalText(text []byte) error { 53 q, err := SamplingStrategyTypeFromString(string(text)) 54 if err != nil { 55 return err 56 } 57 *p = q 58 return nil 59} 60 61// Attributes: 62// - SamplingRate 63type ProbabilisticSamplingStrategy struct { 64 SamplingRate float64 `thrift:"samplingRate,1,required" json:"samplingRate"` 65} 66 67func NewProbabilisticSamplingStrategy() *ProbabilisticSamplingStrategy { 68 return &ProbabilisticSamplingStrategy{} 69} 70 71func (p *ProbabilisticSamplingStrategy) GetSamplingRate() float64 { 72 return p.SamplingRate 73} 74func (p *ProbabilisticSamplingStrategy) Read(iprot thrift.TProtocol) error { 75 if _, err := iprot.ReadStructBegin(); err != nil { 76 return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) 77 } 78 79 var issetSamplingRate bool = false 80 81 for { 82 _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin() 83 if err != nil { 84 return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err) 85 } 86 if fieldTypeId == thrift.STOP { 87 break 88 } 89 switch fieldId { 90 case 1: 91 if err := p.readField1(iprot); err != nil { 92 return err 93 } 94 issetSamplingRate = true 95 default: 96 if err := iprot.Skip(fieldTypeId); err != nil { 97 return err 98 } 99 } 100 if err := iprot.ReadFieldEnd(); err != nil { 101 return err 102 } 103 } 104 if err := iprot.ReadStructEnd(); err != nil { 105 return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) 106 } 107 if !issetSamplingRate { 108 return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field SamplingRate is not set")) 109 } 110 return nil 111} 112 113func (p *ProbabilisticSamplingStrategy) readField1(iprot thrift.TProtocol) error { 114 if v, err := iprot.ReadDouble(); err != nil { 115 return thrift.PrependError("error reading field 1: ", err) 116 } else { 117 p.SamplingRate = v 118 } 119 return nil 120} 121 122func (p *ProbabilisticSamplingStrategy) Write(oprot thrift.TProtocol) error { 123 if err := oprot.WriteStructBegin("ProbabilisticSamplingStrategy"); err != nil { 124 return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) 125 } 126 if err := p.writeField1(oprot); err != nil { 127 return err 128 } 129 if err := oprot.WriteFieldStop(); err != nil { 130 return thrift.PrependError("write field stop error: ", err) 131 } 132 if err := oprot.WriteStructEnd(); err != nil { 133 return thrift.PrependError("write struct stop error: ", err) 134 } 135 return nil 136} 137 138func (p *ProbabilisticSamplingStrategy) writeField1(oprot thrift.TProtocol) (err error) { 139 if err := oprot.WriteFieldBegin("samplingRate", thrift.DOUBLE, 1); err != nil { 140 return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:samplingRate: ", p), err) 141 } 142 if err := oprot.WriteDouble(float64(p.SamplingRate)); err != nil { 143 return thrift.PrependError(fmt.Sprintf("%T.samplingRate (1) field write error: ", p), err) 144 } 145 if err := oprot.WriteFieldEnd(); err != nil { 146 return thrift.PrependError(fmt.Sprintf("%T write field end error 1:samplingRate: ", p), err) 147 } 148 return err 149} 150 151func (p *ProbabilisticSamplingStrategy) String() string { 152 if p == nil { 153 return "<nil>" 154 } 155 return fmt.Sprintf("ProbabilisticSamplingStrategy(%+v)", *p) 156} 157 158// Attributes: 159// - MaxTracesPerSecond 160type RateLimitingSamplingStrategy struct { 161 MaxTracesPerSecond int16 `thrift:"maxTracesPerSecond,1,required" json:"maxTracesPerSecond"` 162} 163 164func NewRateLimitingSamplingStrategy() *RateLimitingSamplingStrategy { 165 return &RateLimitingSamplingStrategy{} 166} 167 168func (p *RateLimitingSamplingStrategy) GetMaxTracesPerSecond() int16 { 169 return p.MaxTracesPerSecond 170} 171func (p *RateLimitingSamplingStrategy) Read(iprot thrift.TProtocol) error { 172 if _, err := iprot.ReadStructBegin(); err != nil { 173 return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) 174 } 175 176 var issetMaxTracesPerSecond bool = false 177 178 for { 179 _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin() 180 if err != nil { 181 return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err) 182 } 183 if fieldTypeId == thrift.STOP { 184 break 185 } 186 switch fieldId { 187 case 1: 188 if err := p.readField1(iprot); err != nil { 189 return err 190 } 191 issetMaxTracesPerSecond = true 192 default: 193 if err := iprot.Skip(fieldTypeId); err != nil { 194 return err 195 } 196 } 197 if err := iprot.ReadFieldEnd(); err != nil { 198 return err 199 } 200 } 201 if err := iprot.ReadStructEnd(); err != nil { 202 return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) 203 } 204 if !issetMaxTracesPerSecond { 205 return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field MaxTracesPerSecond is not set")) 206 } 207 return nil 208} 209 210func (p *RateLimitingSamplingStrategy) readField1(iprot thrift.TProtocol) error { 211 if v, err := iprot.ReadI16(); err != nil { 212 return thrift.PrependError("error reading field 1: ", err) 213 } else { 214 p.MaxTracesPerSecond = v 215 } 216 return nil 217} 218 219func (p *RateLimitingSamplingStrategy) Write(oprot thrift.TProtocol) error { 220 if err := oprot.WriteStructBegin("RateLimitingSamplingStrategy"); err != nil { 221 return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) 222 } 223 if err := p.writeField1(oprot); err != nil { 224 return err 225 } 226 if err := oprot.WriteFieldStop(); err != nil { 227 return thrift.PrependError("write field stop error: ", err) 228 } 229 if err := oprot.WriteStructEnd(); err != nil { 230 return thrift.PrependError("write struct stop error: ", err) 231 } 232 return nil 233} 234 235func (p *RateLimitingSamplingStrategy) writeField1(oprot thrift.TProtocol) (err error) { 236 if err := oprot.WriteFieldBegin("maxTracesPerSecond", thrift.I16, 1); err != nil { 237 return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:maxTracesPerSecond: ", p), err) 238 } 239 if err := oprot.WriteI16(int16(p.MaxTracesPerSecond)); err != nil { 240 return thrift.PrependError(fmt.Sprintf("%T.maxTracesPerSecond (1) field write error: ", p), err) 241 } 242 if err := oprot.WriteFieldEnd(); err != nil { 243 return thrift.PrependError(fmt.Sprintf("%T write field end error 1:maxTracesPerSecond: ", p), err) 244 } 245 return err 246} 247 248func (p *RateLimitingSamplingStrategy) String() string { 249 if p == nil { 250 return "<nil>" 251 } 252 return fmt.Sprintf("RateLimitingSamplingStrategy(%+v)", *p) 253} 254 255// Attributes: 256// - Operation 257// - ProbabilisticSampling 258type OperationSamplingStrategy struct { 259 Operation string `thrift:"operation,1,required" json:"operation"` 260 ProbabilisticSampling *ProbabilisticSamplingStrategy `thrift:"probabilisticSampling,2,required" json:"probabilisticSampling"` 261} 262 263func NewOperationSamplingStrategy() *OperationSamplingStrategy { 264 return &OperationSamplingStrategy{} 265} 266 267func (p *OperationSamplingStrategy) GetOperation() string { 268 return p.Operation 269} 270 271var OperationSamplingStrategy_ProbabilisticSampling_DEFAULT *ProbabilisticSamplingStrategy 272 273func (p *OperationSamplingStrategy) GetProbabilisticSampling() *ProbabilisticSamplingStrategy { 274 if !p.IsSetProbabilisticSampling() { 275 return OperationSamplingStrategy_ProbabilisticSampling_DEFAULT 276 } 277 return p.ProbabilisticSampling 278} 279func (p *OperationSamplingStrategy) IsSetProbabilisticSampling() bool { 280 return p.ProbabilisticSampling != nil 281} 282 283func (p *OperationSamplingStrategy) Read(iprot thrift.TProtocol) error { 284 if _, err := iprot.ReadStructBegin(); err != nil { 285 return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) 286 } 287 288 var issetOperation bool = false 289 var issetProbabilisticSampling bool = false 290 291 for { 292 _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin() 293 if err != nil { 294 return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err) 295 } 296 if fieldTypeId == thrift.STOP { 297 break 298 } 299 switch fieldId { 300 case 1: 301 if err := p.readField1(iprot); err != nil { 302 return err 303 } 304 issetOperation = true 305 case 2: 306 if err := p.readField2(iprot); err != nil { 307 return err 308 } 309 issetProbabilisticSampling = true 310 default: 311 if err := iprot.Skip(fieldTypeId); err != nil { 312 return err 313 } 314 } 315 if err := iprot.ReadFieldEnd(); err != nil { 316 return err 317 } 318 } 319 if err := iprot.ReadStructEnd(); err != nil { 320 return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) 321 } 322 if !issetOperation { 323 return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field Operation is not set")) 324 } 325 if !issetProbabilisticSampling { 326 return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field ProbabilisticSampling is not set")) 327 } 328 return nil 329} 330 331func (p *OperationSamplingStrategy) readField1(iprot thrift.TProtocol) error { 332 if v, err := iprot.ReadString(); err != nil { 333 return thrift.PrependError("error reading field 1: ", err) 334 } else { 335 p.Operation = v 336 } 337 return nil 338} 339 340func (p *OperationSamplingStrategy) readField2(iprot thrift.TProtocol) error { 341 p.ProbabilisticSampling = &ProbabilisticSamplingStrategy{} 342 if err := p.ProbabilisticSampling.Read(iprot); err != nil { 343 return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.ProbabilisticSampling), err) 344 } 345 return nil 346} 347 348func (p *OperationSamplingStrategy) Write(oprot thrift.TProtocol) error { 349 if err := oprot.WriteStructBegin("OperationSamplingStrategy"); err != nil { 350 return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) 351 } 352 if err := p.writeField1(oprot); err != nil { 353 return err 354 } 355 if err := p.writeField2(oprot); err != nil { 356 return err 357 } 358 if err := oprot.WriteFieldStop(); err != nil { 359 return thrift.PrependError("write field stop error: ", err) 360 } 361 if err := oprot.WriteStructEnd(); err != nil { 362 return thrift.PrependError("write struct stop error: ", err) 363 } 364 return nil 365} 366 367func (p *OperationSamplingStrategy) writeField1(oprot thrift.TProtocol) (err error) { 368 if err := oprot.WriteFieldBegin("operation", thrift.STRING, 1); err != nil { 369 return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:operation: ", p), err) 370 } 371 if err := oprot.WriteString(string(p.Operation)); err != nil { 372 return thrift.PrependError(fmt.Sprintf("%T.operation (1) field write error: ", p), err) 373 } 374 if err := oprot.WriteFieldEnd(); err != nil { 375 return thrift.PrependError(fmt.Sprintf("%T write field end error 1:operation: ", p), err) 376 } 377 return err 378} 379 380func (p *OperationSamplingStrategy) writeField2(oprot thrift.TProtocol) (err error) { 381 if err := oprot.WriteFieldBegin("probabilisticSampling", thrift.STRUCT, 2); err != nil { 382 return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:probabilisticSampling: ", p), err) 383 } 384 if err := p.ProbabilisticSampling.Write(oprot); err != nil { 385 return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.ProbabilisticSampling), err) 386 } 387 if err := oprot.WriteFieldEnd(); err != nil { 388 return thrift.PrependError(fmt.Sprintf("%T write field end error 2:probabilisticSampling: ", p), err) 389 } 390 return err 391} 392 393func (p *OperationSamplingStrategy) String() string { 394 if p == nil { 395 return "<nil>" 396 } 397 return fmt.Sprintf("OperationSamplingStrategy(%+v)", *p) 398} 399 400// Attributes: 401// - DefaultSamplingProbability 402// - DefaultLowerBoundTracesPerSecond 403// - PerOperationStrategies 404// - DefaultUpperBoundTracesPerSecond 405type PerOperationSamplingStrategies struct { 406 DefaultSamplingProbability float64 `thrift:"defaultSamplingProbability,1,required" json:"defaultSamplingProbability"` 407 DefaultLowerBoundTracesPerSecond float64 `thrift:"defaultLowerBoundTracesPerSecond,2,required" json:"defaultLowerBoundTracesPerSecond"` 408 PerOperationStrategies []*OperationSamplingStrategy `thrift:"perOperationStrategies,3,required" json:"perOperationStrategies"` 409 DefaultUpperBoundTracesPerSecond *float64 `thrift:"defaultUpperBoundTracesPerSecond,4" json:"defaultUpperBoundTracesPerSecond,omitempty"` 410} 411 412func NewPerOperationSamplingStrategies() *PerOperationSamplingStrategies { 413 return &PerOperationSamplingStrategies{} 414} 415 416func (p *PerOperationSamplingStrategies) GetDefaultSamplingProbability() float64 { 417 return p.DefaultSamplingProbability 418} 419 420func (p *PerOperationSamplingStrategies) GetDefaultLowerBoundTracesPerSecond() float64 { 421 return p.DefaultLowerBoundTracesPerSecond 422} 423 424func (p *PerOperationSamplingStrategies) GetPerOperationStrategies() []*OperationSamplingStrategy { 425 return p.PerOperationStrategies 426} 427 428var PerOperationSamplingStrategies_DefaultUpperBoundTracesPerSecond_DEFAULT float64 429 430func (p *PerOperationSamplingStrategies) GetDefaultUpperBoundTracesPerSecond() float64 { 431 if !p.IsSetDefaultUpperBoundTracesPerSecond() { 432 return PerOperationSamplingStrategies_DefaultUpperBoundTracesPerSecond_DEFAULT 433 } 434 return *p.DefaultUpperBoundTracesPerSecond 435} 436func (p *PerOperationSamplingStrategies) IsSetDefaultUpperBoundTracesPerSecond() bool { 437 return p.DefaultUpperBoundTracesPerSecond != nil 438} 439 440func (p *PerOperationSamplingStrategies) Read(iprot thrift.TProtocol) error { 441 if _, err := iprot.ReadStructBegin(); err != nil { 442 return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) 443 } 444 445 var issetDefaultSamplingProbability bool = false 446 var issetDefaultLowerBoundTracesPerSecond bool = false 447 var issetPerOperationStrategies bool = false 448 449 for { 450 _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin() 451 if err != nil { 452 return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err) 453 } 454 if fieldTypeId == thrift.STOP { 455 break 456 } 457 switch fieldId { 458 case 1: 459 if err := p.readField1(iprot); err != nil { 460 return err 461 } 462 issetDefaultSamplingProbability = true 463 case 2: 464 if err := p.readField2(iprot); err != nil { 465 return err 466 } 467 issetDefaultLowerBoundTracesPerSecond = true 468 case 3: 469 if err := p.readField3(iprot); err != nil { 470 return err 471 } 472 issetPerOperationStrategies = true 473 case 4: 474 if err := p.readField4(iprot); err != nil { 475 return err 476 } 477 default: 478 if err := iprot.Skip(fieldTypeId); err != nil { 479 return err 480 } 481 } 482 if err := iprot.ReadFieldEnd(); err != nil { 483 return err 484 } 485 } 486 if err := iprot.ReadStructEnd(); err != nil { 487 return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) 488 } 489 if !issetDefaultSamplingProbability { 490 return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field DefaultSamplingProbability is not set")) 491 } 492 if !issetDefaultLowerBoundTracesPerSecond { 493 return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field DefaultLowerBoundTracesPerSecond is not set")) 494 } 495 if !issetPerOperationStrategies { 496 return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field PerOperationStrategies is not set")) 497 } 498 return nil 499} 500 501func (p *PerOperationSamplingStrategies) readField1(iprot thrift.TProtocol) error { 502 if v, err := iprot.ReadDouble(); err != nil { 503 return thrift.PrependError("error reading field 1: ", err) 504 } else { 505 p.DefaultSamplingProbability = v 506 } 507 return nil 508} 509 510func (p *PerOperationSamplingStrategies) readField2(iprot thrift.TProtocol) error { 511 if v, err := iprot.ReadDouble(); err != nil { 512 return thrift.PrependError("error reading field 2: ", err) 513 } else { 514 p.DefaultLowerBoundTracesPerSecond = v 515 } 516 return nil 517} 518 519func (p *PerOperationSamplingStrategies) readField3(iprot thrift.TProtocol) error { 520 _, size, err := iprot.ReadListBegin() 521 if err != nil { 522 return thrift.PrependError("error reading list begin: ", err) 523 } 524 tSlice := make([]*OperationSamplingStrategy, 0, size) 525 p.PerOperationStrategies = tSlice 526 for i := 0; i < size; i++ { 527 _elem0 := &OperationSamplingStrategy{} 528 if err := _elem0.Read(iprot); err != nil { 529 return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem0), err) 530 } 531 p.PerOperationStrategies = append(p.PerOperationStrategies, _elem0) 532 } 533 if err := iprot.ReadListEnd(); err != nil { 534 return thrift.PrependError("error reading list end: ", err) 535 } 536 return nil 537} 538 539func (p *PerOperationSamplingStrategies) readField4(iprot thrift.TProtocol) error { 540 if v, err := iprot.ReadDouble(); err != nil { 541 return thrift.PrependError("error reading field 4: ", err) 542 } else { 543 p.DefaultUpperBoundTracesPerSecond = &v 544 } 545 return nil 546} 547 548func (p *PerOperationSamplingStrategies) Write(oprot thrift.TProtocol) error { 549 if err := oprot.WriteStructBegin("PerOperationSamplingStrategies"); err != nil { 550 return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) 551 } 552 if err := p.writeField1(oprot); err != nil { 553 return err 554 } 555 if err := p.writeField2(oprot); err != nil { 556 return err 557 } 558 if err := p.writeField3(oprot); err != nil { 559 return err 560 } 561 if err := p.writeField4(oprot); err != nil { 562 return err 563 } 564 if err := oprot.WriteFieldStop(); err != nil { 565 return thrift.PrependError("write field stop error: ", err) 566 } 567 if err := oprot.WriteStructEnd(); err != nil { 568 return thrift.PrependError("write struct stop error: ", err) 569 } 570 return nil 571} 572 573func (p *PerOperationSamplingStrategies) writeField1(oprot thrift.TProtocol) (err error) { 574 if err := oprot.WriteFieldBegin("defaultSamplingProbability", thrift.DOUBLE, 1); err != nil { 575 return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:defaultSamplingProbability: ", p), err) 576 } 577 if err := oprot.WriteDouble(float64(p.DefaultSamplingProbability)); err != nil { 578 return thrift.PrependError(fmt.Sprintf("%T.defaultSamplingProbability (1) field write error: ", p), err) 579 } 580 if err := oprot.WriteFieldEnd(); err != nil { 581 return thrift.PrependError(fmt.Sprintf("%T write field end error 1:defaultSamplingProbability: ", p), err) 582 } 583 return err 584} 585 586func (p *PerOperationSamplingStrategies) writeField2(oprot thrift.TProtocol) (err error) { 587 if err := oprot.WriteFieldBegin("defaultLowerBoundTracesPerSecond", thrift.DOUBLE, 2); err != nil { 588 return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:defaultLowerBoundTracesPerSecond: ", p), err) 589 } 590 if err := oprot.WriteDouble(float64(p.DefaultLowerBoundTracesPerSecond)); err != nil { 591 return thrift.PrependError(fmt.Sprintf("%T.defaultLowerBoundTracesPerSecond (2) field write error: ", p), err) 592 } 593 if err := oprot.WriteFieldEnd(); err != nil { 594 return thrift.PrependError(fmt.Sprintf("%T write field end error 2:defaultLowerBoundTracesPerSecond: ", p), err) 595 } 596 return err 597} 598 599func (p *PerOperationSamplingStrategies) writeField3(oprot thrift.TProtocol) (err error) { 600 if err := oprot.WriteFieldBegin("perOperationStrategies", thrift.LIST, 3); err != nil { 601 return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:perOperationStrategies: ", p), err) 602 } 603 if err := oprot.WriteListBegin(thrift.STRUCT, len(p.PerOperationStrategies)); err != nil { 604 return thrift.PrependError("error writing list begin: ", err) 605 } 606 for _, v := range p.PerOperationStrategies { 607 if err := v.Write(oprot); err != nil { 608 return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", v), err) 609 } 610 } 611 if err := oprot.WriteListEnd(); err != nil { 612 return thrift.PrependError("error writing list end: ", err) 613 } 614 if err := oprot.WriteFieldEnd(); err != nil { 615 return thrift.PrependError(fmt.Sprintf("%T write field end error 3:perOperationStrategies: ", p), err) 616 } 617 return err 618} 619 620func (p *PerOperationSamplingStrategies) writeField4(oprot thrift.TProtocol) (err error) { 621 if p.IsSetDefaultUpperBoundTracesPerSecond() { 622 if err := oprot.WriteFieldBegin("defaultUpperBoundTracesPerSecond", thrift.DOUBLE, 4); err != nil { 623 return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:defaultUpperBoundTracesPerSecond: ", p), err) 624 } 625 if err := oprot.WriteDouble(float64(*p.DefaultUpperBoundTracesPerSecond)); err != nil { 626 return thrift.PrependError(fmt.Sprintf("%T.defaultUpperBoundTracesPerSecond (4) field write error: ", p), err) 627 } 628 if err := oprot.WriteFieldEnd(); err != nil { 629 return thrift.PrependError(fmt.Sprintf("%T write field end error 4:defaultUpperBoundTracesPerSecond: ", p), err) 630 } 631 } 632 return err 633} 634 635func (p *PerOperationSamplingStrategies) String() string { 636 if p == nil { 637 return "<nil>" 638 } 639 return fmt.Sprintf("PerOperationSamplingStrategies(%+v)", *p) 640} 641 642// Attributes: 643// - StrategyType 644// - ProbabilisticSampling 645// - RateLimitingSampling 646// - OperationSampling 647type SamplingStrategyResponse struct { 648 StrategyType SamplingStrategyType `thrift:"strategyType,1,required" json:"strategyType"` 649 ProbabilisticSampling *ProbabilisticSamplingStrategy `thrift:"probabilisticSampling,2" json:"probabilisticSampling,omitempty"` 650 RateLimitingSampling *RateLimitingSamplingStrategy `thrift:"rateLimitingSampling,3" json:"rateLimitingSampling,omitempty"` 651 OperationSampling *PerOperationSamplingStrategies `thrift:"operationSampling,4" json:"operationSampling,omitempty"` 652} 653 654func NewSamplingStrategyResponse() *SamplingStrategyResponse { 655 return &SamplingStrategyResponse{} 656} 657 658func (p *SamplingStrategyResponse) GetStrategyType() SamplingStrategyType { 659 return p.StrategyType 660} 661 662var SamplingStrategyResponse_ProbabilisticSampling_DEFAULT *ProbabilisticSamplingStrategy 663 664func (p *SamplingStrategyResponse) GetProbabilisticSampling() *ProbabilisticSamplingStrategy { 665 if !p.IsSetProbabilisticSampling() { 666 return SamplingStrategyResponse_ProbabilisticSampling_DEFAULT 667 } 668 return p.ProbabilisticSampling 669} 670 671var SamplingStrategyResponse_RateLimitingSampling_DEFAULT *RateLimitingSamplingStrategy 672 673func (p *SamplingStrategyResponse) GetRateLimitingSampling() *RateLimitingSamplingStrategy { 674 if !p.IsSetRateLimitingSampling() { 675 return SamplingStrategyResponse_RateLimitingSampling_DEFAULT 676 } 677 return p.RateLimitingSampling 678} 679 680var SamplingStrategyResponse_OperationSampling_DEFAULT *PerOperationSamplingStrategies 681 682func (p *SamplingStrategyResponse) GetOperationSampling() *PerOperationSamplingStrategies { 683 if !p.IsSetOperationSampling() { 684 return SamplingStrategyResponse_OperationSampling_DEFAULT 685 } 686 return p.OperationSampling 687} 688func (p *SamplingStrategyResponse) IsSetProbabilisticSampling() bool { 689 return p.ProbabilisticSampling != nil 690} 691 692func (p *SamplingStrategyResponse) IsSetRateLimitingSampling() bool { 693 return p.RateLimitingSampling != nil 694} 695 696func (p *SamplingStrategyResponse) IsSetOperationSampling() bool { 697 return p.OperationSampling != nil 698} 699 700func (p *SamplingStrategyResponse) Read(iprot thrift.TProtocol) error { 701 if _, err := iprot.ReadStructBegin(); err != nil { 702 return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) 703 } 704 705 var issetStrategyType bool = false 706 707 for { 708 _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin() 709 if err != nil { 710 return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err) 711 } 712 if fieldTypeId == thrift.STOP { 713 break 714 } 715 switch fieldId { 716 case 1: 717 if err := p.readField1(iprot); err != nil { 718 return err 719 } 720 issetStrategyType = true 721 case 2: 722 if err := p.readField2(iprot); err != nil { 723 return err 724 } 725 case 3: 726 if err := p.readField3(iprot); err != nil { 727 return err 728 } 729 case 4: 730 if err := p.readField4(iprot); err != nil { 731 return err 732 } 733 default: 734 if err := iprot.Skip(fieldTypeId); err != nil { 735 return err 736 } 737 } 738 if err := iprot.ReadFieldEnd(); err != nil { 739 return err 740 } 741 } 742 if err := iprot.ReadStructEnd(); err != nil { 743 return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) 744 } 745 if !issetStrategyType { 746 return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field StrategyType is not set")) 747 } 748 return nil 749} 750 751func (p *SamplingStrategyResponse) readField1(iprot thrift.TProtocol) error { 752 if v, err := iprot.ReadI32(); err != nil { 753 return thrift.PrependError("error reading field 1: ", err) 754 } else { 755 temp := SamplingStrategyType(v) 756 p.StrategyType = temp 757 } 758 return nil 759} 760 761func (p *SamplingStrategyResponse) readField2(iprot thrift.TProtocol) error { 762 p.ProbabilisticSampling = &ProbabilisticSamplingStrategy{} 763 if err := p.ProbabilisticSampling.Read(iprot); err != nil { 764 return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.ProbabilisticSampling), err) 765 } 766 return nil 767} 768 769func (p *SamplingStrategyResponse) readField3(iprot thrift.TProtocol) error { 770 p.RateLimitingSampling = &RateLimitingSamplingStrategy{} 771 if err := p.RateLimitingSampling.Read(iprot); err != nil { 772 return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.RateLimitingSampling), err) 773 } 774 return nil 775} 776 777func (p *SamplingStrategyResponse) readField4(iprot thrift.TProtocol) error { 778 p.OperationSampling = &PerOperationSamplingStrategies{} 779 if err := p.OperationSampling.Read(iprot); err != nil { 780 return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.OperationSampling), err) 781 } 782 return nil 783} 784 785func (p *SamplingStrategyResponse) Write(oprot thrift.TProtocol) error { 786 if err := oprot.WriteStructBegin("SamplingStrategyResponse"); err != nil { 787 return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) 788 } 789 if err := p.writeField1(oprot); err != nil { 790 return err 791 } 792 if err := p.writeField2(oprot); err != nil { 793 return err 794 } 795 if err := p.writeField3(oprot); err != nil { 796 return err 797 } 798 if err := p.writeField4(oprot); err != nil { 799 return err 800 } 801 if err := oprot.WriteFieldStop(); err != nil { 802 return thrift.PrependError("write field stop error: ", err) 803 } 804 if err := oprot.WriteStructEnd(); err != nil { 805 return thrift.PrependError("write struct stop error: ", err) 806 } 807 return nil 808} 809 810func (p *SamplingStrategyResponse) writeField1(oprot thrift.TProtocol) (err error) { 811 if err := oprot.WriteFieldBegin("strategyType", thrift.I32, 1); err != nil { 812 return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:strategyType: ", p), err) 813 } 814 if err := oprot.WriteI32(int32(p.StrategyType)); err != nil { 815 return thrift.PrependError(fmt.Sprintf("%T.strategyType (1) field write error: ", p), err) 816 } 817 if err := oprot.WriteFieldEnd(); err != nil { 818 return thrift.PrependError(fmt.Sprintf("%T write field end error 1:strategyType: ", p), err) 819 } 820 return err 821} 822 823func (p *SamplingStrategyResponse) writeField2(oprot thrift.TProtocol) (err error) { 824 if p.IsSetProbabilisticSampling() { 825 if err := oprot.WriteFieldBegin("probabilisticSampling", thrift.STRUCT, 2); err != nil { 826 return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:probabilisticSampling: ", p), err) 827 } 828 if err := p.ProbabilisticSampling.Write(oprot); err != nil { 829 return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.ProbabilisticSampling), err) 830 } 831 if err := oprot.WriteFieldEnd(); err != nil { 832 return thrift.PrependError(fmt.Sprintf("%T write field end error 2:probabilisticSampling: ", p), err) 833 } 834 } 835 return err 836} 837 838func (p *SamplingStrategyResponse) writeField3(oprot thrift.TProtocol) (err error) { 839 if p.IsSetRateLimitingSampling() { 840 if err := oprot.WriteFieldBegin("rateLimitingSampling", thrift.STRUCT, 3); err != nil { 841 return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:rateLimitingSampling: ", p), err) 842 } 843 if err := p.RateLimitingSampling.Write(oprot); err != nil { 844 return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.RateLimitingSampling), err) 845 } 846 if err := oprot.WriteFieldEnd(); err != nil { 847 return thrift.PrependError(fmt.Sprintf("%T write field end error 3:rateLimitingSampling: ", p), err) 848 } 849 } 850 return err 851} 852 853func (p *SamplingStrategyResponse) writeField4(oprot thrift.TProtocol) (err error) { 854 if p.IsSetOperationSampling() { 855 if err := oprot.WriteFieldBegin("operationSampling", thrift.STRUCT, 4); err != nil { 856 return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:operationSampling: ", p), err) 857 } 858 if err := p.OperationSampling.Write(oprot); err != nil { 859 return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.OperationSampling), err) 860 } 861 if err := oprot.WriteFieldEnd(); err != nil { 862 return thrift.PrependError(fmt.Sprintf("%T write field end error 4:operationSampling: ", p), err) 863 } 864 } 865 return err 866} 867 868func (p *SamplingStrategyResponse) String() string { 869 if p == nil { 870 return "<nil>" 871 } 872 return fmt.Sprintf("SamplingStrategyResponse(%+v)", *p) 873} 874