github.com/cloudwan/edgelq-sdk@v1.15.4/monitoring/resources/v3/time_serie/time_serie.pb.fieldpath.go (about) 1 // Code generated by protoc-gen-goten-object 2 // File: edgelq/monitoring/proto/v3/time_serie.proto 3 // DO NOT EDIT!!! 4 5 package time_serie 6 7 import ( 8 "encoding/json" 9 "fmt" 10 "reflect" 11 "strings" 12 "time" 13 14 "google.golang.org/grpc/codes" 15 "google.golang.org/grpc/status" 16 "google.golang.org/protobuf/encoding/protojson" 17 "google.golang.org/protobuf/proto" 18 "google.golang.org/protobuf/reflect/protoregistry" 19 20 gotenobject "github.com/cloudwan/goten-sdk/runtime/object" 21 "github.com/cloudwan/goten-sdk/runtime/strcase" 22 ) 23 24 // proto imports 25 import ( 26 common "github.com/cloudwan/edgelq-sdk/monitoring/resources/v3/common" 27 metric_descriptor "github.com/cloudwan/edgelq-sdk/monitoring/resources/v3/metric_descriptor" 28 ) 29 30 // ensure the imports are used 31 var ( 32 _ = new(json.Marshaler) 33 _ = new(fmt.Stringer) 34 _ = reflect.DeepEqual 35 _ = strings.Builder{} 36 _ = time.Second 37 38 _ = strcase.ToLowerCamel 39 _ = codes.NotFound 40 _ = status.Status{} 41 _ = protojson.UnmarshalOptions{} 42 _ = new(proto.Message) 43 _ = protoregistry.GlobalTypes 44 45 _ = new(gotenobject.FieldPath) 46 ) 47 48 // make sure we're using proto imports 49 var ( 50 _ = &common.LabelDescriptor{} 51 _ = &metric_descriptor.MetricDescriptor{} 52 ) 53 54 // FieldPath provides implementation to handle 55 // https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto 56 type Point_FieldPath interface { 57 gotenobject.FieldPath 58 Selector() Point_FieldPathSelector 59 Get(source *Point) []interface{} 60 GetSingle(source *Point) (interface{}, bool) 61 ClearValue(item *Point) 62 63 // Those methods build corresponding Point_FieldPathValue 64 // (or array of values) and holds passed value. Panics if injected type is incorrect. 65 WithIValue(value interface{}) Point_FieldPathValue 66 WithIArrayOfValues(values interface{}) Point_FieldPathArrayOfValues 67 WithIArrayItemValue(value interface{}) Point_FieldPathArrayItemValue 68 } 69 70 type Point_FieldPathSelector int32 71 72 const ( 73 Point_FieldPathSelectorInterval Point_FieldPathSelector = 0 74 Point_FieldPathSelectorValue Point_FieldPathSelector = 1 75 Point_FieldPathSelectorAggregation Point_FieldPathSelector = 2 76 ) 77 78 func (s Point_FieldPathSelector) String() string { 79 switch s { 80 case Point_FieldPathSelectorInterval: 81 return "interval" 82 case Point_FieldPathSelectorValue: 83 return "value" 84 case Point_FieldPathSelectorAggregation: 85 return "aggregation" 86 default: 87 panic(fmt.Sprintf("Invalid selector for Point: %d", s)) 88 } 89 } 90 91 func BuildPoint_FieldPath(fp gotenobject.RawFieldPath) (Point_FieldPath, error) { 92 if len(fp) == 0 { 93 return nil, status.Error(codes.InvalidArgument, "empty field path for object Point") 94 } 95 if len(fp) == 1 { 96 switch fp[0] { 97 case "interval": 98 return &Point_FieldTerminalPath{selector: Point_FieldPathSelectorInterval}, nil 99 case "value": 100 return &Point_FieldTerminalPath{selector: Point_FieldPathSelectorValue}, nil 101 case "aggregation": 102 return &Point_FieldTerminalPath{selector: Point_FieldPathSelectorAggregation}, nil 103 } 104 } else { 105 switch fp[0] { 106 case "interval": 107 if subpath, err := common.BuildTimeInterval_FieldPath(fp[1:]); err != nil { 108 return nil, err 109 } else { 110 return &Point_FieldSubPath{selector: Point_FieldPathSelectorInterval, subPath: subpath}, nil 111 } 112 case "value": 113 if subpath, err := common.BuildTypedValue_FieldPath(fp[1:]); err != nil { 114 return nil, err 115 } else { 116 return &Point_FieldSubPath{selector: Point_FieldPathSelectorValue, subPath: subpath}, nil 117 } 118 case "aggregation": 119 if subpath, err := common.BuildAggregation_FieldPath(fp[1:]); err != nil { 120 return nil, err 121 } else { 122 return &Point_FieldSubPath{selector: Point_FieldPathSelectorAggregation, subPath: subpath}, nil 123 } 124 } 125 } 126 return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Point", fp) 127 } 128 129 func ParsePoint_FieldPath(rawField string) (Point_FieldPath, error) { 130 fp, err := gotenobject.ParseRawFieldPath(rawField) 131 if err != nil { 132 return nil, err 133 } 134 return BuildPoint_FieldPath(fp) 135 } 136 137 func MustParsePoint_FieldPath(rawField string) Point_FieldPath { 138 fp, err := ParsePoint_FieldPath(rawField) 139 if err != nil { 140 panic(err) 141 } 142 return fp 143 } 144 145 type Point_FieldTerminalPath struct { 146 selector Point_FieldPathSelector 147 } 148 149 var _ Point_FieldPath = (*Point_FieldTerminalPath)(nil) 150 151 func (fp *Point_FieldTerminalPath) Selector() Point_FieldPathSelector { 152 return fp.selector 153 } 154 155 // String returns path representation in proto convention 156 func (fp *Point_FieldTerminalPath) String() string { 157 return fp.selector.String() 158 } 159 160 // JSONString returns path representation is JSON convention 161 func (fp *Point_FieldTerminalPath) JSONString() string { 162 return strcase.ToLowerCamel(fp.String()) 163 } 164 165 // Get returns all values pointed by specific field from source Point 166 func (fp *Point_FieldTerminalPath) Get(source *Point) (values []interface{}) { 167 if source != nil { 168 switch fp.selector { 169 case Point_FieldPathSelectorInterval: 170 if source.Interval != nil { 171 values = append(values, source.Interval) 172 } 173 case Point_FieldPathSelectorValue: 174 if source.Value != nil { 175 values = append(values, source.Value) 176 } 177 case Point_FieldPathSelectorAggregation: 178 if source.Aggregation != nil { 179 values = append(values, source.Aggregation) 180 } 181 default: 182 panic(fmt.Sprintf("Invalid selector for Point: %d", fp.selector)) 183 } 184 } 185 return 186 } 187 188 func (fp *Point_FieldTerminalPath) GetRaw(source proto.Message) []interface{} { 189 return fp.Get(source.(*Point)) 190 } 191 192 // GetSingle returns value pointed by specific field of from source Point 193 func (fp *Point_FieldTerminalPath) GetSingle(source *Point) (interface{}, bool) { 194 switch fp.selector { 195 case Point_FieldPathSelectorInterval: 196 res := source.GetInterval() 197 return res, res != nil 198 case Point_FieldPathSelectorValue: 199 res := source.GetValue() 200 return res, res != nil 201 case Point_FieldPathSelectorAggregation: 202 res := source.GetAggregation() 203 return res, res != nil 204 default: 205 panic(fmt.Sprintf("Invalid selector for Point: %d", fp.selector)) 206 } 207 } 208 209 func (fp *Point_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) { 210 return fp.GetSingle(source.(*Point)) 211 } 212 213 // GetDefault returns a default value of the field type 214 func (fp *Point_FieldTerminalPath) GetDefault() interface{} { 215 switch fp.selector { 216 case Point_FieldPathSelectorInterval: 217 return (*common.TimeInterval)(nil) 218 case Point_FieldPathSelectorValue: 219 return (*common.TypedValue)(nil) 220 case Point_FieldPathSelectorAggregation: 221 return (*common.Aggregation)(nil) 222 default: 223 panic(fmt.Sprintf("Invalid selector for Point: %d", fp.selector)) 224 } 225 } 226 227 func (fp *Point_FieldTerminalPath) ClearValue(item *Point) { 228 if item != nil { 229 switch fp.selector { 230 case Point_FieldPathSelectorInterval: 231 item.Interval = nil 232 case Point_FieldPathSelectorValue: 233 item.Value = nil 234 case Point_FieldPathSelectorAggregation: 235 item.Aggregation = nil 236 default: 237 panic(fmt.Sprintf("Invalid selector for Point: %d", fp.selector)) 238 } 239 } 240 } 241 242 func (fp *Point_FieldTerminalPath) ClearValueRaw(item proto.Message) { 243 fp.ClearValue(item.(*Point)) 244 } 245 246 // IsLeaf - whether field path is holds simple value 247 func (fp *Point_FieldTerminalPath) IsLeaf() bool { 248 return false 249 } 250 251 func (fp *Point_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath { 252 return []gotenobject.FieldPath{fp} 253 } 254 255 func (fp *Point_FieldTerminalPath) WithIValue(value interface{}) Point_FieldPathValue { 256 switch fp.selector { 257 case Point_FieldPathSelectorInterval: 258 return &Point_FieldTerminalPathValue{Point_FieldTerminalPath: *fp, value: value.(*common.TimeInterval)} 259 case Point_FieldPathSelectorValue: 260 return &Point_FieldTerminalPathValue{Point_FieldTerminalPath: *fp, value: value.(*common.TypedValue)} 261 case Point_FieldPathSelectorAggregation: 262 return &Point_FieldTerminalPathValue{Point_FieldTerminalPath: *fp, value: value.(*common.Aggregation)} 263 default: 264 panic(fmt.Sprintf("Invalid selector for Point: %d", fp.selector)) 265 } 266 } 267 268 func (fp *Point_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue { 269 return fp.WithIValue(value) 270 } 271 272 func (fp *Point_FieldTerminalPath) WithIArrayOfValues(values interface{}) Point_FieldPathArrayOfValues { 273 fpaov := &Point_FieldTerminalPathArrayOfValues{Point_FieldTerminalPath: *fp} 274 switch fp.selector { 275 case Point_FieldPathSelectorInterval: 276 return &Point_FieldTerminalPathArrayOfValues{Point_FieldTerminalPath: *fp, values: values.([]*common.TimeInterval)} 277 case Point_FieldPathSelectorValue: 278 return &Point_FieldTerminalPathArrayOfValues{Point_FieldTerminalPath: *fp, values: values.([]*common.TypedValue)} 279 case Point_FieldPathSelectorAggregation: 280 return &Point_FieldTerminalPathArrayOfValues{Point_FieldTerminalPath: *fp, values: values.([]*common.Aggregation)} 281 default: 282 panic(fmt.Sprintf("Invalid selector for Point: %d", fp.selector)) 283 } 284 return fpaov 285 } 286 287 func (fp *Point_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues { 288 return fp.WithIArrayOfValues(values) 289 } 290 291 func (fp *Point_FieldTerminalPath) WithIArrayItemValue(value interface{}) Point_FieldPathArrayItemValue { 292 switch fp.selector { 293 default: 294 panic(fmt.Sprintf("Invalid selector for Point: %d", fp.selector)) 295 } 296 } 297 298 func (fp *Point_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue { 299 return fp.WithIArrayItemValue(value) 300 } 301 302 type Point_FieldSubPath struct { 303 selector Point_FieldPathSelector 304 subPath gotenobject.FieldPath 305 } 306 307 var _ Point_FieldPath = (*Point_FieldSubPath)(nil) 308 309 func (fps *Point_FieldSubPath) Selector() Point_FieldPathSelector { 310 return fps.selector 311 } 312 func (fps *Point_FieldSubPath) AsIntervalSubPath() (common.TimeInterval_FieldPath, bool) { 313 res, ok := fps.subPath.(common.TimeInterval_FieldPath) 314 return res, ok 315 } 316 func (fps *Point_FieldSubPath) AsValueSubPath() (common.TypedValue_FieldPath, bool) { 317 res, ok := fps.subPath.(common.TypedValue_FieldPath) 318 return res, ok 319 } 320 func (fps *Point_FieldSubPath) AsAggregationSubPath() (common.Aggregation_FieldPath, bool) { 321 res, ok := fps.subPath.(common.Aggregation_FieldPath) 322 return res, ok 323 } 324 325 // String returns path representation in proto convention 326 func (fps *Point_FieldSubPath) String() string { 327 return fps.selector.String() + "." + fps.subPath.String() 328 } 329 330 // JSONString returns path representation is JSON convention 331 func (fps *Point_FieldSubPath) JSONString() string { 332 return strcase.ToLowerCamel(fps.selector.String()) + "." + fps.subPath.JSONString() 333 } 334 335 // Get returns all values pointed by selected field from source Point 336 func (fps *Point_FieldSubPath) Get(source *Point) (values []interface{}) { 337 switch fps.selector { 338 case Point_FieldPathSelectorInterval: 339 values = append(values, fps.subPath.GetRaw(source.GetInterval())...) 340 case Point_FieldPathSelectorValue: 341 values = append(values, fps.subPath.GetRaw(source.GetValue())...) 342 case Point_FieldPathSelectorAggregation: 343 values = append(values, fps.subPath.GetRaw(source.GetAggregation())...) 344 default: 345 panic(fmt.Sprintf("Invalid selector for Point: %d", fps.selector)) 346 } 347 return 348 } 349 350 func (fps *Point_FieldSubPath) GetRaw(source proto.Message) []interface{} { 351 return fps.Get(source.(*Point)) 352 } 353 354 // GetSingle returns value of selected field from source Point 355 func (fps *Point_FieldSubPath) GetSingle(source *Point) (interface{}, bool) { 356 switch fps.selector { 357 case Point_FieldPathSelectorInterval: 358 if source.GetInterval() == nil { 359 return nil, false 360 } 361 return fps.subPath.GetSingleRaw(source.GetInterval()) 362 case Point_FieldPathSelectorValue: 363 if source.GetValue() == nil { 364 return nil, false 365 } 366 return fps.subPath.GetSingleRaw(source.GetValue()) 367 case Point_FieldPathSelectorAggregation: 368 if source.GetAggregation() == nil { 369 return nil, false 370 } 371 return fps.subPath.GetSingleRaw(source.GetAggregation()) 372 default: 373 panic(fmt.Sprintf("Invalid selector for Point: %d", fps.selector)) 374 } 375 } 376 377 func (fps *Point_FieldSubPath) GetSingleRaw(source proto.Message) (interface{}, bool) { 378 return fps.GetSingle(source.(*Point)) 379 } 380 381 // GetDefault returns a default value of the field type 382 func (fps *Point_FieldSubPath) GetDefault() interface{} { 383 return fps.subPath.GetDefault() 384 } 385 386 func (fps *Point_FieldSubPath) ClearValue(item *Point) { 387 if item != nil { 388 switch fps.selector { 389 case Point_FieldPathSelectorInterval: 390 fps.subPath.ClearValueRaw(item.Interval) 391 case Point_FieldPathSelectorValue: 392 fps.subPath.ClearValueRaw(item.Value) 393 case Point_FieldPathSelectorAggregation: 394 fps.subPath.ClearValueRaw(item.Aggregation) 395 default: 396 panic(fmt.Sprintf("Invalid selector for Point: %d", fps.selector)) 397 } 398 } 399 } 400 401 func (fps *Point_FieldSubPath) ClearValueRaw(item proto.Message) { 402 fps.ClearValue(item.(*Point)) 403 } 404 405 // IsLeaf - whether field path is holds simple value 406 func (fps *Point_FieldSubPath) IsLeaf() bool { 407 return fps.subPath.IsLeaf() 408 } 409 410 func (fps *Point_FieldSubPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath { 411 iPaths := []gotenobject.FieldPath{&Point_FieldTerminalPath{selector: fps.selector}} 412 iPaths = append(iPaths, fps.subPath.SplitIntoTerminalIPaths()...) 413 return iPaths 414 } 415 416 func (fps *Point_FieldSubPath) WithIValue(value interface{}) Point_FieldPathValue { 417 return &Point_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)} 418 } 419 420 func (fps *Point_FieldSubPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue { 421 return fps.WithIValue(value) 422 } 423 424 func (fps *Point_FieldSubPath) WithIArrayOfValues(values interface{}) Point_FieldPathArrayOfValues { 425 return &Point_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)} 426 } 427 428 func (fps *Point_FieldSubPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues { 429 return fps.WithIArrayOfValues(values) 430 } 431 432 func (fps *Point_FieldSubPath) WithIArrayItemValue(value interface{}) Point_FieldPathArrayItemValue { 433 return &Point_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)} 434 } 435 436 func (fps *Point_FieldSubPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue { 437 return fps.WithIArrayItemValue(value) 438 } 439 440 // Point_FieldPathValue allows storing values for Point fields according to their type 441 type Point_FieldPathValue interface { 442 Point_FieldPath 443 gotenobject.FieldPathValue 444 SetTo(target **Point) 445 CompareWith(*Point) (cmp int, comparable bool) 446 } 447 448 func ParsePoint_FieldPathValue(pathStr, valueStr string) (Point_FieldPathValue, error) { 449 fp, err := ParsePoint_FieldPath(pathStr) 450 if err != nil { 451 return nil, err 452 } 453 fpv, err := gotenobject.ParseFieldPathValue(fp, valueStr) 454 if err != nil { 455 return nil, status.Errorf(codes.InvalidArgument, "error parsing Point field path value from %s: %v", valueStr, err) 456 } 457 return fpv.(Point_FieldPathValue), nil 458 } 459 460 func MustParsePoint_FieldPathValue(pathStr, valueStr string) Point_FieldPathValue { 461 fpv, err := ParsePoint_FieldPathValue(pathStr, valueStr) 462 if err != nil { 463 panic(err) 464 } 465 return fpv 466 } 467 468 type Point_FieldTerminalPathValue struct { 469 Point_FieldTerminalPath 470 value interface{} 471 } 472 473 var _ Point_FieldPathValue = (*Point_FieldTerminalPathValue)(nil) 474 475 // GetRawValue returns raw value stored under selected path for 'Point' as interface{} 476 func (fpv *Point_FieldTerminalPathValue) GetRawValue() interface{} { 477 return fpv.value 478 } 479 func (fpv *Point_FieldTerminalPathValue) AsIntervalValue() (*common.TimeInterval, bool) { 480 res, ok := fpv.value.(*common.TimeInterval) 481 return res, ok 482 } 483 func (fpv *Point_FieldTerminalPathValue) AsValueValue() (*common.TypedValue, bool) { 484 res, ok := fpv.value.(*common.TypedValue) 485 return res, ok 486 } 487 func (fpv *Point_FieldTerminalPathValue) AsAggregationValue() (*common.Aggregation, bool) { 488 res, ok := fpv.value.(*common.Aggregation) 489 return res, ok 490 } 491 492 // SetTo stores value for selected field for object Point 493 func (fpv *Point_FieldTerminalPathValue) SetTo(target **Point) { 494 if *target == nil { 495 *target = new(Point) 496 } 497 switch fpv.selector { 498 case Point_FieldPathSelectorInterval: 499 (*target).Interval = fpv.value.(*common.TimeInterval) 500 case Point_FieldPathSelectorValue: 501 (*target).Value = fpv.value.(*common.TypedValue) 502 case Point_FieldPathSelectorAggregation: 503 (*target).Aggregation = fpv.value.(*common.Aggregation) 504 default: 505 panic(fmt.Sprintf("Invalid selector for Point: %d", fpv.selector)) 506 } 507 } 508 509 func (fpv *Point_FieldTerminalPathValue) SetToRaw(target proto.Message) { 510 typedObject := target.(*Point) 511 fpv.SetTo(&typedObject) 512 } 513 514 // CompareWith compares value in the 'Point_FieldTerminalPathValue' with the value under path in 'Point'. 515 func (fpv *Point_FieldTerminalPathValue) CompareWith(source *Point) (int, bool) { 516 switch fpv.selector { 517 case Point_FieldPathSelectorInterval: 518 return 0, false 519 case Point_FieldPathSelectorValue: 520 return 0, false 521 case Point_FieldPathSelectorAggregation: 522 return 0, false 523 default: 524 panic(fmt.Sprintf("Invalid selector for Point: %d", fpv.selector)) 525 } 526 } 527 528 func (fpv *Point_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) { 529 return fpv.CompareWith(source.(*Point)) 530 } 531 532 type Point_FieldSubPathValue struct { 533 Point_FieldPath 534 subPathValue gotenobject.FieldPathValue 535 } 536 537 var _ Point_FieldPathValue = (*Point_FieldSubPathValue)(nil) 538 539 func (fpvs *Point_FieldSubPathValue) AsIntervalPathValue() (common.TimeInterval_FieldPathValue, bool) { 540 res, ok := fpvs.subPathValue.(common.TimeInterval_FieldPathValue) 541 return res, ok 542 } 543 func (fpvs *Point_FieldSubPathValue) AsValuePathValue() (common.TypedValue_FieldPathValue, bool) { 544 res, ok := fpvs.subPathValue.(common.TypedValue_FieldPathValue) 545 return res, ok 546 } 547 func (fpvs *Point_FieldSubPathValue) AsAggregationPathValue() (common.Aggregation_FieldPathValue, bool) { 548 res, ok := fpvs.subPathValue.(common.Aggregation_FieldPathValue) 549 return res, ok 550 } 551 552 func (fpvs *Point_FieldSubPathValue) SetTo(target **Point) { 553 if *target == nil { 554 *target = new(Point) 555 } 556 switch fpvs.Selector() { 557 case Point_FieldPathSelectorInterval: 558 fpvs.subPathValue.(common.TimeInterval_FieldPathValue).SetTo(&(*target).Interval) 559 case Point_FieldPathSelectorValue: 560 fpvs.subPathValue.(common.TypedValue_FieldPathValue).SetTo(&(*target).Value) 561 case Point_FieldPathSelectorAggregation: 562 fpvs.subPathValue.(common.Aggregation_FieldPathValue).SetTo(&(*target).Aggregation) 563 default: 564 panic(fmt.Sprintf("Invalid selector for Point: %d", fpvs.Selector())) 565 } 566 } 567 568 func (fpvs *Point_FieldSubPathValue) SetToRaw(target proto.Message) { 569 typedObject := target.(*Point) 570 fpvs.SetTo(&typedObject) 571 } 572 573 func (fpvs *Point_FieldSubPathValue) GetRawValue() interface{} { 574 return fpvs.subPathValue.GetRawValue() 575 } 576 577 func (fpvs *Point_FieldSubPathValue) CompareWith(source *Point) (int, bool) { 578 switch fpvs.Selector() { 579 case Point_FieldPathSelectorInterval: 580 return fpvs.subPathValue.(common.TimeInterval_FieldPathValue).CompareWith(source.GetInterval()) 581 case Point_FieldPathSelectorValue: 582 return fpvs.subPathValue.(common.TypedValue_FieldPathValue).CompareWith(source.GetValue()) 583 case Point_FieldPathSelectorAggregation: 584 return fpvs.subPathValue.(common.Aggregation_FieldPathValue).CompareWith(source.GetAggregation()) 585 default: 586 panic(fmt.Sprintf("Invalid selector for Point: %d", fpvs.Selector())) 587 } 588 } 589 590 func (fpvs *Point_FieldSubPathValue) CompareWithRaw(source proto.Message) (int, bool) { 591 return fpvs.CompareWith(source.(*Point)) 592 } 593 594 // Point_FieldPathArrayItemValue allows storing single item in Path-specific values for Point according to their type 595 // Present only for array (repeated) types. 596 type Point_FieldPathArrayItemValue interface { 597 gotenobject.FieldPathArrayItemValue 598 Point_FieldPath 599 ContainsValue(*Point) bool 600 } 601 602 // ParsePoint_FieldPathArrayItemValue parses string and JSON-encoded value to its Value 603 func ParsePoint_FieldPathArrayItemValue(pathStr, valueStr string) (Point_FieldPathArrayItemValue, error) { 604 fp, err := ParsePoint_FieldPath(pathStr) 605 if err != nil { 606 return nil, err 607 } 608 fpaiv, err := gotenobject.ParseFieldPathArrayItemValue(fp, valueStr) 609 if err != nil { 610 return nil, status.Errorf(codes.InvalidArgument, "error parsing Point field path array item value from %s: %v", valueStr, err) 611 } 612 return fpaiv.(Point_FieldPathArrayItemValue), nil 613 } 614 615 func MustParsePoint_FieldPathArrayItemValue(pathStr, valueStr string) Point_FieldPathArrayItemValue { 616 fpaiv, err := ParsePoint_FieldPathArrayItemValue(pathStr, valueStr) 617 if err != nil { 618 panic(err) 619 } 620 return fpaiv 621 } 622 623 type Point_FieldTerminalPathArrayItemValue struct { 624 Point_FieldTerminalPath 625 value interface{} 626 } 627 628 var _ Point_FieldPathArrayItemValue = (*Point_FieldTerminalPathArrayItemValue)(nil) 629 630 // GetRawValue returns stored element value for array in object Point as interface{} 631 func (fpaiv *Point_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} { 632 return fpaiv.value 633 } 634 635 func (fpaiv *Point_FieldTerminalPathArrayItemValue) GetSingle(source *Point) (interface{}, bool) { 636 return nil, false 637 } 638 639 func (fpaiv *Point_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) { 640 return fpaiv.GetSingle(source.(*Point)) 641 } 642 643 // Contains returns a boolean indicating if value that is being held is present in given 'Point' 644 func (fpaiv *Point_FieldTerminalPathArrayItemValue) ContainsValue(source *Point) bool { 645 slice := fpaiv.Point_FieldTerminalPath.Get(source) 646 for _, v := range slice { 647 if asProtoMsg, ok := fpaiv.value.(proto.Message); ok { 648 if proto.Equal(asProtoMsg, v.(proto.Message)) { 649 return true 650 } 651 } else if reflect.DeepEqual(v, fpaiv.value) { 652 return true 653 } 654 } 655 return false 656 } 657 658 type Point_FieldSubPathArrayItemValue struct { 659 Point_FieldPath 660 subPathItemValue gotenobject.FieldPathArrayItemValue 661 } 662 663 // GetRawValue returns stored array item value 664 func (fpaivs *Point_FieldSubPathArrayItemValue) GetRawItemValue() interface{} { 665 return fpaivs.subPathItemValue.GetRawItemValue() 666 } 667 func (fpaivs *Point_FieldSubPathArrayItemValue) AsIntervalPathItemValue() (common.TimeInterval_FieldPathArrayItemValue, bool) { 668 res, ok := fpaivs.subPathItemValue.(common.TimeInterval_FieldPathArrayItemValue) 669 return res, ok 670 } 671 func (fpaivs *Point_FieldSubPathArrayItemValue) AsValuePathItemValue() (common.TypedValue_FieldPathArrayItemValue, bool) { 672 res, ok := fpaivs.subPathItemValue.(common.TypedValue_FieldPathArrayItemValue) 673 return res, ok 674 } 675 func (fpaivs *Point_FieldSubPathArrayItemValue) AsAggregationPathItemValue() (common.Aggregation_FieldPathArrayItemValue, bool) { 676 res, ok := fpaivs.subPathItemValue.(common.Aggregation_FieldPathArrayItemValue) 677 return res, ok 678 } 679 680 // Contains returns a boolean indicating if value that is being held is present in given 'Point' 681 func (fpaivs *Point_FieldSubPathArrayItemValue) ContainsValue(source *Point) bool { 682 switch fpaivs.Selector() { 683 case Point_FieldPathSelectorInterval: 684 return fpaivs.subPathItemValue.(common.TimeInterval_FieldPathArrayItemValue).ContainsValue(source.GetInterval()) 685 case Point_FieldPathSelectorValue: 686 return fpaivs.subPathItemValue.(common.TypedValue_FieldPathArrayItemValue).ContainsValue(source.GetValue()) 687 case Point_FieldPathSelectorAggregation: 688 return fpaivs.subPathItemValue.(common.Aggregation_FieldPathArrayItemValue).ContainsValue(source.GetAggregation()) 689 default: 690 panic(fmt.Sprintf("Invalid selector for Point: %d", fpaivs.Selector())) 691 } 692 } 693 694 // Point_FieldPathArrayOfValues allows storing slice of values for Point fields according to their type 695 type Point_FieldPathArrayOfValues interface { 696 gotenobject.FieldPathArrayOfValues 697 Point_FieldPath 698 } 699 700 func ParsePoint_FieldPathArrayOfValues(pathStr, valuesStr string) (Point_FieldPathArrayOfValues, error) { 701 fp, err := ParsePoint_FieldPath(pathStr) 702 if err != nil { 703 return nil, err 704 } 705 fpaov, err := gotenobject.ParseFieldPathArrayOfValues(fp, valuesStr) 706 if err != nil { 707 return nil, status.Errorf(codes.InvalidArgument, "error parsing Point field path array of values from %s: %v", valuesStr, err) 708 } 709 return fpaov.(Point_FieldPathArrayOfValues), nil 710 } 711 712 func MustParsePoint_FieldPathArrayOfValues(pathStr, valuesStr string) Point_FieldPathArrayOfValues { 713 fpaov, err := ParsePoint_FieldPathArrayOfValues(pathStr, valuesStr) 714 if err != nil { 715 panic(err) 716 } 717 return fpaov 718 } 719 720 type Point_FieldTerminalPathArrayOfValues struct { 721 Point_FieldTerminalPath 722 values interface{} 723 } 724 725 var _ Point_FieldPathArrayOfValues = (*Point_FieldTerminalPathArrayOfValues)(nil) 726 727 func (fpaov *Point_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) { 728 switch fpaov.selector { 729 case Point_FieldPathSelectorInterval: 730 for _, v := range fpaov.values.([]*common.TimeInterval) { 731 values = append(values, v) 732 } 733 case Point_FieldPathSelectorValue: 734 for _, v := range fpaov.values.([]*common.TypedValue) { 735 values = append(values, v) 736 } 737 case Point_FieldPathSelectorAggregation: 738 for _, v := range fpaov.values.([]*common.Aggregation) { 739 values = append(values, v) 740 } 741 } 742 return 743 } 744 func (fpaov *Point_FieldTerminalPathArrayOfValues) AsIntervalArrayOfValues() ([]*common.TimeInterval, bool) { 745 res, ok := fpaov.values.([]*common.TimeInterval) 746 return res, ok 747 } 748 func (fpaov *Point_FieldTerminalPathArrayOfValues) AsValueArrayOfValues() ([]*common.TypedValue, bool) { 749 res, ok := fpaov.values.([]*common.TypedValue) 750 return res, ok 751 } 752 func (fpaov *Point_FieldTerminalPathArrayOfValues) AsAggregationArrayOfValues() ([]*common.Aggregation, bool) { 753 res, ok := fpaov.values.([]*common.Aggregation) 754 return res, ok 755 } 756 757 type Point_FieldSubPathArrayOfValues struct { 758 Point_FieldPath 759 subPathArrayOfValues gotenobject.FieldPathArrayOfValues 760 } 761 762 var _ Point_FieldPathArrayOfValues = (*Point_FieldSubPathArrayOfValues)(nil) 763 764 func (fpsaov *Point_FieldSubPathArrayOfValues) GetRawValues() []interface{} { 765 return fpsaov.subPathArrayOfValues.GetRawValues() 766 } 767 func (fpsaov *Point_FieldSubPathArrayOfValues) AsIntervalPathArrayOfValues() (common.TimeInterval_FieldPathArrayOfValues, bool) { 768 res, ok := fpsaov.subPathArrayOfValues.(common.TimeInterval_FieldPathArrayOfValues) 769 return res, ok 770 } 771 func (fpsaov *Point_FieldSubPathArrayOfValues) AsValuePathArrayOfValues() (common.TypedValue_FieldPathArrayOfValues, bool) { 772 res, ok := fpsaov.subPathArrayOfValues.(common.TypedValue_FieldPathArrayOfValues) 773 return res, ok 774 } 775 func (fpsaov *Point_FieldSubPathArrayOfValues) AsAggregationPathArrayOfValues() (common.Aggregation_FieldPathArrayOfValues, bool) { 776 res, ok := fpsaov.subPathArrayOfValues.(common.Aggregation_FieldPathArrayOfValues) 777 return res, ok 778 } 779 780 // FieldPath provides implementation to handle 781 // https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto 782 type TimeSerie_FieldPath interface { 783 gotenobject.FieldPath 784 Selector() TimeSerie_FieldPathSelector 785 Get(source *TimeSerie) []interface{} 786 GetSingle(source *TimeSerie) (interface{}, bool) 787 ClearValue(item *TimeSerie) 788 789 // Those methods build corresponding TimeSerie_FieldPathValue 790 // (or array of values) and holds passed value. Panics if injected type is incorrect. 791 WithIValue(value interface{}) TimeSerie_FieldPathValue 792 WithIArrayOfValues(values interface{}) TimeSerie_FieldPathArrayOfValues 793 WithIArrayItemValue(value interface{}) TimeSerie_FieldPathArrayItemValue 794 } 795 796 type TimeSerie_FieldPathSelector int32 797 798 const ( 799 TimeSerie_FieldPathSelectorKey TimeSerie_FieldPathSelector = 0 800 TimeSerie_FieldPathSelectorProject TimeSerie_FieldPathSelector = 1 801 TimeSerie_FieldPathSelectorRegion TimeSerie_FieldPathSelector = 2 802 TimeSerie_FieldPathSelectorMetric TimeSerie_FieldPathSelector = 3 803 TimeSerie_FieldPathSelectorResource TimeSerie_FieldPathSelector = 4 804 TimeSerie_FieldPathSelectorMetricKind TimeSerie_FieldPathSelector = 5 805 TimeSerie_FieldPathSelectorValueType TimeSerie_FieldPathSelector = 6 806 TimeSerie_FieldPathSelectorPoints TimeSerie_FieldPathSelector = 7 807 ) 808 809 func (s TimeSerie_FieldPathSelector) String() string { 810 switch s { 811 case TimeSerie_FieldPathSelectorKey: 812 return "key" 813 case TimeSerie_FieldPathSelectorProject: 814 return "project" 815 case TimeSerie_FieldPathSelectorRegion: 816 return "region" 817 case TimeSerie_FieldPathSelectorMetric: 818 return "metric" 819 case TimeSerie_FieldPathSelectorResource: 820 return "resource" 821 case TimeSerie_FieldPathSelectorMetricKind: 822 return "metric_kind" 823 case TimeSerie_FieldPathSelectorValueType: 824 return "value_type" 825 case TimeSerie_FieldPathSelectorPoints: 826 return "points" 827 default: 828 panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", s)) 829 } 830 } 831 832 func BuildTimeSerie_FieldPath(fp gotenobject.RawFieldPath) (TimeSerie_FieldPath, error) { 833 if len(fp) == 0 { 834 return nil, status.Error(codes.InvalidArgument, "empty field path for object TimeSerie") 835 } 836 if len(fp) == 1 { 837 switch fp[0] { 838 case "key": 839 return &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorKey}, nil 840 case "project": 841 return &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorProject}, nil 842 case "region": 843 return &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorRegion}, nil 844 case "metric": 845 return &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorMetric}, nil 846 case "resource": 847 return &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorResource}, nil 848 case "metric_kind", "metricKind", "metric-kind": 849 return &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorMetricKind}, nil 850 case "value_type", "valueType", "value-type": 851 return &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorValueType}, nil 852 case "points": 853 return &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorPoints}, nil 854 } 855 } else { 856 switch fp[0] { 857 case "metric": 858 if subpath, err := common.BuildMetric_FieldPath(fp[1:]); err != nil { 859 return nil, err 860 } else { 861 return &TimeSerie_FieldSubPath{selector: TimeSerie_FieldPathSelectorMetric, subPath: subpath}, nil 862 } 863 case "resource": 864 if subpath, err := common.BuildMonitoredResource_FieldPath(fp[1:]); err != nil { 865 return nil, err 866 } else { 867 return &TimeSerie_FieldSubPath{selector: TimeSerie_FieldPathSelectorResource, subPath: subpath}, nil 868 } 869 case "points": 870 if subpath, err := BuildPoint_FieldPath(fp[1:]); err != nil { 871 return nil, err 872 } else { 873 return &TimeSerie_FieldSubPath{selector: TimeSerie_FieldPathSelectorPoints, subPath: subpath}, nil 874 } 875 } 876 } 877 return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object TimeSerie", fp) 878 } 879 880 func ParseTimeSerie_FieldPath(rawField string) (TimeSerie_FieldPath, error) { 881 fp, err := gotenobject.ParseRawFieldPath(rawField) 882 if err != nil { 883 return nil, err 884 } 885 return BuildTimeSerie_FieldPath(fp) 886 } 887 888 func MustParseTimeSerie_FieldPath(rawField string) TimeSerie_FieldPath { 889 fp, err := ParseTimeSerie_FieldPath(rawField) 890 if err != nil { 891 panic(err) 892 } 893 return fp 894 } 895 896 type TimeSerie_FieldTerminalPath struct { 897 selector TimeSerie_FieldPathSelector 898 } 899 900 var _ TimeSerie_FieldPath = (*TimeSerie_FieldTerminalPath)(nil) 901 902 func (fp *TimeSerie_FieldTerminalPath) Selector() TimeSerie_FieldPathSelector { 903 return fp.selector 904 } 905 906 // String returns path representation in proto convention 907 func (fp *TimeSerie_FieldTerminalPath) String() string { 908 return fp.selector.String() 909 } 910 911 // JSONString returns path representation is JSON convention 912 func (fp *TimeSerie_FieldTerminalPath) JSONString() string { 913 return strcase.ToLowerCamel(fp.String()) 914 } 915 916 // Get returns all values pointed by specific field from source TimeSerie 917 func (fp *TimeSerie_FieldTerminalPath) Get(source *TimeSerie) (values []interface{}) { 918 if source != nil { 919 switch fp.selector { 920 case TimeSerie_FieldPathSelectorKey: 921 values = append(values, source.Key) 922 case TimeSerie_FieldPathSelectorProject: 923 values = append(values, source.Project) 924 case TimeSerie_FieldPathSelectorRegion: 925 values = append(values, source.Region) 926 case TimeSerie_FieldPathSelectorMetric: 927 if source.Metric != nil { 928 values = append(values, source.Metric) 929 } 930 case TimeSerie_FieldPathSelectorResource: 931 if source.Resource != nil { 932 values = append(values, source.Resource) 933 } 934 case TimeSerie_FieldPathSelectorMetricKind: 935 values = append(values, source.MetricKind) 936 case TimeSerie_FieldPathSelectorValueType: 937 values = append(values, source.ValueType) 938 case TimeSerie_FieldPathSelectorPoints: 939 for _, value := range source.GetPoints() { 940 values = append(values, value) 941 } 942 default: 943 panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fp.selector)) 944 } 945 } 946 return 947 } 948 949 func (fp *TimeSerie_FieldTerminalPath) GetRaw(source proto.Message) []interface{} { 950 return fp.Get(source.(*TimeSerie)) 951 } 952 953 // GetSingle returns value pointed by specific field of from source TimeSerie 954 func (fp *TimeSerie_FieldTerminalPath) GetSingle(source *TimeSerie) (interface{}, bool) { 955 switch fp.selector { 956 case TimeSerie_FieldPathSelectorKey: 957 res := source.GetKey() 958 return res, res != nil 959 case TimeSerie_FieldPathSelectorProject: 960 return source.GetProject(), source != nil 961 case TimeSerie_FieldPathSelectorRegion: 962 return source.GetRegion(), source != nil 963 case TimeSerie_FieldPathSelectorMetric: 964 res := source.GetMetric() 965 return res, res != nil 966 case TimeSerie_FieldPathSelectorResource: 967 res := source.GetResource() 968 return res, res != nil 969 case TimeSerie_FieldPathSelectorMetricKind: 970 return source.GetMetricKind(), source != nil 971 case TimeSerie_FieldPathSelectorValueType: 972 return source.GetValueType(), source != nil 973 case TimeSerie_FieldPathSelectorPoints: 974 res := source.GetPoints() 975 return res, res != nil 976 default: 977 panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fp.selector)) 978 } 979 } 980 981 func (fp *TimeSerie_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) { 982 return fp.GetSingle(source.(*TimeSerie)) 983 } 984 985 // GetDefault returns a default value of the field type 986 func (fp *TimeSerie_FieldTerminalPath) GetDefault() interface{} { 987 switch fp.selector { 988 case TimeSerie_FieldPathSelectorKey: 989 return ([]byte)(nil) 990 case TimeSerie_FieldPathSelectorProject: 991 return "" 992 case TimeSerie_FieldPathSelectorRegion: 993 return "" 994 case TimeSerie_FieldPathSelectorMetric: 995 return (*common.Metric)(nil) 996 case TimeSerie_FieldPathSelectorResource: 997 return (*common.MonitoredResource)(nil) 998 case TimeSerie_FieldPathSelectorMetricKind: 999 return metric_descriptor.MetricDescriptor_METRIC_KIND_UNSPECIFIED 1000 case TimeSerie_FieldPathSelectorValueType: 1001 return metric_descriptor.MetricDescriptor_VALUE_TYPE_UNSPECIFIED 1002 case TimeSerie_FieldPathSelectorPoints: 1003 return ([]*Point)(nil) 1004 default: 1005 panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fp.selector)) 1006 } 1007 } 1008 1009 func (fp *TimeSerie_FieldTerminalPath) ClearValue(item *TimeSerie) { 1010 if item != nil { 1011 switch fp.selector { 1012 case TimeSerie_FieldPathSelectorKey: 1013 item.Key = nil 1014 case TimeSerie_FieldPathSelectorProject: 1015 item.Project = "" 1016 case TimeSerie_FieldPathSelectorRegion: 1017 item.Region = "" 1018 case TimeSerie_FieldPathSelectorMetric: 1019 item.Metric = nil 1020 case TimeSerie_FieldPathSelectorResource: 1021 item.Resource = nil 1022 case TimeSerie_FieldPathSelectorMetricKind: 1023 item.MetricKind = metric_descriptor.MetricDescriptor_METRIC_KIND_UNSPECIFIED 1024 case TimeSerie_FieldPathSelectorValueType: 1025 item.ValueType = metric_descriptor.MetricDescriptor_VALUE_TYPE_UNSPECIFIED 1026 case TimeSerie_FieldPathSelectorPoints: 1027 item.Points = nil 1028 default: 1029 panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fp.selector)) 1030 } 1031 } 1032 } 1033 1034 func (fp *TimeSerie_FieldTerminalPath) ClearValueRaw(item proto.Message) { 1035 fp.ClearValue(item.(*TimeSerie)) 1036 } 1037 1038 // IsLeaf - whether field path is holds simple value 1039 func (fp *TimeSerie_FieldTerminalPath) IsLeaf() bool { 1040 return fp.selector == TimeSerie_FieldPathSelectorKey || 1041 fp.selector == TimeSerie_FieldPathSelectorProject || 1042 fp.selector == TimeSerie_FieldPathSelectorRegion || 1043 fp.selector == TimeSerie_FieldPathSelectorMetricKind || 1044 fp.selector == TimeSerie_FieldPathSelectorValueType 1045 } 1046 1047 func (fp *TimeSerie_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath { 1048 return []gotenobject.FieldPath{fp} 1049 } 1050 1051 func (fp *TimeSerie_FieldTerminalPath) WithIValue(value interface{}) TimeSerie_FieldPathValue { 1052 switch fp.selector { 1053 case TimeSerie_FieldPathSelectorKey: 1054 return &TimeSerie_FieldTerminalPathValue{TimeSerie_FieldTerminalPath: *fp, value: value.([]byte)} 1055 case TimeSerie_FieldPathSelectorProject: 1056 return &TimeSerie_FieldTerminalPathValue{TimeSerie_FieldTerminalPath: *fp, value: value.(string)} 1057 case TimeSerie_FieldPathSelectorRegion: 1058 return &TimeSerie_FieldTerminalPathValue{TimeSerie_FieldTerminalPath: *fp, value: value.(string)} 1059 case TimeSerie_FieldPathSelectorMetric: 1060 return &TimeSerie_FieldTerminalPathValue{TimeSerie_FieldTerminalPath: *fp, value: value.(*common.Metric)} 1061 case TimeSerie_FieldPathSelectorResource: 1062 return &TimeSerie_FieldTerminalPathValue{TimeSerie_FieldTerminalPath: *fp, value: value.(*common.MonitoredResource)} 1063 case TimeSerie_FieldPathSelectorMetricKind: 1064 return &TimeSerie_FieldTerminalPathValue{TimeSerie_FieldTerminalPath: *fp, value: value.(metric_descriptor.MetricDescriptor_MetricKind)} 1065 case TimeSerie_FieldPathSelectorValueType: 1066 return &TimeSerie_FieldTerminalPathValue{TimeSerie_FieldTerminalPath: *fp, value: value.(metric_descriptor.MetricDescriptor_ValueType)} 1067 case TimeSerie_FieldPathSelectorPoints: 1068 return &TimeSerie_FieldTerminalPathValue{TimeSerie_FieldTerminalPath: *fp, value: value.([]*Point)} 1069 default: 1070 panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fp.selector)) 1071 } 1072 } 1073 1074 func (fp *TimeSerie_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue { 1075 return fp.WithIValue(value) 1076 } 1077 1078 func (fp *TimeSerie_FieldTerminalPath) WithIArrayOfValues(values interface{}) TimeSerie_FieldPathArrayOfValues { 1079 fpaov := &TimeSerie_FieldTerminalPathArrayOfValues{TimeSerie_FieldTerminalPath: *fp} 1080 switch fp.selector { 1081 case TimeSerie_FieldPathSelectorKey: 1082 return &TimeSerie_FieldTerminalPathArrayOfValues{TimeSerie_FieldTerminalPath: *fp, values: values.([][]byte)} 1083 case TimeSerie_FieldPathSelectorProject: 1084 return &TimeSerie_FieldTerminalPathArrayOfValues{TimeSerie_FieldTerminalPath: *fp, values: values.([]string)} 1085 case TimeSerie_FieldPathSelectorRegion: 1086 return &TimeSerie_FieldTerminalPathArrayOfValues{TimeSerie_FieldTerminalPath: *fp, values: values.([]string)} 1087 case TimeSerie_FieldPathSelectorMetric: 1088 return &TimeSerie_FieldTerminalPathArrayOfValues{TimeSerie_FieldTerminalPath: *fp, values: values.([]*common.Metric)} 1089 case TimeSerie_FieldPathSelectorResource: 1090 return &TimeSerie_FieldTerminalPathArrayOfValues{TimeSerie_FieldTerminalPath: *fp, values: values.([]*common.MonitoredResource)} 1091 case TimeSerie_FieldPathSelectorMetricKind: 1092 return &TimeSerie_FieldTerminalPathArrayOfValues{TimeSerie_FieldTerminalPath: *fp, values: values.([]metric_descriptor.MetricDescriptor_MetricKind)} 1093 case TimeSerie_FieldPathSelectorValueType: 1094 return &TimeSerie_FieldTerminalPathArrayOfValues{TimeSerie_FieldTerminalPath: *fp, values: values.([]metric_descriptor.MetricDescriptor_ValueType)} 1095 case TimeSerie_FieldPathSelectorPoints: 1096 return &TimeSerie_FieldTerminalPathArrayOfValues{TimeSerie_FieldTerminalPath: *fp, values: values.([][]*Point)} 1097 default: 1098 panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fp.selector)) 1099 } 1100 return fpaov 1101 } 1102 1103 func (fp *TimeSerie_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues { 1104 return fp.WithIArrayOfValues(values) 1105 } 1106 1107 func (fp *TimeSerie_FieldTerminalPath) WithIArrayItemValue(value interface{}) TimeSerie_FieldPathArrayItemValue { 1108 switch fp.selector { 1109 case TimeSerie_FieldPathSelectorPoints: 1110 return &TimeSerie_FieldTerminalPathArrayItemValue{TimeSerie_FieldTerminalPath: *fp, value: value.(*Point)} 1111 default: 1112 panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fp.selector)) 1113 } 1114 } 1115 1116 func (fp *TimeSerie_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue { 1117 return fp.WithIArrayItemValue(value) 1118 } 1119 1120 type TimeSerie_FieldSubPath struct { 1121 selector TimeSerie_FieldPathSelector 1122 subPath gotenobject.FieldPath 1123 } 1124 1125 var _ TimeSerie_FieldPath = (*TimeSerie_FieldSubPath)(nil) 1126 1127 func (fps *TimeSerie_FieldSubPath) Selector() TimeSerie_FieldPathSelector { 1128 return fps.selector 1129 } 1130 func (fps *TimeSerie_FieldSubPath) AsMetricSubPath() (common.Metric_FieldPath, bool) { 1131 res, ok := fps.subPath.(common.Metric_FieldPath) 1132 return res, ok 1133 } 1134 func (fps *TimeSerie_FieldSubPath) AsResourceSubPath() (common.MonitoredResource_FieldPath, bool) { 1135 res, ok := fps.subPath.(common.MonitoredResource_FieldPath) 1136 return res, ok 1137 } 1138 func (fps *TimeSerie_FieldSubPath) AsPointsSubPath() (Point_FieldPath, bool) { 1139 res, ok := fps.subPath.(Point_FieldPath) 1140 return res, ok 1141 } 1142 1143 // String returns path representation in proto convention 1144 func (fps *TimeSerie_FieldSubPath) String() string { 1145 return fps.selector.String() + "." + fps.subPath.String() 1146 } 1147 1148 // JSONString returns path representation is JSON convention 1149 func (fps *TimeSerie_FieldSubPath) JSONString() string { 1150 return strcase.ToLowerCamel(fps.selector.String()) + "." + fps.subPath.JSONString() 1151 } 1152 1153 // Get returns all values pointed by selected field from source TimeSerie 1154 func (fps *TimeSerie_FieldSubPath) Get(source *TimeSerie) (values []interface{}) { 1155 switch fps.selector { 1156 case TimeSerie_FieldPathSelectorMetric: 1157 values = append(values, fps.subPath.GetRaw(source.GetMetric())...) 1158 case TimeSerie_FieldPathSelectorResource: 1159 values = append(values, fps.subPath.GetRaw(source.GetResource())...) 1160 case TimeSerie_FieldPathSelectorPoints: 1161 for _, item := range source.GetPoints() { 1162 values = append(values, fps.subPath.GetRaw(item)...) 1163 } 1164 default: 1165 panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fps.selector)) 1166 } 1167 return 1168 } 1169 1170 func (fps *TimeSerie_FieldSubPath) GetRaw(source proto.Message) []interface{} { 1171 return fps.Get(source.(*TimeSerie)) 1172 } 1173 1174 // GetSingle returns value of selected field from source TimeSerie 1175 func (fps *TimeSerie_FieldSubPath) GetSingle(source *TimeSerie) (interface{}, bool) { 1176 switch fps.selector { 1177 case TimeSerie_FieldPathSelectorMetric: 1178 if source.GetMetric() == nil { 1179 return nil, false 1180 } 1181 return fps.subPath.GetSingleRaw(source.GetMetric()) 1182 case TimeSerie_FieldPathSelectorResource: 1183 if source.GetResource() == nil { 1184 return nil, false 1185 } 1186 return fps.subPath.GetSingleRaw(source.GetResource()) 1187 case TimeSerie_FieldPathSelectorPoints: 1188 if len(source.GetPoints()) == 0 { 1189 return nil, false 1190 } 1191 return fps.subPath.GetSingleRaw(source.GetPoints()[0]) 1192 default: 1193 panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fps.selector)) 1194 } 1195 } 1196 1197 func (fps *TimeSerie_FieldSubPath) GetSingleRaw(source proto.Message) (interface{}, bool) { 1198 return fps.GetSingle(source.(*TimeSerie)) 1199 } 1200 1201 // GetDefault returns a default value of the field type 1202 func (fps *TimeSerie_FieldSubPath) GetDefault() interface{} { 1203 return fps.subPath.GetDefault() 1204 } 1205 1206 func (fps *TimeSerie_FieldSubPath) ClearValue(item *TimeSerie) { 1207 if item != nil { 1208 switch fps.selector { 1209 case TimeSerie_FieldPathSelectorMetric: 1210 fps.subPath.ClearValueRaw(item.Metric) 1211 case TimeSerie_FieldPathSelectorResource: 1212 fps.subPath.ClearValueRaw(item.Resource) 1213 case TimeSerie_FieldPathSelectorPoints: 1214 for _, subItem := range item.Points { 1215 fps.subPath.ClearValueRaw(subItem) 1216 } 1217 default: 1218 panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fps.selector)) 1219 } 1220 } 1221 } 1222 1223 func (fps *TimeSerie_FieldSubPath) ClearValueRaw(item proto.Message) { 1224 fps.ClearValue(item.(*TimeSerie)) 1225 } 1226 1227 // IsLeaf - whether field path is holds simple value 1228 func (fps *TimeSerie_FieldSubPath) IsLeaf() bool { 1229 return fps.subPath.IsLeaf() 1230 } 1231 1232 func (fps *TimeSerie_FieldSubPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath { 1233 iPaths := []gotenobject.FieldPath{&TimeSerie_FieldTerminalPath{selector: fps.selector}} 1234 iPaths = append(iPaths, fps.subPath.SplitIntoTerminalIPaths()...) 1235 return iPaths 1236 } 1237 1238 func (fps *TimeSerie_FieldSubPath) WithIValue(value interface{}) TimeSerie_FieldPathValue { 1239 return &TimeSerie_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)} 1240 } 1241 1242 func (fps *TimeSerie_FieldSubPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue { 1243 return fps.WithIValue(value) 1244 } 1245 1246 func (fps *TimeSerie_FieldSubPath) WithIArrayOfValues(values interface{}) TimeSerie_FieldPathArrayOfValues { 1247 return &TimeSerie_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)} 1248 } 1249 1250 func (fps *TimeSerie_FieldSubPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues { 1251 return fps.WithIArrayOfValues(values) 1252 } 1253 1254 func (fps *TimeSerie_FieldSubPath) WithIArrayItemValue(value interface{}) TimeSerie_FieldPathArrayItemValue { 1255 return &TimeSerie_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)} 1256 } 1257 1258 func (fps *TimeSerie_FieldSubPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue { 1259 return fps.WithIArrayItemValue(value) 1260 } 1261 1262 // TimeSerie_FieldPathValue allows storing values for TimeSerie fields according to their type 1263 type TimeSerie_FieldPathValue interface { 1264 TimeSerie_FieldPath 1265 gotenobject.FieldPathValue 1266 SetTo(target **TimeSerie) 1267 CompareWith(*TimeSerie) (cmp int, comparable bool) 1268 } 1269 1270 func ParseTimeSerie_FieldPathValue(pathStr, valueStr string) (TimeSerie_FieldPathValue, error) { 1271 fp, err := ParseTimeSerie_FieldPath(pathStr) 1272 if err != nil { 1273 return nil, err 1274 } 1275 fpv, err := gotenobject.ParseFieldPathValue(fp, valueStr) 1276 if err != nil { 1277 return nil, status.Errorf(codes.InvalidArgument, "error parsing TimeSerie field path value from %s: %v", valueStr, err) 1278 } 1279 return fpv.(TimeSerie_FieldPathValue), nil 1280 } 1281 1282 func MustParseTimeSerie_FieldPathValue(pathStr, valueStr string) TimeSerie_FieldPathValue { 1283 fpv, err := ParseTimeSerie_FieldPathValue(pathStr, valueStr) 1284 if err != nil { 1285 panic(err) 1286 } 1287 return fpv 1288 } 1289 1290 type TimeSerie_FieldTerminalPathValue struct { 1291 TimeSerie_FieldTerminalPath 1292 value interface{} 1293 } 1294 1295 var _ TimeSerie_FieldPathValue = (*TimeSerie_FieldTerminalPathValue)(nil) 1296 1297 // GetRawValue returns raw value stored under selected path for 'TimeSerie' as interface{} 1298 func (fpv *TimeSerie_FieldTerminalPathValue) GetRawValue() interface{} { 1299 return fpv.value 1300 } 1301 func (fpv *TimeSerie_FieldTerminalPathValue) AsKeyValue() ([]byte, bool) { 1302 res, ok := fpv.value.([]byte) 1303 return res, ok 1304 } 1305 func (fpv *TimeSerie_FieldTerminalPathValue) AsProjectValue() (string, bool) { 1306 res, ok := fpv.value.(string) 1307 return res, ok 1308 } 1309 func (fpv *TimeSerie_FieldTerminalPathValue) AsRegionValue() (string, bool) { 1310 res, ok := fpv.value.(string) 1311 return res, ok 1312 } 1313 func (fpv *TimeSerie_FieldTerminalPathValue) AsMetricValue() (*common.Metric, bool) { 1314 res, ok := fpv.value.(*common.Metric) 1315 return res, ok 1316 } 1317 func (fpv *TimeSerie_FieldTerminalPathValue) AsResourceValue() (*common.MonitoredResource, bool) { 1318 res, ok := fpv.value.(*common.MonitoredResource) 1319 return res, ok 1320 } 1321 func (fpv *TimeSerie_FieldTerminalPathValue) AsMetricKindValue() (metric_descriptor.MetricDescriptor_MetricKind, bool) { 1322 res, ok := fpv.value.(metric_descriptor.MetricDescriptor_MetricKind) 1323 return res, ok 1324 } 1325 func (fpv *TimeSerie_FieldTerminalPathValue) AsValueTypeValue() (metric_descriptor.MetricDescriptor_ValueType, bool) { 1326 res, ok := fpv.value.(metric_descriptor.MetricDescriptor_ValueType) 1327 return res, ok 1328 } 1329 func (fpv *TimeSerie_FieldTerminalPathValue) AsPointsValue() ([]*Point, bool) { 1330 res, ok := fpv.value.([]*Point) 1331 return res, ok 1332 } 1333 1334 // SetTo stores value for selected field for object TimeSerie 1335 func (fpv *TimeSerie_FieldTerminalPathValue) SetTo(target **TimeSerie) { 1336 if *target == nil { 1337 *target = new(TimeSerie) 1338 } 1339 switch fpv.selector { 1340 case TimeSerie_FieldPathSelectorKey: 1341 (*target).Key = fpv.value.([]byte) 1342 case TimeSerie_FieldPathSelectorProject: 1343 (*target).Project = fpv.value.(string) 1344 case TimeSerie_FieldPathSelectorRegion: 1345 (*target).Region = fpv.value.(string) 1346 case TimeSerie_FieldPathSelectorMetric: 1347 (*target).Metric = fpv.value.(*common.Metric) 1348 case TimeSerie_FieldPathSelectorResource: 1349 (*target).Resource = fpv.value.(*common.MonitoredResource) 1350 case TimeSerie_FieldPathSelectorMetricKind: 1351 (*target).MetricKind = fpv.value.(metric_descriptor.MetricDescriptor_MetricKind) 1352 case TimeSerie_FieldPathSelectorValueType: 1353 (*target).ValueType = fpv.value.(metric_descriptor.MetricDescriptor_ValueType) 1354 case TimeSerie_FieldPathSelectorPoints: 1355 (*target).Points = fpv.value.([]*Point) 1356 default: 1357 panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fpv.selector)) 1358 } 1359 } 1360 1361 func (fpv *TimeSerie_FieldTerminalPathValue) SetToRaw(target proto.Message) { 1362 typedObject := target.(*TimeSerie) 1363 fpv.SetTo(&typedObject) 1364 } 1365 1366 // CompareWith compares value in the 'TimeSerie_FieldTerminalPathValue' with the value under path in 'TimeSerie'. 1367 func (fpv *TimeSerie_FieldTerminalPathValue) CompareWith(source *TimeSerie) (int, bool) { 1368 switch fpv.selector { 1369 case TimeSerie_FieldPathSelectorKey: 1370 return 0, false 1371 case TimeSerie_FieldPathSelectorProject: 1372 leftValue := fpv.value.(string) 1373 rightValue := source.GetProject() 1374 if (leftValue) == (rightValue) { 1375 return 0, true 1376 } else if (leftValue) < (rightValue) { 1377 return -1, true 1378 } else { 1379 return 1, true 1380 } 1381 case TimeSerie_FieldPathSelectorRegion: 1382 leftValue := fpv.value.(string) 1383 rightValue := source.GetRegion() 1384 if (leftValue) == (rightValue) { 1385 return 0, true 1386 } else if (leftValue) < (rightValue) { 1387 return -1, true 1388 } else { 1389 return 1, true 1390 } 1391 case TimeSerie_FieldPathSelectorMetric: 1392 return 0, false 1393 case TimeSerie_FieldPathSelectorResource: 1394 return 0, false 1395 case TimeSerie_FieldPathSelectorMetricKind: 1396 leftValue := fpv.value.(metric_descriptor.MetricDescriptor_MetricKind) 1397 rightValue := source.GetMetricKind() 1398 if (leftValue) == (rightValue) { 1399 return 0, true 1400 } else if (leftValue) < (rightValue) { 1401 return -1, true 1402 } else { 1403 return 1, true 1404 } 1405 case TimeSerie_FieldPathSelectorValueType: 1406 leftValue := fpv.value.(metric_descriptor.MetricDescriptor_ValueType) 1407 rightValue := source.GetValueType() 1408 if (leftValue) == (rightValue) { 1409 return 0, true 1410 } else if (leftValue) < (rightValue) { 1411 return -1, true 1412 } else { 1413 return 1, true 1414 } 1415 case TimeSerie_FieldPathSelectorPoints: 1416 return 0, false 1417 default: 1418 panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fpv.selector)) 1419 } 1420 } 1421 1422 func (fpv *TimeSerie_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) { 1423 return fpv.CompareWith(source.(*TimeSerie)) 1424 } 1425 1426 type TimeSerie_FieldSubPathValue struct { 1427 TimeSerie_FieldPath 1428 subPathValue gotenobject.FieldPathValue 1429 } 1430 1431 var _ TimeSerie_FieldPathValue = (*TimeSerie_FieldSubPathValue)(nil) 1432 1433 func (fpvs *TimeSerie_FieldSubPathValue) AsMetricPathValue() (common.Metric_FieldPathValue, bool) { 1434 res, ok := fpvs.subPathValue.(common.Metric_FieldPathValue) 1435 return res, ok 1436 } 1437 func (fpvs *TimeSerie_FieldSubPathValue) AsResourcePathValue() (common.MonitoredResource_FieldPathValue, bool) { 1438 res, ok := fpvs.subPathValue.(common.MonitoredResource_FieldPathValue) 1439 return res, ok 1440 } 1441 func (fpvs *TimeSerie_FieldSubPathValue) AsPointsPathValue() (Point_FieldPathValue, bool) { 1442 res, ok := fpvs.subPathValue.(Point_FieldPathValue) 1443 return res, ok 1444 } 1445 1446 func (fpvs *TimeSerie_FieldSubPathValue) SetTo(target **TimeSerie) { 1447 if *target == nil { 1448 *target = new(TimeSerie) 1449 } 1450 switch fpvs.Selector() { 1451 case TimeSerie_FieldPathSelectorMetric: 1452 fpvs.subPathValue.(common.Metric_FieldPathValue).SetTo(&(*target).Metric) 1453 case TimeSerie_FieldPathSelectorResource: 1454 fpvs.subPathValue.(common.MonitoredResource_FieldPathValue).SetTo(&(*target).Resource) 1455 case TimeSerie_FieldPathSelectorPoints: 1456 panic("FieldPath setter is unsupported for array subpaths") 1457 default: 1458 panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fpvs.Selector())) 1459 } 1460 } 1461 1462 func (fpvs *TimeSerie_FieldSubPathValue) SetToRaw(target proto.Message) { 1463 typedObject := target.(*TimeSerie) 1464 fpvs.SetTo(&typedObject) 1465 } 1466 1467 func (fpvs *TimeSerie_FieldSubPathValue) GetRawValue() interface{} { 1468 return fpvs.subPathValue.GetRawValue() 1469 } 1470 1471 func (fpvs *TimeSerie_FieldSubPathValue) CompareWith(source *TimeSerie) (int, bool) { 1472 switch fpvs.Selector() { 1473 case TimeSerie_FieldPathSelectorMetric: 1474 return fpvs.subPathValue.(common.Metric_FieldPathValue).CompareWith(source.GetMetric()) 1475 case TimeSerie_FieldPathSelectorResource: 1476 return fpvs.subPathValue.(common.MonitoredResource_FieldPathValue).CompareWith(source.GetResource()) 1477 case TimeSerie_FieldPathSelectorPoints: 1478 return 0, false // repeated field 1479 default: 1480 panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fpvs.Selector())) 1481 } 1482 } 1483 1484 func (fpvs *TimeSerie_FieldSubPathValue) CompareWithRaw(source proto.Message) (int, bool) { 1485 return fpvs.CompareWith(source.(*TimeSerie)) 1486 } 1487 1488 // TimeSerie_FieldPathArrayItemValue allows storing single item in Path-specific values for TimeSerie according to their type 1489 // Present only for array (repeated) types. 1490 type TimeSerie_FieldPathArrayItemValue interface { 1491 gotenobject.FieldPathArrayItemValue 1492 TimeSerie_FieldPath 1493 ContainsValue(*TimeSerie) bool 1494 } 1495 1496 // ParseTimeSerie_FieldPathArrayItemValue parses string and JSON-encoded value to its Value 1497 func ParseTimeSerie_FieldPathArrayItemValue(pathStr, valueStr string) (TimeSerie_FieldPathArrayItemValue, error) { 1498 fp, err := ParseTimeSerie_FieldPath(pathStr) 1499 if err != nil { 1500 return nil, err 1501 } 1502 fpaiv, err := gotenobject.ParseFieldPathArrayItemValue(fp, valueStr) 1503 if err != nil { 1504 return nil, status.Errorf(codes.InvalidArgument, "error parsing TimeSerie field path array item value from %s: %v", valueStr, err) 1505 } 1506 return fpaiv.(TimeSerie_FieldPathArrayItemValue), nil 1507 } 1508 1509 func MustParseTimeSerie_FieldPathArrayItemValue(pathStr, valueStr string) TimeSerie_FieldPathArrayItemValue { 1510 fpaiv, err := ParseTimeSerie_FieldPathArrayItemValue(pathStr, valueStr) 1511 if err != nil { 1512 panic(err) 1513 } 1514 return fpaiv 1515 } 1516 1517 type TimeSerie_FieldTerminalPathArrayItemValue struct { 1518 TimeSerie_FieldTerminalPath 1519 value interface{} 1520 } 1521 1522 var _ TimeSerie_FieldPathArrayItemValue = (*TimeSerie_FieldTerminalPathArrayItemValue)(nil) 1523 1524 // GetRawValue returns stored element value for array in object TimeSerie as interface{} 1525 func (fpaiv *TimeSerie_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} { 1526 return fpaiv.value 1527 } 1528 func (fpaiv *TimeSerie_FieldTerminalPathArrayItemValue) AsPointsItemValue() (*Point, bool) { 1529 res, ok := fpaiv.value.(*Point) 1530 return res, ok 1531 } 1532 1533 func (fpaiv *TimeSerie_FieldTerminalPathArrayItemValue) GetSingle(source *TimeSerie) (interface{}, bool) { 1534 return nil, false 1535 } 1536 1537 func (fpaiv *TimeSerie_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) { 1538 return fpaiv.GetSingle(source.(*TimeSerie)) 1539 } 1540 1541 // Contains returns a boolean indicating if value that is being held is present in given 'TimeSerie' 1542 func (fpaiv *TimeSerie_FieldTerminalPathArrayItemValue) ContainsValue(source *TimeSerie) bool { 1543 slice := fpaiv.TimeSerie_FieldTerminalPath.Get(source) 1544 for _, v := range slice { 1545 if asProtoMsg, ok := fpaiv.value.(proto.Message); ok { 1546 if proto.Equal(asProtoMsg, v.(proto.Message)) { 1547 return true 1548 } 1549 } else if reflect.DeepEqual(v, fpaiv.value) { 1550 return true 1551 } 1552 } 1553 return false 1554 } 1555 1556 type TimeSerie_FieldSubPathArrayItemValue struct { 1557 TimeSerie_FieldPath 1558 subPathItemValue gotenobject.FieldPathArrayItemValue 1559 } 1560 1561 // GetRawValue returns stored array item value 1562 func (fpaivs *TimeSerie_FieldSubPathArrayItemValue) GetRawItemValue() interface{} { 1563 return fpaivs.subPathItemValue.GetRawItemValue() 1564 } 1565 func (fpaivs *TimeSerie_FieldSubPathArrayItemValue) AsMetricPathItemValue() (common.Metric_FieldPathArrayItemValue, bool) { 1566 res, ok := fpaivs.subPathItemValue.(common.Metric_FieldPathArrayItemValue) 1567 return res, ok 1568 } 1569 func (fpaivs *TimeSerie_FieldSubPathArrayItemValue) AsResourcePathItemValue() (common.MonitoredResource_FieldPathArrayItemValue, bool) { 1570 res, ok := fpaivs.subPathItemValue.(common.MonitoredResource_FieldPathArrayItemValue) 1571 return res, ok 1572 } 1573 func (fpaivs *TimeSerie_FieldSubPathArrayItemValue) AsPointsPathItemValue() (Point_FieldPathArrayItemValue, bool) { 1574 res, ok := fpaivs.subPathItemValue.(Point_FieldPathArrayItemValue) 1575 return res, ok 1576 } 1577 1578 // Contains returns a boolean indicating if value that is being held is present in given 'TimeSerie' 1579 func (fpaivs *TimeSerie_FieldSubPathArrayItemValue) ContainsValue(source *TimeSerie) bool { 1580 switch fpaivs.Selector() { 1581 case TimeSerie_FieldPathSelectorMetric: 1582 return fpaivs.subPathItemValue.(common.Metric_FieldPathArrayItemValue).ContainsValue(source.GetMetric()) 1583 case TimeSerie_FieldPathSelectorResource: 1584 return fpaivs.subPathItemValue.(common.MonitoredResource_FieldPathArrayItemValue).ContainsValue(source.GetResource()) 1585 case TimeSerie_FieldPathSelectorPoints: 1586 return false // repeated/map field 1587 default: 1588 panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fpaivs.Selector())) 1589 } 1590 } 1591 1592 // TimeSerie_FieldPathArrayOfValues allows storing slice of values for TimeSerie fields according to their type 1593 type TimeSerie_FieldPathArrayOfValues interface { 1594 gotenobject.FieldPathArrayOfValues 1595 TimeSerie_FieldPath 1596 } 1597 1598 func ParseTimeSerie_FieldPathArrayOfValues(pathStr, valuesStr string) (TimeSerie_FieldPathArrayOfValues, error) { 1599 fp, err := ParseTimeSerie_FieldPath(pathStr) 1600 if err != nil { 1601 return nil, err 1602 } 1603 fpaov, err := gotenobject.ParseFieldPathArrayOfValues(fp, valuesStr) 1604 if err != nil { 1605 return nil, status.Errorf(codes.InvalidArgument, "error parsing TimeSerie field path array of values from %s: %v", valuesStr, err) 1606 } 1607 return fpaov.(TimeSerie_FieldPathArrayOfValues), nil 1608 } 1609 1610 func MustParseTimeSerie_FieldPathArrayOfValues(pathStr, valuesStr string) TimeSerie_FieldPathArrayOfValues { 1611 fpaov, err := ParseTimeSerie_FieldPathArrayOfValues(pathStr, valuesStr) 1612 if err != nil { 1613 panic(err) 1614 } 1615 return fpaov 1616 } 1617 1618 type TimeSerie_FieldTerminalPathArrayOfValues struct { 1619 TimeSerie_FieldTerminalPath 1620 values interface{} 1621 } 1622 1623 var _ TimeSerie_FieldPathArrayOfValues = (*TimeSerie_FieldTerminalPathArrayOfValues)(nil) 1624 1625 func (fpaov *TimeSerie_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) { 1626 switch fpaov.selector { 1627 case TimeSerie_FieldPathSelectorKey: 1628 for _, v := range fpaov.values.([][]byte) { 1629 values = append(values, v) 1630 } 1631 case TimeSerie_FieldPathSelectorProject: 1632 for _, v := range fpaov.values.([]string) { 1633 values = append(values, v) 1634 } 1635 case TimeSerie_FieldPathSelectorRegion: 1636 for _, v := range fpaov.values.([]string) { 1637 values = append(values, v) 1638 } 1639 case TimeSerie_FieldPathSelectorMetric: 1640 for _, v := range fpaov.values.([]*common.Metric) { 1641 values = append(values, v) 1642 } 1643 case TimeSerie_FieldPathSelectorResource: 1644 for _, v := range fpaov.values.([]*common.MonitoredResource) { 1645 values = append(values, v) 1646 } 1647 case TimeSerie_FieldPathSelectorMetricKind: 1648 for _, v := range fpaov.values.([]metric_descriptor.MetricDescriptor_MetricKind) { 1649 values = append(values, v) 1650 } 1651 case TimeSerie_FieldPathSelectorValueType: 1652 for _, v := range fpaov.values.([]metric_descriptor.MetricDescriptor_ValueType) { 1653 values = append(values, v) 1654 } 1655 case TimeSerie_FieldPathSelectorPoints: 1656 for _, v := range fpaov.values.([][]*Point) { 1657 values = append(values, v) 1658 } 1659 } 1660 return 1661 } 1662 func (fpaov *TimeSerie_FieldTerminalPathArrayOfValues) AsKeyArrayOfValues() ([][]byte, bool) { 1663 res, ok := fpaov.values.([][]byte) 1664 return res, ok 1665 } 1666 func (fpaov *TimeSerie_FieldTerminalPathArrayOfValues) AsProjectArrayOfValues() ([]string, bool) { 1667 res, ok := fpaov.values.([]string) 1668 return res, ok 1669 } 1670 func (fpaov *TimeSerie_FieldTerminalPathArrayOfValues) AsRegionArrayOfValues() ([]string, bool) { 1671 res, ok := fpaov.values.([]string) 1672 return res, ok 1673 } 1674 func (fpaov *TimeSerie_FieldTerminalPathArrayOfValues) AsMetricArrayOfValues() ([]*common.Metric, bool) { 1675 res, ok := fpaov.values.([]*common.Metric) 1676 return res, ok 1677 } 1678 func (fpaov *TimeSerie_FieldTerminalPathArrayOfValues) AsResourceArrayOfValues() ([]*common.MonitoredResource, bool) { 1679 res, ok := fpaov.values.([]*common.MonitoredResource) 1680 return res, ok 1681 } 1682 func (fpaov *TimeSerie_FieldTerminalPathArrayOfValues) AsMetricKindArrayOfValues() ([]metric_descriptor.MetricDescriptor_MetricKind, bool) { 1683 res, ok := fpaov.values.([]metric_descriptor.MetricDescriptor_MetricKind) 1684 return res, ok 1685 } 1686 func (fpaov *TimeSerie_FieldTerminalPathArrayOfValues) AsValueTypeArrayOfValues() ([]metric_descriptor.MetricDescriptor_ValueType, bool) { 1687 res, ok := fpaov.values.([]metric_descriptor.MetricDescriptor_ValueType) 1688 return res, ok 1689 } 1690 func (fpaov *TimeSerie_FieldTerminalPathArrayOfValues) AsPointsArrayOfValues() ([][]*Point, bool) { 1691 res, ok := fpaov.values.([][]*Point) 1692 return res, ok 1693 } 1694 1695 type TimeSerie_FieldSubPathArrayOfValues struct { 1696 TimeSerie_FieldPath 1697 subPathArrayOfValues gotenobject.FieldPathArrayOfValues 1698 } 1699 1700 var _ TimeSerie_FieldPathArrayOfValues = (*TimeSerie_FieldSubPathArrayOfValues)(nil) 1701 1702 func (fpsaov *TimeSerie_FieldSubPathArrayOfValues) GetRawValues() []interface{} { 1703 return fpsaov.subPathArrayOfValues.GetRawValues() 1704 } 1705 func (fpsaov *TimeSerie_FieldSubPathArrayOfValues) AsMetricPathArrayOfValues() (common.Metric_FieldPathArrayOfValues, bool) { 1706 res, ok := fpsaov.subPathArrayOfValues.(common.Metric_FieldPathArrayOfValues) 1707 return res, ok 1708 } 1709 func (fpsaov *TimeSerie_FieldSubPathArrayOfValues) AsResourcePathArrayOfValues() (common.MonitoredResource_FieldPathArrayOfValues, bool) { 1710 res, ok := fpsaov.subPathArrayOfValues.(common.MonitoredResource_FieldPathArrayOfValues) 1711 return res, ok 1712 } 1713 func (fpsaov *TimeSerie_FieldSubPathArrayOfValues) AsPointsPathArrayOfValues() (Point_FieldPathArrayOfValues, bool) { 1714 res, ok := fpsaov.subPathArrayOfValues.(Point_FieldPathArrayOfValues) 1715 return res, ok 1716 } 1717 1718 // FieldPath provides implementation to handle 1719 // https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto 1720 type BulkTimeSeries_FieldPath interface { 1721 gotenobject.FieldPath 1722 Selector() BulkTimeSeries_FieldPathSelector 1723 Get(source *BulkTimeSeries) []interface{} 1724 GetSingle(source *BulkTimeSeries) (interface{}, bool) 1725 ClearValue(item *BulkTimeSeries) 1726 1727 // Those methods build corresponding BulkTimeSeries_FieldPathValue 1728 // (or array of values) and holds passed value. Panics if injected type is incorrect. 1729 WithIValue(value interface{}) BulkTimeSeries_FieldPathValue 1730 WithIArrayOfValues(values interface{}) BulkTimeSeries_FieldPathArrayOfValues 1731 WithIArrayItemValue(value interface{}) BulkTimeSeries_FieldPathArrayItemValue 1732 } 1733 1734 type BulkTimeSeries_FieldPathSelector int32 1735 1736 const ( 1737 BulkTimeSeries_FieldPathSelectorTimeSeries BulkTimeSeries_FieldPathSelector = 0 1738 BulkTimeSeries_FieldPathSelectorPhantomFlag BulkTimeSeries_FieldPathSelector = 1 1739 ) 1740 1741 func (s BulkTimeSeries_FieldPathSelector) String() string { 1742 switch s { 1743 case BulkTimeSeries_FieldPathSelectorTimeSeries: 1744 return "time_series" 1745 case BulkTimeSeries_FieldPathSelectorPhantomFlag: 1746 return "phantom_flag" 1747 default: 1748 panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", s)) 1749 } 1750 } 1751 1752 func BuildBulkTimeSeries_FieldPath(fp gotenobject.RawFieldPath) (BulkTimeSeries_FieldPath, error) { 1753 if len(fp) == 0 { 1754 return nil, status.Error(codes.InvalidArgument, "empty field path for object BulkTimeSeries") 1755 } 1756 if len(fp) == 1 { 1757 switch fp[0] { 1758 case "time_series", "timeSeries", "time-series": 1759 return &BulkTimeSeries_FieldTerminalPath{selector: BulkTimeSeries_FieldPathSelectorTimeSeries}, nil 1760 case "phantom_flag", "phantomFlag", "phantom-flag": 1761 return &BulkTimeSeries_FieldTerminalPath{selector: BulkTimeSeries_FieldPathSelectorPhantomFlag}, nil 1762 } 1763 } else { 1764 switch fp[0] { 1765 case "time_series", "timeSeries", "time-series": 1766 if subpath, err := BuildTimeSerie_FieldPath(fp[1:]); err != nil { 1767 return nil, err 1768 } else { 1769 return &BulkTimeSeries_FieldSubPath{selector: BulkTimeSeries_FieldPathSelectorTimeSeries, subPath: subpath}, nil 1770 } 1771 } 1772 } 1773 return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object BulkTimeSeries", fp) 1774 } 1775 1776 func ParseBulkTimeSeries_FieldPath(rawField string) (BulkTimeSeries_FieldPath, error) { 1777 fp, err := gotenobject.ParseRawFieldPath(rawField) 1778 if err != nil { 1779 return nil, err 1780 } 1781 return BuildBulkTimeSeries_FieldPath(fp) 1782 } 1783 1784 func MustParseBulkTimeSeries_FieldPath(rawField string) BulkTimeSeries_FieldPath { 1785 fp, err := ParseBulkTimeSeries_FieldPath(rawField) 1786 if err != nil { 1787 panic(err) 1788 } 1789 return fp 1790 } 1791 1792 type BulkTimeSeries_FieldTerminalPath struct { 1793 selector BulkTimeSeries_FieldPathSelector 1794 } 1795 1796 var _ BulkTimeSeries_FieldPath = (*BulkTimeSeries_FieldTerminalPath)(nil) 1797 1798 func (fp *BulkTimeSeries_FieldTerminalPath) Selector() BulkTimeSeries_FieldPathSelector { 1799 return fp.selector 1800 } 1801 1802 // String returns path representation in proto convention 1803 func (fp *BulkTimeSeries_FieldTerminalPath) String() string { 1804 return fp.selector.String() 1805 } 1806 1807 // JSONString returns path representation is JSON convention 1808 func (fp *BulkTimeSeries_FieldTerminalPath) JSONString() string { 1809 return strcase.ToLowerCamel(fp.String()) 1810 } 1811 1812 // Get returns all values pointed by specific field from source BulkTimeSeries 1813 func (fp *BulkTimeSeries_FieldTerminalPath) Get(source *BulkTimeSeries) (values []interface{}) { 1814 if source != nil { 1815 switch fp.selector { 1816 case BulkTimeSeries_FieldPathSelectorTimeSeries: 1817 for _, value := range source.GetTimeSeries() { 1818 values = append(values, value) 1819 } 1820 case BulkTimeSeries_FieldPathSelectorPhantomFlag: 1821 values = append(values, source.PhantomFlag) 1822 default: 1823 panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fp.selector)) 1824 } 1825 } 1826 return 1827 } 1828 1829 func (fp *BulkTimeSeries_FieldTerminalPath) GetRaw(source proto.Message) []interface{} { 1830 return fp.Get(source.(*BulkTimeSeries)) 1831 } 1832 1833 // GetSingle returns value pointed by specific field of from source BulkTimeSeries 1834 func (fp *BulkTimeSeries_FieldTerminalPath) GetSingle(source *BulkTimeSeries) (interface{}, bool) { 1835 switch fp.selector { 1836 case BulkTimeSeries_FieldPathSelectorTimeSeries: 1837 res := source.GetTimeSeries() 1838 return res, res != nil 1839 case BulkTimeSeries_FieldPathSelectorPhantomFlag: 1840 return source.GetPhantomFlag(), source != nil 1841 default: 1842 panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fp.selector)) 1843 } 1844 } 1845 1846 func (fp *BulkTimeSeries_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) { 1847 return fp.GetSingle(source.(*BulkTimeSeries)) 1848 } 1849 1850 // GetDefault returns a default value of the field type 1851 func (fp *BulkTimeSeries_FieldTerminalPath) GetDefault() interface{} { 1852 switch fp.selector { 1853 case BulkTimeSeries_FieldPathSelectorTimeSeries: 1854 return ([]*TimeSerie)(nil) 1855 case BulkTimeSeries_FieldPathSelectorPhantomFlag: 1856 return false 1857 default: 1858 panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fp.selector)) 1859 } 1860 } 1861 1862 func (fp *BulkTimeSeries_FieldTerminalPath) ClearValue(item *BulkTimeSeries) { 1863 if item != nil { 1864 switch fp.selector { 1865 case BulkTimeSeries_FieldPathSelectorTimeSeries: 1866 item.TimeSeries = nil 1867 case BulkTimeSeries_FieldPathSelectorPhantomFlag: 1868 item.PhantomFlag = false 1869 default: 1870 panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fp.selector)) 1871 } 1872 } 1873 } 1874 1875 func (fp *BulkTimeSeries_FieldTerminalPath) ClearValueRaw(item proto.Message) { 1876 fp.ClearValue(item.(*BulkTimeSeries)) 1877 } 1878 1879 // IsLeaf - whether field path is holds simple value 1880 func (fp *BulkTimeSeries_FieldTerminalPath) IsLeaf() bool { 1881 return fp.selector == BulkTimeSeries_FieldPathSelectorPhantomFlag 1882 } 1883 1884 func (fp *BulkTimeSeries_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath { 1885 return []gotenobject.FieldPath{fp} 1886 } 1887 1888 func (fp *BulkTimeSeries_FieldTerminalPath) WithIValue(value interface{}) BulkTimeSeries_FieldPathValue { 1889 switch fp.selector { 1890 case BulkTimeSeries_FieldPathSelectorTimeSeries: 1891 return &BulkTimeSeries_FieldTerminalPathValue{BulkTimeSeries_FieldTerminalPath: *fp, value: value.([]*TimeSerie)} 1892 case BulkTimeSeries_FieldPathSelectorPhantomFlag: 1893 return &BulkTimeSeries_FieldTerminalPathValue{BulkTimeSeries_FieldTerminalPath: *fp, value: value.(bool)} 1894 default: 1895 panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fp.selector)) 1896 } 1897 } 1898 1899 func (fp *BulkTimeSeries_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue { 1900 return fp.WithIValue(value) 1901 } 1902 1903 func (fp *BulkTimeSeries_FieldTerminalPath) WithIArrayOfValues(values interface{}) BulkTimeSeries_FieldPathArrayOfValues { 1904 fpaov := &BulkTimeSeries_FieldTerminalPathArrayOfValues{BulkTimeSeries_FieldTerminalPath: *fp} 1905 switch fp.selector { 1906 case BulkTimeSeries_FieldPathSelectorTimeSeries: 1907 return &BulkTimeSeries_FieldTerminalPathArrayOfValues{BulkTimeSeries_FieldTerminalPath: *fp, values: values.([][]*TimeSerie)} 1908 case BulkTimeSeries_FieldPathSelectorPhantomFlag: 1909 return &BulkTimeSeries_FieldTerminalPathArrayOfValues{BulkTimeSeries_FieldTerminalPath: *fp, values: values.([]bool)} 1910 default: 1911 panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fp.selector)) 1912 } 1913 return fpaov 1914 } 1915 1916 func (fp *BulkTimeSeries_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues { 1917 return fp.WithIArrayOfValues(values) 1918 } 1919 1920 func (fp *BulkTimeSeries_FieldTerminalPath) WithIArrayItemValue(value interface{}) BulkTimeSeries_FieldPathArrayItemValue { 1921 switch fp.selector { 1922 case BulkTimeSeries_FieldPathSelectorTimeSeries: 1923 return &BulkTimeSeries_FieldTerminalPathArrayItemValue{BulkTimeSeries_FieldTerminalPath: *fp, value: value.(*TimeSerie)} 1924 default: 1925 panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fp.selector)) 1926 } 1927 } 1928 1929 func (fp *BulkTimeSeries_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue { 1930 return fp.WithIArrayItemValue(value) 1931 } 1932 1933 type BulkTimeSeries_FieldSubPath struct { 1934 selector BulkTimeSeries_FieldPathSelector 1935 subPath gotenobject.FieldPath 1936 } 1937 1938 var _ BulkTimeSeries_FieldPath = (*BulkTimeSeries_FieldSubPath)(nil) 1939 1940 func (fps *BulkTimeSeries_FieldSubPath) Selector() BulkTimeSeries_FieldPathSelector { 1941 return fps.selector 1942 } 1943 func (fps *BulkTimeSeries_FieldSubPath) AsTimeSeriesSubPath() (TimeSerie_FieldPath, bool) { 1944 res, ok := fps.subPath.(TimeSerie_FieldPath) 1945 return res, ok 1946 } 1947 1948 // String returns path representation in proto convention 1949 func (fps *BulkTimeSeries_FieldSubPath) String() string { 1950 return fps.selector.String() + "." + fps.subPath.String() 1951 } 1952 1953 // JSONString returns path representation is JSON convention 1954 func (fps *BulkTimeSeries_FieldSubPath) JSONString() string { 1955 return strcase.ToLowerCamel(fps.selector.String()) + "." + fps.subPath.JSONString() 1956 } 1957 1958 // Get returns all values pointed by selected field from source BulkTimeSeries 1959 func (fps *BulkTimeSeries_FieldSubPath) Get(source *BulkTimeSeries) (values []interface{}) { 1960 switch fps.selector { 1961 case BulkTimeSeries_FieldPathSelectorTimeSeries: 1962 for _, item := range source.GetTimeSeries() { 1963 values = append(values, fps.subPath.GetRaw(item)...) 1964 } 1965 default: 1966 panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fps.selector)) 1967 } 1968 return 1969 } 1970 1971 func (fps *BulkTimeSeries_FieldSubPath) GetRaw(source proto.Message) []interface{} { 1972 return fps.Get(source.(*BulkTimeSeries)) 1973 } 1974 1975 // GetSingle returns value of selected field from source BulkTimeSeries 1976 func (fps *BulkTimeSeries_FieldSubPath) GetSingle(source *BulkTimeSeries) (interface{}, bool) { 1977 switch fps.selector { 1978 case BulkTimeSeries_FieldPathSelectorTimeSeries: 1979 if len(source.GetTimeSeries()) == 0 { 1980 return nil, false 1981 } 1982 return fps.subPath.GetSingleRaw(source.GetTimeSeries()[0]) 1983 default: 1984 panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fps.selector)) 1985 } 1986 } 1987 1988 func (fps *BulkTimeSeries_FieldSubPath) GetSingleRaw(source proto.Message) (interface{}, bool) { 1989 return fps.GetSingle(source.(*BulkTimeSeries)) 1990 } 1991 1992 // GetDefault returns a default value of the field type 1993 func (fps *BulkTimeSeries_FieldSubPath) GetDefault() interface{} { 1994 return fps.subPath.GetDefault() 1995 } 1996 1997 func (fps *BulkTimeSeries_FieldSubPath) ClearValue(item *BulkTimeSeries) { 1998 if item != nil { 1999 switch fps.selector { 2000 case BulkTimeSeries_FieldPathSelectorTimeSeries: 2001 for _, subItem := range item.TimeSeries { 2002 fps.subPath.ClearValueRaw(subItem) 2003 } 2004 default: 2005 panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fps.selector)) 2006 } 2007 } 2008 } 2009 2010 func (fps *BulkTimeSeries_FieldSubPath) ClearValueRaw(item proto.Message) { 2011 fps.ClearValue(item.(*BulkTimeSeries)) 2012 } 2013 2014 // IsLeaf - whether field path is holds simple value 2015 func (fps *BulkTimeSeries_FieldSubPath) IsLeaf() bool { 2016 return fps.subPath.IsLeaf() 2017 } 2018 2019 func (fps *BulkTimeSeries_FieldSubPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath { 2020 iPaths := []gotenobject.FieldPath{&BulkTimeSeries_FieldTerminalPath{selector: fps.selector}} 2021 iPaths = append(iPaths, fps.subPath.SplitIntoTerminalIPaths()...) 2022 return iPaths 2023 } 2024 2025 func (fps *BulkTimeSeries_FieldSubPath) WithIValue(value interface{}) BulkTimeSeries_FieldPathValue { 2026 return &BulkTimeSeries_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)} 2027 } 2028 2029 func (fps *BulkTimeSeries_FieldSubPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue { 2030 return fps.WithIValue(value) 2031 } 2032 2033 func (fps *BulkTimeSeries_FieldSubPath) WithIArrayOfValues(values interface{}) BulkTimeSeries_FieldPathArrayOfValues { 2034 return &BulkTimeSeries_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)} 2035 } 2036 2037 func (fps *BulkTimeSeries_FieldSubPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues { 2038 return fps.WithIArrayOfValues(values) 2039 } 2040 2041 func (fps *BulkTimeSeries_FieldSubPath) WithIArrayItemValue(value interface{}) BulkTimeSeries_FieldPathArrayItemValue { 2042 return &BulkTimeSeries_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)} 2043 } 2044 2045 func (fps *BulkTimeSeries_FieldSubPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue { 2046 return fps.WithIArrayItemValue(value) 2047 } 2048 2049 // BulkTimeSeries_FieldPathValue allows storing values for BulkTimeSeries fields according to their type 2050 type BulkTimeSeries_FieldPathValue interface { 2051 BulkTimeSeries_FieldPath 2052 gotenobject.FieldPathValue 2053 SetTo(target **BulkTimeSeries) 2054 CompareWith(*BulkTimeSeries) (cmp int, comparable bool) 2055 } 2056 2057 func ParseBulkTimeSeries_FieldPathValue(pathStr, valueStr string) (BulkTimeSeries_FieldPathValue, error) { 2058 fp, err := ParseBulkTimeSeries_FieldPath(pathStr) 2059 if err != nil { 2060 return nil, err 2061 } 2062 fpv, err := gotenobject.ParseFieldPathValue(fp, valueStr) 2063 if err != nil { 2064 return nil, status.Errorf(codes.InvalidArgument, "error parsing BulkTimeSeries field path value from %s: %v", valueStr, err) 2065 } 2066 return fpv.(BulkTimeSeries_FieldPathValue), nil 2067 } 2068 2069 func MustParseBulkTimeSeries_FieldPathValue(pathStr, valueStr string) BulkTimeSeries_FieldPathValue { 2070 fpv, err := ParseBulkTimeSeries_FieldPathValue(pathStr, valueStr) 2071 if err != nil { 2072 panic(err) 2073 } 2074 return fpv 2075 } 2076 2077 type BulkTimeSeries_FieldTerminalPathValue struct { 2078 BulkTimeSeries_FieldTerminalPath 2079 value interface{} 2080 } 2081 2082 var _ BulkTimeSeries_FieldPathValue = (*BulkTimeSeries_FieldTerminalPathValue)(nil) 2083 2084 // GetRawValue returns raw value stored under selected path for 'BulkTimeSeries' as interface{} 2085 func (fpv *BulkTimeSeries_FieldTerminalPathValue) GetRawValue() interface{} { 2086 return fpv.value 2087 } 2088 func (fpv *BulkTimeSeries_FieldTerminalPathValue) AsTimeSeriesValue() ([]*TimeSerie, bool) { 2089 res, ok := fpv.value.([]*TimeSerie) 2090 return res, ok 2091 } 2092 func (fpv *BulkTimeSeries_FieldTerminalPathValue) AsPhantomFlagValue() (bool, bool) { 2093 res, ok := fpv.value.(bool) 2094 return res, ok 2095 } 2096 2097 // SetTo stores value for selected field for object BulkTimeSeries 2098 func (fpv *BulkTimeSeries_FieldTerminalPathValue) SetTo(target **BulkTimeSeries) { 2099 if *target == nil { 2100 *target = new(BulkTimeSeries) 2101 } 2102 switch fpv.selector { 2103 case BulkTimeSeries_FieldPathSelectorTimeSeries: 2104 (*target).TimeSeries = fpv.value.([]*TimeSerie) 2105 case BulkTimeSeries_FieldPathSelectorPhantomFlag: 2106 (*target).PhantomFlag = fpv.value.(bool) 2107 default: 2108 panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fpv.selector)) 2109 } 2110 } 2111 2112 func (fpv *BulkTimeSeries_FieldTerminalPathValue) SetToRaw(target proto.Message) { 2113 typedObject := target.(*BulkTimeSeries) 2114 fpv.SetTo(&typedObject) 2115 } 2116 2117 // CompareWith compares value in the 'BulkTimeSeries_FieldTerminalPathValue' with the value under path in 'BulkTimeSeries'. 2118 func (fpv *BulkTimeSeries_FieldTerminalPathValue) CompareWith(source *BulkTimeSeries) (int, bool) { 2119 switch fpv.selector { 2120 case BulkTimeSeries_FieldPathSelectorTimeSeries: 2121 return 0, false 2122 case BulkTimeSeries_FieldPathSelectorPhantomFlag: 2123 leftValue := fpv.value.(bool) 2124 rightValue := source.GetPhantomFlag() 2125 if (leftValue) == (rightValue) { 2126 return 0, true 2127 } else if !(leftValue) && (rightValue) { 2128 return -1, true 2129 } else { 2130 return 1, true 2131 } 2132 default: 2133 panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fpv.selector)) 2134 } 2135 } 2136 2137 func (fpv *BulkTimeSeries_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) { 2138 return fpv.CompareWith(source.(*BulkTimeSeries)) 2139 } 2140 2141 type BulkTimeSeries_FieldSubPathValue struct { 2142 BulkTimeSeries_FieldPath 2143 subPathValue gotenobject.FieldPathValue 2144 } 2145 2146 var _ BulkTimeSeries_FieldPathValue = (*BulkTimeSeries_FieldSubPathValue)(nil) 2147 2148 func (fpvs *BulkTimeSeries_FieldSubPathValue) AsTimeSeriesPathValue() (TimeSerie_FieldPathValue, bool) { 2149 res, ok := fpvs.subPathValue.(TimeSerie_FieldPathValue) 2150 return res, ok 2151 } 2152 2153 func (fpvs *BulkTimeSeries_FieldSubPathValue) SetTo(target **BulkTimeSeries) { 2154 if *target == nil { 2155 *target = new(BulkTimeSeries) 2156 } 2157 switch fpvs.Selector() { 2158 case BulkTimeSeries_FieldPathSelectorTimeSeries: 2159 panic("FieldPath setter is unsupported for array subpaths") 2160 default: 2161 panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fpvs.Selector())) 2162 } 2163 } 2164 2165 func (fpvs *BulkTimeSeries_FieldSubPathValue) SetToRaw(target proto.Message) { 2166 typedObject := target.(*BulkTimeSeries) 2167 fpvs.SetTo(&typedObject) 2168 } 2169 2170 func (fpvs *BulkTimeSeries_FieldSubPathValue) GetRawValue() interface{} { 2171 return fpvs.subPathValue.GetRawValue() 2172 } 2173 2174 func (fpvs *BulkTimeSeries_FieldSubPathValue) CompareWith(source *BulkTimeSeries) (int, bool) { 2175 switch fpvs.Selector() { 2176 case BulkTimeSeries_FieldPathSelectorTimeSeries: 2177 return 0, false // repeated field 2178 default: 2179 panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fpvs.Selector())) 2180 } 2181 } 2182 2183 func (fpvs *BulkTimeSeries_FieldSubPathValue) CompareWithRaw(source proto.Message) (int, bool) { 2184 return fpvs.CompareWith(source.(*BulkTimeSeries)) 2185 } 2186 2187 // BulkTimeSeries_FieldPathArrayItemValue allows storing single item in Path-specific values for BulkTimeSeries according to their type 2188 // Present only for array (repeated) types. 2189 type BulkTimeSeries_FieldPathArrayItemValue interface { 2190 gotenobject.FieldPathArrayItemValue 2191 BulkTimeSeries_FieldPath 2192 ContainsValue(*BulkTimeSeries) bool 2193 } 2194 2195 // ParseBulkTimeSeries_FieldPathArrayItemValue parses string and JSON-encoded value to its Value 2196 func ParseBulkTimeSeries_FieldPathArrayItemValue(pathStr, valueStr string) (BulkTimeSeries_FieldPathArrayItemValue, error) { 2197 fp, err := ParseBulkTimeSeries_FieldPath(pathStr) 2198 if err != nil { 2199 return nil, err 2200 } 2201 fpaiv, err := gotenobject.ParseFieldPathArrayItemValue(fp, valueStr) 2202 if err != nil { 2203 return nil, status.Errorf(codes.InvalidArgument, "error parsing BulkTimeSeries field path array item value from %s: %v", valueStr, err) 2204 } 2205 return fpaiv.(BulkTimeSeries_FieldPathArrayItemValue), nil 2206 } 2207 2208 func MustParseBulkTimeSeries_FieldPathArrayItemValue(pathStr, valueStr string) BulkTimeSeries_FieldPathArrayItemValue { 2209 fpaiv, err := ParseBulkTimeSeries_FieldPathArrayItemValue(pathStr, valueStr) 2210 if err != nil { 2211 panic(err) 2212 } 2213 return fpaiv 2214 } 2215 2216 type BulkTimeSeries_FieldTerminalPathArrayItemValue struct { 2217 BulkTimeSeries_FieldTerminalPath 2218 value interface{} 2219 } 2220 2221 var _ BulkTimeSeries_FieldPathArrayItemValue = (*BulkTimeSeries_FieldTerminalPathArrayItemValue)(nil) 2222 2223 // GetRawValue returns stored element value for array in object BulkTimeSeries as interface{} 2224 func (fpaiv *BulkTimeSeries_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} { 2225 return fpaiv.value 2226 } 2227 func (fpaiv *BulkTimeSeries_FieldTerminalPathArrayItemValue) AsTimeSeriesItemValue() (*TimeSerie, bool) { 2228 res, ok := fpaiv.value.(*TimeSerie) 2229 return res, ok 2230 } 2231 2232 func (fpaiv *BulkTimeSeries_FieldTerminalPathArrayItemValue) GetSingle(source *BulkTimeSeries) (interface{}, bool) { 2233 return nil, false 2234 } 2235 2236 func (fpaiv *BulkTimeSeries_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) { 2237 return fpaiv.GetSingle(source.(*BulkTimeSeries)) 2238 } 2239 2240 // Contains returns a boolean indicating if value that is being held is present in given 'BulkTimeSeries' 2241 func (fpaiv *BulkTimeSeries_FieldTerminalPathArrayItemValue) ContainsValue(source *BulkTimeSeries) bool { 2242 slice := fpaiv.BulkTimeSeries_FieldTerminalPath.Get(source) 2243 for _, v := range slice { 2244 if asProtoMsg, ok := fpaiv.value.(proto.Message); ok { 2245 if proto.Equal(asProtoMsg, v.(proto.Message)) { 2246 return true 2247 } 2248 } else if reflect.DeepEqual(v, fpaiv.value) { 2249 return true 2250 } 2251 } 2252 return false 2253 } 2254 2255 type BulkTimeSeries_FieldSubPathArrayItemValue struct { 2256 BulkTimeSeries_FieldPath 2257 subPathItemValue gotenobject.FieldPathArrayItemValue 2258 } 2259 2260 // GetRawValue returns stored array item value 2261 func (fpaivs *BulkTimeSeries_FieldSubPathArrayItemValue) GetRawItemValue() interface{} { 2262 return fpaivs.subPathItemValue.GetRawItemValue() 2263 } 2264 func (fpaivs *BulkTimeSeries_FieldSubPathArrayItemValue) AsTimeSeriesPathItemValue() (TimeSerie_FieldPathArrayItemValue, bool) { 2265 res, ok := fpaivs.subPathItemValue.(TimeSerie_FieldPathArrayItemValue) 2266 return res, ok 2267 } 2268 2269 // Contains returns a boolean indicating if value that is being held is present in given 'BulkTimeSeries' 2270 func (fpaivs *BulkTimeSeries_FieldSubPathArrayItemValue) ContainsValue(source *BulkTimeSeries) bool { 2271 switch fpaivs.Selector() { 2272 case BulkTimeSeries_FieldPathSelectorTimeSeries: 2273 return false // repeated/map field 2274 default: 2275 panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fpaivs.Selector())) 2276 } 2277 } 2278 2279 // BulkTimeSeries_FieldPathArrayOfValues allows storing slice of values for BulkTimeSeries fields according to their type 2280 type BulkTimeSeries_FieldPathArrayOfValues interface { 2281 gotenobject.FieldPathArrayOfValues 2282 BulkTimeSeries_FieldPath 2283 } 2284 2285 func ParseBulkTimeSeries_FieldPathArrayOfValues(pathStr, valuesStr string) (BulkTimeSeries_FieldPathArrayOfValues, error) { 2286 fp, err := ParseBulkTimeSeries_FieldPath(pathStr) 2287 if err != nil { 2288 return nil, err 2289 } 2290 fpaov, err := gotenobject.ParseFieldPathArrayOfValues(fp, valuesStr) 2291 if err != nil { 2292 return nil, status.Errorf(codes.InvalidArgument, "error parsing BulkTimeSeries field path array of values from %s: %v", valuesStr, err) 2293 } 2294 return fpaov.(BulkTimeSeries_FieldPathArrayOfValues), nil 2295 } 2296 2297 func MustParseBulkTimeSeries_FieldPathArrayOfValues(pathStr, valuesStr string) BulkTimeSeries_FieldPathArrayOfValues { 2298 fpaov, err := ParseBulkTimeSeries_FieldPathArrayOfValues(pathStr, valuesStr) 2299 if err != nil { 2300 panic(err) 2301 } 2302 return fpaov 2303 } 2304 2305 type BulkTimeSeries_FieldTerminalPathArrayOfValues struct { 2306 BulkTimeSeries_FieldTerminalPath 2307 values interface{} 2308 } 2309 2310 var _ BulkTimeSeries_FieldPathArrayOfValues = (*BulkTimeSeries_FieldTerminalPathArrayOfValues)(nil) 2311 2312 func (fpaov *BulkTimeSeries_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) { 2313 switch fpaov.selector { 2314 case BulkTimeSeries_FieldPathSelectorTimeSeries: 2315 for _, v := range fpaov.values.([][]*TimeSerie) { 2316 values = append(values, v) 2317 } 2318 case BulkTimeSeries_FieldPathSelectorPhantomFlag: 2319 for _, v := range fpaov.values.([]bool) { 2320 values = append(values, v) 2321 } 2322 } 2323 return 2324 } 2325 func (fpaov *BulkTimeSeries_FieldTerminalPathArrayOfValues) AsTimeSeriesArrayOfValues() ([][]*TimeSerie, bool) { 2326 res, ok := fpaov.values.([][]*TimeSerie) 2327 return res, ok 2328 } 2329 func (fpaov *BulkTimeSeries_FieldTerminalPathArrayOfValues) AsPhantomFlagArrayOfValues() ([]bool, bool) { 2330 res, ok := fpaov.values.([]bool) 2331 return res, ok 2332 } 2333 2334 type BulkTimeSeries_FieldSubPathArrayOfValues struct { 2335 BulkTimeSeries_FieldPath 2336 subPathArrayOfValues gotenobject.FieldPathArrayOfValues 2337 } 2338 2339 var _ BulkTimeSeries_FieldPathArrayOfValues = (*BulkTimeSeries_FieldSubPathArrayOfValues)(nil) 2340 2341 func (fpsaov *BulkTimeSeries_FieldSubPathArrayOfValues) GetRawValues() []interface{} { 2342 return fpsaov.subPathArrayOfValues.GetRawValues() 2343 } 2344 func (fpsaov *BulkTimeSeries_FieldSubPathArrayOfValues) AsTimeSeriesPathArrayOfValues() (TimeSerie_FieldPathArrayOfValues, bool) { 2345 res, ok := fpsaov.subPathArrayOfValues.(TimeSerie_FieldPathArrayOfValues) 2346 return res, ok 2347 }