github.com/cloudwan/edgelq-sdk@v1.15.4/monitoring/resources/v4/time_serie/time_serie.pb.fieldpath.go (about) 1 // Code generated by protoc-gen-goten-object 2 // File: edgelq/monitoring/proto/v4/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/v4/common" 27 metric_descriptor "github.com/cloudwan/edgelq-sdk/monitoring/resources/v4/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_FieldPathSelectorUnit TimeSerie_FieldPathSelector = 3 803 TimeSerie_FieldPathSelectorMetric TimeSerie_FieldPathSelector = 4 804 TimeSerie_FieldPathSelectorResource TimeSerie_FieldPathSelector = 5 805 TimeSerie_FieldPathSelectorMetricKind TimeSerie_FieldPathSelector = 6 806 TimeSerie_FieldPathSelectorValueType TimeSerie_FieldPathSelector = 7 807 TimeSerie_FieldPathSelectorPoints TimeSerie_FieldPathSelector = 8 808 ) 809 810 func (s TimeSerie_FieldPathSelector) String() string { 811 switch s { 812 case TimeSerie_FieldPathSelectorKey: 813 return "key" 814 case TimeSerie_FieldPathSelectorProject: 815 return "project" 816 case TimeSerie_FieldPathSelectorRegion: 817 return "region" 818 case TimeSerie_FieldPathSelectorUnit: 819 return "unit" 820 case TimeSerie_FieldPathSelectorMetric: 821 return "metric" 822 case TimeSerie_FieldPathSelectorResource: 823 return "resource" 824 case TimeSerie_FieldPathSelectorMetricKind: 825 return "metric_kind" 826 case TimeSerie_FieldPathSelectorValueType: 827 return "value_type" 828 case TimeSerie_FieldPathSelectorPoints: 829 return "points" 830 default: 831 panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", s)) 832 } 833 } 834 835 func BuildTimeSerie_FieldPath(fp gotenobject.RawFieldPath) (TimeSerie_FieldPath, error) { 836 if len(fp) == 0 { 837 return nil, status.Error(codes.InvalidArgument, "empty field path for object TimeSerie") 838 } 839 if len(fp) == 1 { 840 switch fp[0] { 841 case "key": 842 return &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorKey}, nil 843 case "project": 844 return &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorProject}, nil 845 case "region": 846 return &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorRegion}, nil 847 case "unit": 848 return &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorUnit}, nil 849 case "metric": 850 return &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorMetric}, nil 851 case "resource": 852 return &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorResource}, nil 853 case "metric_kind", "metricKind", "metric-kind": 854 return &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorMetricKind}, nil 855 case "value_type", "valueType", "value-type": 856 return &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorValueType}, nil 857 case "points": 858 return &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorPoints}, nil 859 } 860 } else { 861 switch fp[0] { 862 case "metric": 863 if subpath, err := common.BuildMetric_FieldPath(fp[1:]); err != nil { 864 return nil, err 865 } else { 866 return &TimeSerie_FieldSubPath{selector: TimeSerie_FieldPathSelectorMetric, subPath: subpath}, nil 867 } 868 case "resource": 869 if subpath, err := common.BuildMonitoredResource_FieldPath(fp[1:]); err != nil { 870 return nil, err 871 } else { 872 return &TimeSerie_FieldSubPath{selector: TimeSerie_FieldPathSelectorResource, subPath: subpath}, nil 873 } 874 case "points": 875 if subpath, err := BuildPoint_FieldPath(fp[1:]); err != nil { 876 return nil, err 877 } else { 878 return &TimeSerie_FieldSubPath{selector: TimeSerie_FieldPathSelectorPoints, subPath: subpath}, nil 879 } 880 } 881 } 882 return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object TimeSerie", fp) 883 } 884 885 func ParseTimeSerie_FieldPath(rawField string) (TimeSerie_FieldPath, error) { 886 fp, err := gotenobject.ParseRawFieldPath(rawField) 887 if err != nil { 888 return nil, err 889 } 890 return BuildTimeSerie_FieldPath(fp) 891 } 892 893 func MustParseTimeSerie_FieldPath(rawField string) TimeSerie_FieldPath { 894 fp, err := ParseTimeSerie_FieldPath(rawField) 895 if err != nil { 896 panic(err) 897 } 898 return fp 899 } 900 901 type TimeSerie_FieldTerminalPath struct { 902 selector TimeSerie_FieldPathSelector 903 } 904 905 var _ TimeSerie_FieldPath = (*TimeSerie_FieldTerminalPath)(nil) 906 907 func (fp *TimeSerie_FieldTerminalPath) Selector() TimeSerie_FieldPathSelector { 908 return fp.selector 909 } 910 911 // String returns path representation in proto convention 912 func (fp *TimeSerie_FieldTerminalPath) String() string { 913 return fp.selector.String() 914 } 915 916 // JSONString returns path representation is JSON convention 917 func (fp *TimeSerie_FieldTerminalPath) JSONString() string { 918 return strcase.ToLowerCamel(fp.String()) 919 } 920 921 // Get returns all values pointed by specific field from source TimeSerie 922 func (fp *TimeSerie_FieldTerminalPath) Get(source *TimeSerie) (values []interface{}) { 923 if source != nil { 924 switch fp.selector { 925 case TimeSerie_FieldPathSelectorKey: 926 values = append(values, source.Key) 927 case TimeSerie_FieldPathSelectorProject: 928 values = append(values, source.Project) 929 case TimeSerie_FieldPathSelectorRegion: 930 values = append(values, source.Region) 931 case TimeSerie_FieldPathSelectorUnit: 932 values = append(values, source.Unit) 933 case TimeSerie_FieldPathSelectorMetric: 934 if source.Metric != nil { 935 values = append(values, source.Metric) 936 } 937 case TimeSerie_FieldPathSelectorResource: 938 if source.Resource != nil { 939 values = append(values, source.Resource) 940 } 941 case TimeSerie_FieldPathSelectorMetricKind: 942 values = append(values, source.MetricKind) 943 case TimeSerie_FieldPathSelectorValueType: 944 values = append(values, source.ValueType) 945 case TimeSerie_FieldPathSelectorPoints: 946 for _, value := range source.GetPoints() { 947 values = append(values, value) 948 } 949 default: 950 panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fp.selector)) 951 } 952 } 953 return 954 } 955 956 func (fp *TimeSerie_FieldTerminalPath) GetRaw(source proto.Message) []interface{} { 957 return fp.Get(source.(*TimeSerie)) 958 } 959 960 // GetSingle returns value pointed by specific field of from source TimeSerie 961 func (fp *TimeSerie_FieldTerminalPath) GetSingle(source *TimeSerie) (interface{}, bool) { 962 switch fp.selector { 963 case TimeSerie_FieldPathSelectorKey: 964 res := source.GetKey() 965 return res, res != nil 966 case TimeSerie_FieldPathSelectorProject: 967 return source.GetProject(), source != nil 968 case TimeSerie_FieldPathSelectorRegion: 969 return source.GetRegion(), source != nil 970 case TimeSerie_FieldPathSelectorUnit: 971 return source.GetUnit(), source != nil 972 case TimeSerie_FieldPathSelectorMetric: 973 res := source.GetMetric() 974 return res, res != nil 975 case TimeSerie_FieldPathSelectorResource: 976 res := source.GetResource() 977 return res, res != nil 978 case TimeSerie_FieldPathSelectorMetricKind: 979 return source.GetMetricKind(), source != nil 980 case TimeSerie_FieldPathSelectorValueType: 981 return source.GetValueType(), source != nil 982 case TimeSerie_FieldPathSelectorPoints: 983 res := source.GetPoints() 984 return res, res != nil 985 default: 986 panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fp.selector)) 987 } 988 } 989 990 func (fp *TimeSerie_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) { 991 return fp.GetSingle(source.(*TimeSerie)) 992 } 993 994 // GetDefault returns a default value of the field type 995 func (fp *TimeSerie_FieldTerminalPath) GetDefault() interface{} { 996 switch fp.selector { 997 case TimeSerie_FieldPathSelectorKey: 998 return ([]byte)(nil) 999 case TimeSerie_FieldPathSelectorProject: 1000 return "" 1001 case TimeSerie_FieldPathSelectorRegion: 1002 return "" 1003 case TimeSerie_FieldPathSelectorUnit: 1004 return "" 1005 case TimeSerie_FieldPathSelectorMetric: 1006 return (*common.Metric)(nil) 1007 case TimeSerie_FieldPathSelectorResource: 1008 return (*common.MonitoredResource)(nil) 1009 case TimeSerie_FieldPathSelectorMetricKind: 1010 return metric_descriptor.MetricDescriptor_METRIC_KIND_UNSPECIFIED 1011 case TimeSerie_FieldPathSelectorValueType: 1012 return metric_descriptor.MetricDescriptor_VALUE_TYPE_UNSPECIFIED 1013 case TimeSerie_FieldPathSelectorPoints: 1014 return ([]*Point)(nil) 1015 default: 1016 panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fp.selector)) 1017 } 1018 } 1019 1020 func (fp *TimeSerie_FieldTerminalPath) ClearValue(item *TimeSerie) { 1021 if item != nil { 1022 switch fp.selector { 1023 case TimeSerie_FieldPathSelectorKey: 1024 item.Key = nil 1025 case TimeSerie_FieldPathSelectorProject: 1026 item.Project = "" 1027 case TimeSerie_FieldPathSelectorRegion: 1028 item.Region = "" 1029 case TimeSerie_FieldPathSelectorUnit: 1030 item.Unit = "" 1031 case TimeSerie_FieldPathSelectorMetric: 1032 item.Metric = nil 1033 case TimeSerie_FieldPathSelectorResource: 1034 item.Resource = nil 1035 case TimeSerie_FieldPathSelectorMetricKind: 1036 item.MetricKind = metric_descriptor.MetricDescriptor_METRIC_KIND_UNSPECIFIED 1037 case TimeSerie_FieldPathSelectorValueType: 1038 item.ValueType = metric_descriptor.MetricDescriptor_VALUE_TYPE_UNSPECIFIED 1039 case TimeSerie_FieldPathSelectorPoints: 1040 item.Points = nil 1041 default: 1042 panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fp.selector)) 1043 } 1044 } 1045 } 1046 1047 func (fp *TimeSerie_FieldTerminalPath) ClearValueRaw(item proto.Message) { 1048 fp.ClearValue(item.(*TimeSerie)) 1049 } 1050 1051 // IsLeaf - whether field path is holds simple value 1052 func (fp *TimeSerie_FieldTerminalPath) IsLeaf() bool { 1053 return fp.selector == TimeSerie_FieldPathSelectorKey || 1054 fp.selector == TimeSerie_FieldPathSelectorProject || 1055 fp.selector == TimeSerie_FieldPathSelectorRegion || 1056 fp.selector == TimeSerie_FieldPathSelectorUnit || 1057 fp.selector == TimeSerie_FieldPathSelectorMetricKind || 1058 fp.selector == TimeSerie_FieldPathSelectorValueType 1059 } 1060 1061 func (fp *TimeSerie_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath { 1062 return []gotenobject.FieldPath{fp} 1063 } 1064 1065 func (fp *TimeSerie_FieldTerminalPath) WithIValue(value interface{}) TimeSerie_FieldPathValue { 1066 switch fp.selector { 1067 case TimeSerie_FieldPathSelectorKey: 1068 return &TimeSerie_FieldTerminalPathValue{TimeSerie_FieldTerminalPath: *fp, value: value.([]byte)} 1069 case TimeSerie_FieldPathSelectorProject: 1070 return &TimeSerie_FieldTerminalPathValue{TimeSerie_FieldTerminalPath: *fp, value: value.(string)} 1071 case TimeSerie_FieldPathSelectorRegion: 1072 return &TimeSerie_FieldTerminalPathValue{TimeSerie_FieldTerminalPath: *fp, value: value.(string)} 1073 case TimeSerie_FieldPathSelectorUnit: 1074 return &TimeSerie_FieldTerminalPathValue{TimeSerie_FieldTerminalPath: *fp, value: value.(string)} 1075 case TimeSerie_FieldPathSelectorMetric: 1076 return &TimeSerie_FieldTerminalPathValue{TimeSerie_FieldTerminalPath: *fp, value: value.(*common.Metric)} 1077 case TimeSerie_FieldPathSelectorResource: 1078 return &TimeSerie_FieldTerminalPathValue{TimeSerie_FieldTerminalPath: *fp, value: value.(*common.MonitoredResource)} 1079 case TimeSerie_FieldPathSelectorMetricKind: 1080 return &TimeSerie_FieldTerminalPathValue{TimeSerie_FieldTerminalPath: *fp, value: value.(metric_descriptor.MetricDescriptor_MetricKind)} 1081 case TimeSerie_FieldPathSelectorValueType: 1082 return &TimeSerie_FieldTerminalPathValue{TimeSerie_FieldTerminalPath: *fp, value: value.(metric_descriptor.MetricDescriptor_ValueType)} 1083 case TimeSerie_FieldPathSelectorPoints: 1084 return &TimeSerie_FieldTerminalPathValue{TimeSerie_FieldTerminalPath: *fp, value: value.([]*Point)} 1085 default: 1086 panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fp.selector)) 1087 } 1088 } 1089 1090 func (fp *TimeSerie_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue { 1091 return fp.WithIValue(value) 1092 } 1093 1094 func (fp *TimeSerie_FieldTerminalPath) WithIArrayOfValues(values interface{}) TimeSerie_FieldPathArrayOfValues { 1095 fpaov := &TimeSerie_FieldTerminalPathArrayOfValues{TimeSerie_FieldTerminalPath: *fp} 1096 switch fp.selector { 1097 case TimeSerie_FieldPathSelectorKey: 1098 return &TimeSerie_FieldTerminalPathArrayOfValues{TimeSerie_FieldTerminalPath: *fp, values: values.([][]byte)} 1099 case TimeSerie_FieldPathSelectorProject: 1100 return &TimeSerie_FieldTerminalPathArrayOfValues{TimeSerie_FieldTerminalPath: *fp, values: values.([]string)} 1101 case TimeSerie_FieldPathSelectorRegion: 1102 return &TimeSerie_FieldTerminalPathArrayOfValues{TimeSerie_FieldTerminalPath: *fp, values: values.([]string)} 1103 case TimeSerie_FieldPathSelectorUnit: 1104 return &TimeSerie_FieldTerminalPathArrayOfValues{TimeSerie_FieldTerminalPath: *fp, values: values.([]string)} 1105 case TimeSerie_FieldPathSelectorMetric: 1106 return &TimeSerie_FieldTerminalPathArrayOfValues{TimeSerie_FieldTerminalPath: *fp, values: values.([]*common.Metric)} 1107 case TimeSerie_FieldPathSelectorResource: 1108 return &TimeSerie_FieldTerminalPathArrayOfValues{TimeSerie_FieldTerminalPath: *fp, values: values.([]*common.MonitoredResource)} 1109 case TimeSerie_FieldPathSelectorMetricKind: 1110 return &TimeSerie_FieldTerminalPathArrayOfValues{TimeSerie_FieldTerminalPath: *fp, values: values.([]metric_descriptor.MetricDescriptor_MetricKind)} 1111 case TimeSerie_FieldPathSelectorValueType: 1112 return &TimeSerie_FieldTerminalPathArrayOfValues{TimeSerie_FieldTerminalPath: *fp, values: values.([]metric_descriptor.MetricDescriptor_ValueType)} 1113 case TimeSerie_FieldPathSelectorPoints: 1114 return &TimeSerie_FieldTerminalPathArrayOfValues{TimeSerie_FieldTerminalPath: *fp, values: values.([][]*Point)} 1115 default: 1116 panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fp.selector)) 1117 } 1118 return fpaov 1119 } 1120 1121 func (fp *TimeSerie_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues { 1122 return fp.WithIArrayOfValues(values) 1123 } 1124 1125 func (fp *TimeSerie_FieldTerminalPath) WithIArrayItemValue(value interface{}) TimeSerie_FieldPathArrayItemValue { 1126 switch fp.selector { 1127 case TimeSerie_FieldPathSelectorPoints: 1128 return &TimeSerie_FieldTerminalPathArrayItemValue{TimeSerie_FieldTerminalPath: *fp, value: value.(*Point)} 1129 default: 1130 panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fp.selector)) 1131 } 1132 } 1133 1134 func (fp *TimeSerie_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue { 1135 return fp.WithIArrayItemValue(value) 1136 } 1137 1138 type TimeSerie_FieldSubPath struct { 1139 selector TimeSerie_FieldPathSelector 1140 subPath gotenobject.FieldPath 1141 } 1142 1143 var _ TimeSerie_FieldPath = (*TimeSerie_FieldSubPath)(nil) 1144 1145 func (fps *TimeSerie_FieldSubPath) Selector() TimeSerie_FieldPathSelector { 1146 return fps.selector 1147 } 1148 func (fps *TimeSerie_FieldSubPath) AsMetricSubPath() (common.Metric_FieldPath, bool) { 1149 res, ok := fps.subPath.(common.Metric_FieldPath) 1150 return res, ok 1151 } 1152 func (fps *TimeSerie_FieldSubPath) AsResourceSubPath() (common.MonitoredResource_FieldPath, bool) { 1153 res, ok := fps.subPath.(common.MonitoredResource_FieldPath) 1154 return res, ok 1155 } 1156 func (fps *TimeSerie_FieldSubPath) AsPointsSubPath() (Point_FieldPath, bool) { 1157 res, ok := fps.subPath.(Point_FieldPath) 1158 return res, ok 1159 } 1160 1161 // String returns path representation in proto convention 1162 func (fps *TimeSerie_FieldSubPath) String() string { 1163 return fps.selector.String() + "." + fps.subPath.String() 1164 } 1165 1166 // JSONString returns path representation is JSON convention 1167 func (fps *TimeSerie_FieldSubPath) JSONString() string { 1168 return strcase.ToLowerCamel(fps.selector.String()) + "." + fps.subPath.JSONString() 1169 } 1170 1171 // Get returns all values pointed by selected field from source TimeSerie 1172 func (fps *TimeSerie_FieldSubPath) Get(source *TimeSerie) (values []interface{}) { 1173 switch fps.selector { 1174 case TimeSerie_FieldPathSelectorMetric: 1175 values = append(values, fps.subPath.GetRaw(source.GetMetric())...) 1176 case TimeSerie_FieldPathSelectorResource: 1177 values = append(values, fps.subPath.GetRaw(source.GetResource())...) 1178 case TimeSerie_FieldPathSelectorPoints: 1179 for _, item := range source.GetPoints() { 1180 values = append(values, fps.subPath.GetRaw(item)...) 1181 } 1182 default: 1183 panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fps.selector)) 1184 } 1185 return 1186 } 1187 1188 func (fps *TimeSerie_FieldSubPath) GetRaw(source proto.Message) []interface{} { 1189 return fps.Get(source.(*TimeSerie)) 1190 } 1191 1192 // GetSingle returns value of selected field from source TimeSerie 1193 func (fps *TimeSerie_FieldSubPath) GetSingle(source *TimeSerie) (interface{}, bool) { 1194 switch fps.selector { 1195 case TimeSerie_FieldPathSelectorMetric: 1196 if source.GetMetric() == nil { 1197 return nil, false 1198 } 1199 return fps.subPath.GetSingleRaw(source.GetMetric()) 1200 case TimeSerie_FieldPathSelectorResource: 1201 if source.GetResource() == nil { 1202 return nil, false 1203 } 1204 return fps.subPath.GetSingleRaw(source.GetResource()) 1205 case TimeSerie_FieldPathSelectorPoints: 1206 if len(source.GetPoints()) == 0 { 1207 return nil, false 1208 } 1209 return fps.subPath.GetSingleRaw(source.GetPoints()[0]) 1210 default: 1211 panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fps.selector)) 1212 } 1213 } 1214 1215 func (fps *TimeSerie_FieldSubPath) GetSingleRaw(source proto.Message) (interface{}, bool) { 1216 return fps.GetSingle(source.(*TimeSerie)) 1217 } 1218 1219 // GetDefault returns a default value of the field type 1220 func (fps *TimeSerie_FieldSubPath) GetDefault() interface{} { 1221 return fps.subPath.GetDefault() 1222 } 1223 1224 func (fps *TimeSerie_FieldSubPath) ClearValue(item *TimeSerie) { 1225 if item != nil { 1226 switch fps.selector { 1227 case TimeSerie_FieldPathSelectorMetric: 1228 fps.subPath.ClearValueRaw(item.Metric) 1229 case TimeSerie_FieldPathSelectorResource: 1230 fps.subPath.ClearValueRaw(item.Resource) 1231 case TimeSerie_FieldPathSelectorPoints: 1232 for _, subItem := range item.Points { 1233 fps.subPath.ClearValueRaw(subItem) 1234 } 1235 default: 1236 panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fps.selector)) 1237 } 1238 } 1239 } 1240 1241 func (fps *TimeSerie_FieldSubPath) ClearValueRaw(item proto.Message) { 1242 fps.ClearValue(item.(*TimeSerie)) 1243 } 1244 1245 // IsLeaf - whether field path is holds simple value 1246 func (fps *TimeSerie_FieldSubPath) IsLeaf() bool { 1247 return fps.subPath.IsLeaf() 1248 } 1249 1250 func (fps *TimeSerie_FieldSubPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath { 1251 iPaths := []gotenobject.FieldPath{&TimeSerie_FieldTerminalPath{selector: fps.selector}} 1252 iPaths = append(iPaths, fps.subPath.SplitIntoTerminalIPaths()...) 1253 return iPaths 1254 } 1255 1256 func (fps *TimeSerie_FieldSubPath) WithIValue(value interface{}) TimeSerie_FieldPathValue { 1257 return &TimeSerie_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)} 1258 } 1259 1260 func (fps *TimeSerie_FieldSubPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue { 1261 return fps.WithIValue(value) 1262 } 1263 1264 func (fps *TimeSerie_FieldSubPath) WithIArrayOfValues(values interface{}) TimeSerie_FieldPathArrayOfValues { 1265 return &TimeSerie_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)} 1266 } 1267 1268 func (fps *TimeSerie_FieldSubPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues { 1269 return fps.WithIArrayOfValues(values) 1270 } 1271 1272 func (fps *TimeSerie_FieldSubPath) WithIArrayItemValue(value interface{}) TimeSerie_FieldPathArrayItemValue { 1273 return &TimeSerie_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)} 1274 } 1275 1276 func (fps *TimeSerie_FieldSubPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue { 1277 return fps.WithIArrayItemValue(value) 1278 } 1279 1280 // TimeSerie_FieldPathValue allows storing values for TimeSerie fields according to their type 1281 type TimeSerie_FieldPathValue interface { 1282 TimeSerie_FieldPath 1283 gotenobject.FieldPathValue 1284 SetTo(target **TimeSerie) 1285 CompareWith(*TimeSerie) (cmp int, comparable bool) 1286 } 1287 1288 func ParseTimeSerie_FieldPathValue(pathStr, valueStr string) (TimeSerie_FieldPathValue, error) { 1289 fp, err := ParseTimeSerie_FieldPath(pathStr) 1290 if err != nil { 1291 return nil, err 1292 } 1293 fpv, err := gotenobject.ParseFieldPathValue(fp, valueStr) 1294 if err != nil { 1295 return nil, status.Errorf(codes.InvalidArgument, "error parsing TimeSerie field path value from %s: %v", valueStr, err) 1296 } 1297 return fpv.(TimeSerie_FieldPathValue), nil 1298 } 1299 1300 func MustParseTimeSerie_FieldPathValue(pathStr, valueStr string) TimeSerie_FieldPathValue { 1301 fpv, err := ParseTimeSerie_FieldPathValue(pathStr, valueStr) 1302 if err != nil { 1303 panic(err) 1304 } 1305 return fpv 1306 } 1307 1308 type TimeSerie_FieldTerminalPathValue struct { 1309 TimeSerie_FieldTerminalPath 1310 value interface{} 1311 } 1312 1313 var _ TimeSerie_FieldPathValue = (*TimeSerie_FieldTerminalPathValue)(nil) 1314 1315 // GetRawValue returns raw value stored under selected path for 'TimeSerie' as interface{} 1316 func (fpv *TimeSerie_FieldTerminalPathValue) GetRawValue() interface{} { 1317 return fpv.value 1318 } 1319 func (fpv *TimeSerie_FieldTerminalPathValue) AsKeyValue() ([]byte, bool) { 1320 res, ok := fpv.value.([]byte) 1321 return res, ok 1322 } 1323 func (fpv *TimeSerie_FieldTerminalPathValue) AsProjectValue() (string, bool) { 1324 res, ok := fpv.value.(string) 1325 return res, ok 1326 } 1327 func (fpv *TimeSerie_FieldTerminalPathValue) AsRegionValue() (string, bool) { 1328 res, ok := fpv.value.(string) 1329 return res, ok 1330 } 1331 func (fpv *TimeSerie_FieldTerminalPathValue) AsUnitValue() (string, bool) { 1332 res, ok := fpv.value.(string) 1333 return res, ok 1334 } 1335 func (fpv *TimeSerie_FieldTerminalPathValue) AsMetricValue() (*common.Metric, bool) { 1336 res, ok := fpv.value.(*common.Metric) 1337 return res, ok 1338 } 1339 func (fpv *TimeSerie_FieldTerminalPathValue) AsResourceValue() (*common.MonitoredResource, bool) { 1340 res, ok := fpv.value.(*common.MonitoredResource) 1341 return res, ok 1342 } 1343 func (fpv *TimeSerie_FieldTerminalPathValue) AsMetricKindValue() (metric_descriptor.MetricDescriptor_MetricKind, bool) { 1344 res, ok := fpv.value.(metric_descriptor.MetricDescriptor_MetricKind) 1345 return res, ok 1346 } 1347 func (fpv *TimeSerie_FieldTerminalPathValue) AsValueTypeValue() (metric_descriptor.MetricDescriptor_ValueType, bool) { 1348 res, ok := fpv.value.(metric_descriptor.MetricDescriptor_ValueType) 1349 return res, ok 1350 } 1351 func (fpv *TimeSerie_FieldTerminalPathValue) AsPointsValue() ([]*Point, bool) { 1352 res, ok := fpv.value.([]*Point) 1353 return res, ok 1354 } 1355 1356 // SetTo stores value for selected field for object TimeSerie 1357 func (fpv *TimeSerie_FieldTerminalPathValue) SetTo(target **TimeSerie) { 1358 if *target == nil { 1359 *target = new(TimeSerie) 1360 } 1361 switch fpv.selector { 1362 case TimeSerie_FieldPathSelectorKey: 1363 (*target).Key = fpv.value.([]byte) 1364 case TimeSerie_FieldPathSelectorProject: 1365 (*target).Project = fpv.value.(string) 1366 case TimeSerie_FieldPathSelectorRegion: 1367 (*target).Region = fpv.value.(string) 1368 case TimeSerie_FieldPathSelectorUnit: 1369 (*target).Unit = fpv.value.(string) 1370 case TimeSerie_FieldPathSelectorMetric: 1371 (*target).Metric = fpv.value.(*common.Metric) 1372 case TimeSerie_FieldPathSelectorResource: 1373 (*target).Resource = fpv.value.(*common.MonitoredResource) 1374 case TimeSerie_FieldPathSelectorMetricKind: 1375 (*target).MetricKind = fpv.value.(metric_descriptor.MetricDescriptor_MetricKind) 1376 case TimeSerie_FieldPathSelectorValueType: 1377 (*target).ValueType = fpv.value.(metric_descriptor.MetricDescriptor_ValueType) 1378 case TimeSerie_FieldPathSelectorPoints: 1379 (*target).Points = fpv.value.([]*Point) 1380 default: 1381 panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fpv.selector)) 1382 } 1383 } 1384 1385 func (fpv *TimeSerie_FieldTerminalPathValue) SetToRaw(target proto.Message) { 1386 typedObject := target.(*TimeSerie) 1387 fpv.SetTo(&typedObject) 1388 } 1389 1390 // CompareWith compares value in the 'TimeSerie_FieldTerminalPathValue' with the value under path in 'TimeSerie'. 1391 func (fpv *TimeSerie_FieldTerminalPathValue) CompareWith(source *TimeSerie) (int, bool) { 1392 switch fpv.selector { 1393 case TimeSerie_FieldPathSelectorKey: 1394 return 0, false 1395 case TimeSerie_FieldPathSelectorProject: 1396 leftValue := fpv.value.(string) 1397 rightValue := source.GetProject() 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_FieldPathSelectorRegion: 1406 leftValue := fpv.value.(string) 1407 rightValue := source.GetRegion() 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_FieldPathSelectorUnit: 1416 leftValue := fpv.value.(string) 1417 rightValue := source.GetUnit() 1418 if (leftValue) == (rightValue) { 1419 return 0, true 1420 } else if (leftValue) < (rightValue) { 1421 return -1, true 1422 } else { 1423 return 1, true 1424 } 1425 case TimeSerie_FieldPathSelectorMetric: 1426 return 0, false 1427 case TimeSerie_FieldPathSelectorResource: 1428 return 0, false 1429 case TimeSerie_FieldPathSelectorMetricKind: 1430 leftValue := fpv.value.(metric_descriptor.MetricDescriptor_MetricKind) 1431 rightValue := source.GetMetricKind() 1432 if (leftValue) == (rightValue) { 1433 return 0, true 1434 } else if (leftValue) < (rightValue) { 1435 return -1, true 1436 } else { 1437 return 1, true 1438 } 1439 case TimeSerie_FieldPathSelectorValueType: 1440 leftValue := fpv.value.(metric_descriptor.MetricDescriptor_ValueType) 1441 rightValue := source.GetValueType() 1442 if (leftValue) == (rightValue) { 1443 return 0, true 1444 } else if (leftValue) < (rightValue) { 1445 return -1, true 1446 } else { 1447 return 1, true 1448 } 1449 case TimeSerie_FieldPathSelectorPoints: 1450 return 0, false 1451 default: 1452 panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fpv.selector)) 1453 } 1454 } 1455 1456 func (fpv *TimeSerie_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) { 1457 return fpv.CompareWith(source.(*TimeSerie)) 1458 } 1459 1460 type TimeSerie_FieldSubPathValue struct { 1461 TimeSerie_FieldPath 1462 subPathValue gotenobject.FieldPathValue 1463 } 1464 1465 var _ TimeSerie_FieldPathValue = (*TimeSerie_FieldSubPathValue)(nil) 1466 1467 func (fpvs *TimeSerie_FieldSubPathValue) AsMetricPathValue() (common.Metric_FieldPathValue, bool) { 1468 res, ok := fpvs.subPathValue.(common.Metric_FieldPathValue) 1469 return res, ok 1470 } 1471 func (fpvs *TimeSerie_FieldSubPathValue) AsResourcePathValue() (common.MonitoredResource_FieldPathValue, bool) { 1472 res, ok := fpvs.subPathValue.(common.MonitoredResource_FieldPathValue) 1473 return res, ok 1474 } 1475 func (fpvs *TimeSerie_FieldSubPathValue) AsPointsPathValue() (Point_FieldPathValue, bool) { 1476 res, ok := fpvs.subPathValue.(Point_FieldPathValue) 1477 return res, ok 1478 } 1479 1480 func (fpvs *TimeSerie_FieldSubPathValue) SetTo(target **TimeSerie) { 1481 if *target == nil { 1482 *target = new(TimeSerie) 1483 } 1484 switch fpvs.Selector() { 1485 case TimeSerie_FieldPathSelectorMetric: 1486 fpvs.subPathValue.(common.Metric_FieldPathValue).SetTo(&(*target).Metric) 1487 case TimeSerie_FieldPathSelectorResource: 1488 fpvs.subPathValue.(common.MonitoredResource_FieldPathValue).SetTo(&(*target).Resource) 1489 case TimeSerie_FieldPathSelectorPoints: 1490 panic("FieldPath setter is unsupported for array subpaths") 1491 default: 1492 panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fpvs.Selector())) 1493 } 1494 } 1495 1496 func (fpvs *TimeSerie_FieldSubPathValue) SetToRaw(target proto.Message) { 1497 typedObject := target.(*TimeSerie) 1498 fpvs.SetTo(&typedObject) 1499 } 1500 1501 func (fpvs *TimeSerie_FieldSubPathValue) GetRawValue() interface{} { 1502 return fpvs.subPathValue.GetRawValue() 1503 } 1504 1505 func (fpvs *TimeSerie_FieldSubPathValue) CompareWith(source *TimeSerie) (int, bool) { 1506 switch fpvs.Selector() { 1507 case TimeSerie_FieldPathSelectorMetric: 1508 return fpvs.subPathValue.(common.Metric_FieldPathValue).CompareWith(source.GetMetric()) 1509 case TimeSerie_FieldPathSelectorResource: 1510 return fpvs.subPathValue.(common.MonitoredResource_FieldPathValue).CompareWith(source.GetResource()) 1511 case TimeSerie_FieldPathSelectorPoints: 1512 return 0, false // repeated field 1513 default: 1514 panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fpvs.Selector())) 1515 } 1516 } 1517 1518 func (fpvs *TimeSerie_FieldSubPathValue) CompareWithRaw(source proto.Message) (int, bool) { 1519 return fpvs.CompareWith(source.(*TimeSerie)) 1520 } 1521 1522 // TimeSerie_FieldPathArrayItemValue allows storing single item in Path-specific values for TimeSerie according to their type 1523 // Present only for array (repeated) types. 1524 type TimeSerie_FieldPathArrayItemValue interface { 1525 gotenobject.FieldPathArrayItemValue 1526 TimeSerie_FieldPath 1527 ContainsValue(*TimeSerie) bool 1528 } 1529 1530 // ParseTimeSerie_FieldPathArrayItemValue parses string and JSON-encoded value to its Value 1531 func ParseTimeSerie_FieldPathArrayItemValue(pathStr, valueStr string) (TimeSerie_FieldPathArrayItemValue, error) { 1532 fp, err := ParseTimeSerie_FieldPath(pathStr) 1533 if err != nil { 1534 return nil, err 1535 } 1536 fpaiv, err := gotenobject.ParseFieldPathArrayItemValue(fp, valueStr) 1537 if err != nil { 1538 return nil, status.Errorf(codes.InvalidArgument, "error parsing TimeSerie field path array item value from %s: %v", valueStr, err) 1539 } 1540 return fpaiv.(TimeSerie_FieldPathArrayItemValue), nil 1541 } 1542 1543 func MustParseTimeSerie_FieldPathArrayItemValue(pathStr, valueStr string) TimeSerie_FieldPathArrayItemValue { 1544 fpaiv, err := ParseTimeSerie_FieldPathArrayItemValue(pathStr, valueStr) 1545 if err != nil { 1546 panic(err) 1547 } 1548 return fpaiv 1549 } 1550 1551 type TimeSerie_FieldTerminalPathArrayItemValue struct { 1552 TimeSerie_FieldTerminalPath 1553 value interface{} 1554 } 1555 1556 var _ TimeSerie_FieldPathArrayItemValue = (*TimeSerie_FieldTerminalPathArrayItemValue)(nil) 1557 1558 // GetRawValue returns stored element value for array in object TimeSerie as interface{} 1559 func (fpaiv *TimeSerie_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} { 1560 return fpaiv.value 1561 } 1562 func (fpaiv *TimeSerie_FieldTerminalPathArrayItemValue) AsPointsItemValue() (*Point, bool) { 1563 res, ok := fpaiv.value.(*Point) 1564 return res, ok 1565 } 1566 1567 func (fpaiv *TimeSerie_FieldTerminalPathArrayItemValue) GetSingle(source *TimeSerie) (interface{}, bool) { 1568 return nil, false 1569 } 1570 1571 func (fpaiv *TimeSerie_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) { 1572 return fpaiv.GetSingle(source.(*TimeSerie)) 1573 } 1574 1575 // Contains returns a boolean indicating if value that is being held is present in given 'TimeSerie' 1576 func (fpaiv *TimeSerie_FieldTerminalPathArrayItemValue) ContainsValue(source *TimeSerie) bool { 1577 slice := fpaiv.TimeSerie_FieldTerminalPath.Get(source) 1578 for _, v := range slice { 1579 if asProtoMsg, ok := fpaiv.value.(proto.Message); ok { 1580 if proto.Equal(asProtoMsg, v.(proto.Message)) { 1581 return true 1582 } 1583 } else if reflect.DeepEqual(v, fpaiv.value) { 1584 return true 1585 } 1586 } 1587 return false 1588 } 1589 1590 type TimeSerie_FieldSubPathArrayItemValue struct { 1591 TimeSerie_FieldPath 1592 subPathItemValue gotenobject.FieldPathArrayItemValue 1593 } 1594 1595 // GetRawValue returns stored array item value 1596 func (fpaivs *TimeSerie_FieldSubPathArrayItemValue) GetRawItemValue() interface{} { 1597 return fpaivs.subPathItemValue.GetRawItemValue() 1598 } 1599 func (fpaivs *TimeSerie_FieldSubPathArrayItemValue) AsMetricPathItemValue() (common.Metric_FieldPathArrayItemValue, bool) { 1600 res, ok := fpaivs.subPathItemValue.(common.Metric_FieldPathArrayItemValue) 1601 return res, ok 1602 } 1603 func (fpaivs *TimeSerie_FieldSubPathArrayItemValue) AsResourcePathItemValue() (common.MonitoredResource_FieldPathArrayItemValue, bool) { 1604 res, ok := fpaivs.subPathItemValue.(common.MonitoredResource_FieldPathArrayItemValue) 1605 return res, ok 1606 } 1607 func (fpaivs *TimeSerie_FieldSubPathArrayItemValue) AsPointsPathItemValue() (Point_FieldPathArrayItemValue, bool) { 1608 res, ok := fpaivs.subPathItemValue.(Point_FieldPathArrayItemValue) 1609 return res, ok 1610 } 1611 1612 // Contains returns a boolean indicating if value that is being held is present in given 'TimeSerie' 1613 func (fpaivs *TimeSerie_FieldSubPathArrayItemValue) ContainsValue(source *TimeSerie) bool { 1614 switch fpaivs.Selector() { 1615 case TimeSerie_FieldPathSelectorMetric: 1616 return fpaivs.subPathItemValue.(common.Metric_FieldPathArrayItemValue).ContainsValue(source.GetMetric()) 1617 case TimeSerie_FieldPathSelectorResource: 1618 return fpaivs.subPathItemValue.(common.MonitoredResource_FieldPathArrayItemValue).ContainsValue(source.GetResource()) 1619 case TimeSerie_FieldPathSelectorPoints: 1620 return false // repeated/map field 1621 default: 1622 panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fpaivs.Selector())) 1623 } 1624 } 1625 1626 // TimeSerie_FieldPathArrayOfValues allows storing slice of values for TimeSerie fields according to their type 1627 type TimeSerie_FieldPathArrayOfValues interface { 1628 gotenobject.FieldPathArrayOfValues 1629 TimeSerie_FieldPath 1630 } 1631 1632 func ParseTimeSerie_FieldPathArrayOfValues(pathStr, valuesStr string) (TimeSerie_FieldPathArrayOfValues, error) { 1633 fp, err := ParseTimeSerie_FieldPath(pathStr) 1634 if err != nil { 1635 return nil, err 1636 } 1637 fpaov, err := gotenobject.ParseFieldPathArrayOfValues(fp, valuesStr) 1638 if err != nil { 1639 return nil, status.Errorf(codes.InvalidArgument, "error parsing TimeSerie field path array of values from %s: %v", valuesStr, err) 1640 } 1641 return fpaov.(TimeSerie_FieldPathArrayOfValues), nil 1642 } 1643 1644 func MustParseTimeSerie_FieldPathArrayOfValues(pathStr, valuesStr string) TimeSerie_FieldPathArrayOfValues { 1645 fpaov, err := ParseTimeSerie_FieldPathArrayOfValues(pathStr, valuesStr) 1646 if err != nil { 1647 panic(err) 1648 } 1649 return fpaov 1650 } 1651 1652 type TimeSerie_FieldTerminalPathArrayOfValues struct { 1653 TimeSerie_FieldTerminalPath 1654 values interface{} 1655 } 1656 1657 var _ TimeSerie_FieldPathArrayOfValues = (*TimeSerie_FieldTerminalPathArrayOfValues)(nil) 1658 1659 func (fpaov *TimeSerie_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) { 1660 switch fpaov.selector { 1661 case TimeSerie_FieldPathSelectorKey: 1662 for _, v := range fpaov.values.([][]byte) { 1663 values = append(values, v) 1664 } 1665 case TimeSerie_FieldPathSelectorProject: 1666 for _, v := range fpaov.values.([]string) { 1667 values = append(values, v) 1668 } 1669 case TimeSerie_FieldPathSelectorRegion: 1670 for _, v := range fpaov.values.([]string) { 1671 values = append(values, v) 1672 } 1673 case TimeSerie_FieldPathSelectorUnit: 1674 for _, v := range fpaov.values.([]string) { 1675 values = append(values, v) 1676 } 1677 case TimeSerie_FieldPathSelectorMetric: 1678 for _, v := range fpaov.values.([]*common.Metric) { 1679 values = append(values, v) 1680 } 1681 case TimeSerie_FieldPathSelectorResource: 1682 for _, v := range fpaov.values.([]*common.MonitoredResource) { 1683 values = append(values, v) 1684 } 1685 case TimeSerie_FieldPathSelectorMetricKind: 1686 for _, v := range fpaov.values.([]metric_descriptor.MetricDescriptor_MetricKind) { 1687 values = append(values, v) 1688 } 1689 case TimeSerie_FieldPathSelectorValueType: 1690 for _, v := range fpaov.values.([]metric_descriptor.MetricDescriptor_ValueType) { 1691 values = append(values, v) 1692 } 1693 case TimeSerie_FieldPathSelectorPoints: 1694 for _, v := range fpaov.values.([][]*Point) { 1695 values = append(values, v) 1696 } 1697 } 1698 return 1699 } 1700 func (fpaov *TimeSerie_FieldTerminalPathArrayOfValues) AsKeyArrayOfValues() ([][]byte, bool) { 1701 res, ok := fpaov.values.([][]byte) 1702 return res, ok 1703 } 1704 func (fpaov *TimeSerie_FieldTerminalPathArrayOfValues) AsProjectArrayOfValues() ([]string, bool) { 1705 res, ok := fpaov.values.([]string) 1706 return res, ok 1707 } 1708 func (fpaov *TimeSerie_FieldTerminalPathArrayOfValues) AsRegionArrayOfValues() ([]string, bool) { 1709 res, ok := fpaov.values.([]string) 1710 return res, ok 1711 } 1712 func (fpaov *TimeSerie_FieldTerminalPathArrayOfValues) AsUnitArrayOfValues() ([]string, bool) { 1713 res, ok := fpaov.values.([]string) 1714 return res, ok 1715 } 1716 func (fpaov *TimeSerie_FieldTerminalPathArrayOfValues) AsMetricArrayOfValues() ([]*common.Metric, bool) { 1717 res, ok := fpaov.values.([]*common.Metric) 1718 return res, ok 1719 } 1720 func (fpaov *TimeSerie_FieldTerminalPathArrayOfValues) AsResourceArrayOfValues() ([]*common.MonitoredResource, bool) { 1721 res, ok := fpaov.values.([]*common.MonitoredResource) 1722 return res, ok 1723 } 1724 func (fpaov *TimeSerie_FieldTerminalPathArrayOfValues) AsMetricKindArrayOfValues() ([]metric_descriptor.MetricDescriptor_MetricKind, bool) { 1725 res, ok := fpaov.values.([]metric_descriptor.MetricDescriptor_MetricKind) 1726 return res, ok 1727 } 1728 func (fpaov *TimeSerie_FieldTerminalPathArrayOfValues) AsValueTypeArrayOfValues() ([]metric_descriptor.MetricDescriptor_ValueType, bool) { 1729 res, ok := fpaov.values.([]metric_descriptor.MetricDescriptor_ValueType) 1730 return res, ok 1731 } 1732 func (fpaov *TimeSerie_FieldTerminalPathArrayOfValues) AsPointsArrayOfValues() ([][]*Point, bool) { 1733 res, ok := fpaov.values.([][]*Point) 1734 return res, ok 1735 } 1736 1737 type TimeSerie_FieldSubPathArrayOfValues struct { 1738 TimeSerie_FieldPath 1739 subPathArrayOfValues gotenobject.FieldPathArrayOfValues 1740 } 1741 1742 var _ TimeSerie_FieldPathArrayOfValues = (*TimeSerie_FieldSubPathArrayOfValues)(nil) 1743 1744 func (fpsaov *TimeSerie_FieldSubPathArrayOfValues) GetRawValues() []interface{} { 1745 return fpsaov.subPathArrayOfValues.GetRawValues() 1746 } 1747 func (fpsaov *TimeSerie_FieldSubPathArrayOfValues) AsMetricPathArrayOfValues() (common.Metric_FieldPathArrayOfValues, bool) { 1748 res, ok := fpsaov.subPathArrayOfValues.(common.Metric_FieldPathArrayOfValues) 1749 return res, ok 1750 } 1751 func (fpsaov *TimeSerie_FieldSubPathArrayOfValues) AsResourcePathArrayOfValues() (common.MonitoredResource_FieldPathArrayOfValues, bool) { 1752 res, ok := fpsaov.subPathArrayOfValues.(common.MonitoredResource_FieldPathArrayOfValues) 1753 return res, ok 1754 } 1755 func (fpsaov *TimeSerie_FieldSubPathArrayOfValues) AsPointsPathArrayOfValues() (Point_FieldPathArrayOfValues, bool) { 1756 res, ok := fpsaov.subPathArrayOfValues.(Point_FieldPathArrayOfValues) 1757 return res, ok 1758 } 1759 1760 // FieldPath provides implementation to handle 1761 // https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto 1762 type BulkTimeSeries_FieldPath interface { 1763 gotenobject.FieldPath 1764 Selector() BulkTimeSeries_FieldPathSelector 1765 Get(source *BulkTimeSeries) []interface{} 1766 GetSingle(source *BulkTimeSeries) (interface{}, bool) 1767 ClearValue(item *BulkTimeSeries) 1768 1769 // Those methods build corresponding BulkTimeSeries_FieldPathValue 1770 // (or array of values) and holds passed value. Panics if injected type is incorrect. 1771 WithIValue(value interface{}) BulkTimeSeries_FieldPathValue 1772 WithIArrayOfValues(values interface{}) BulkTimeSeries_FieldPathArrayOfValues 1773 WithIArrayItemValue(value interface{}) BulkTimeSeries_FieldPathArrayItemValue 1774 } 1775 1776 type BulkTimeSeries_FieldPathSelector int32 1777 1778 const ( 1779 BulkTimeSeries_FieldPathSelectorTimeSeries BulkTimeSeries_FieldPathSelector = 0 1780 BulkTimeSeries_FieldPathSelectorPhantomFlag BulkTimeSeries_FieldPathSelector = 1 1781 ) 1782 1783 func (s BulkTimeSeries_FieldPathSelector) String() string { 1784 switch s { 1785 case BulkTimeSeries_FieldPathSelectorTimeSeries: 1786 return "time_series" 1787 case BulkTimeSeries_FieldPathSelectorPhantomFlag: 1788 return "phantom_flag" 1789 default: 1790 panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", s)) 1791 } 1792 } 1793 1794 func BuildBulkTimeSeries_FieldPath(fp gotenobject.RawFieldPath) (BulkTimeSeries_FieldPath, error) { 1795 if len(fp) == 0 { 1796 return nil, status.Error(codes.InvalidArgument, "empty field path for object BulkTimeSeries") 1797 } 1798 if len(fp) == 1 { 1799 switch fp[0] { 1800 case "time_series", "timeSeries", "time-series": 1801 return &BulkTimeSeries_FieldTerminalPath{selector: BulkTimeSeries_FieldPathSelectorTimeSeries}, nil 1802 case "phantom_flag", "phantomFlag", "phantom-flag": 1803 return &BulkTimeSeries_FieldTerminalPath{selector: BulkTimeSeries_FieldPathSelectorPhantomFlag}, nil 1804 } 1805 } else { 1806 switch fp[0] { 1807 case "time_series", "timeSeries", "time-series": 1808 if subpath, err := BuildTimeSerie_FieldPath(fp[1:]); err != nil { 1809 return nil, err 1810 } else { 1811 return &BulkTimeSeries_FieldSubPath{selector: BulkTimeSeries_FieldPathSelectorTimeSeries, subPath: subpath}, nil 1812 } 1813 } 1814 } 1815 return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object BulkTimeSeries", fp) 1816 } 1817 1818 func ParseBulkTimeSeries_FieldPath(rawField string) (BulkTimeSeries_FieldPath, error) { 1819 fp, err := gotenobject.ParseRawFieldPath(rawField) 1820 if err != nil { 1821 return nil, err 1822 } 1823 return BuildBulkTimeSeries_FieldPath(fp) 1824 } 1825 1826 func MustParseBulkTimeSeries_FieldPath(rawField string) BulkTimeSeries_FieldPath { 1827 fp, err := ParseBulkTimeSeries_FieldPath(rawField) 1828 if err != nil { 1829 panic(err) 1830 } 1831 return fp 1832 } 1833 1834 type BulkTimeSeries_FieldTerminalPath struct { 1835 selector BulkTimeSeries_FieldPathSelector 1836 } 1837 1838 var _ BulkTimeSeries_FieldPath = (*BulkTimeSeries_FieldTerminalPath)(nil) 1839 1840 func (fp *BulkTimeSeries_FieldTerminalPath) Selector() BulkTimeSeries_FieldPathSelector { 1841 return fp.selector 1842 } 1843 1844 // String returns path representation in proto convention 1845 func (fp *BulkTimeSeries_FieldTerminalPath) String() string { 1846 return fp.selector.String() 1847 } 1848 1849 // JSONString returns path representation is JSON convention 1850 func (fp *BulkTimeSeries_FieldTerminalPath) JSONString() string { 1851 return strcase.ToLowerCamel(fp.String()) 1852 } 1853 1854 // Get returns all values pointed by specific field from source BulkTimeSeries 1855 func (fp *BulkTimeSeries_FieldTerminalPath) Get(source *BulkTimeSeries) (values []interface{}) { 1856 if source != nil { 1857 switch fp.selector { 1858 case BulkTimeSeries_FieldPathSelectorTimeSeries: 1859 for _, value := range source.GetTimeSeries() { 1860 values = append(values, value) 1861 } 1862 case BulkTimeSeries_FieldPathSelectorPhantomFlag: 1863 values = append(values, source.PhantomFlag) 1864 default: 1865 panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fp.selector)) 1866 } 1867 } 1868 return 1869 } 1870 1871 func (fp *BulkTimeSeries_FieldTerminalPath) GetRaw(source proto.Message) []interface{} { 1872 return fp.Get(source.(*BulkTimeSeries)) 1873 } 1874 1875 // GetSingle returns value pointed by specific field of from source BulkTimeSeries 1876 func (fp *BulkTimeSeries_FieldTerminalPath) GetSingle(source *BulkTimeSeries) (interface{}, bool) { 1877 switch fp.selector { 1878 case BulkTimeSeries_FieldPathSelectorTimeSeries: 1879 res := source.GetTimeSeries() 1880 return res, res != nil 1881 case BulkTimeSeries_FieldPathSelectorPhantomFlag: 1882 return source.GetPhantomFlag(), source != nil 1883 default: 1884 panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fp.selector)) 1885 } 1886 } 1887 1888 func (fp *BulkTimeSeries_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) { 1889 return fp.GetSingle(source.(*BulkTimeSeries)) 1890 } 1891 1892 // GetDefault returns a default value of the field type 1893 func (fp *BulkTimeSeries_FieldTerminalPath) GetDefault() interface{} { 1894 switch fp.selector { 1895 case BulkTimeSeries_FieldPathSelectorTimeSeries: 1896 return ([]*TimeSerie)(nil) 1897 case BulkTimeSeries_FieldPathSelectorPhantomFlag: 1898 return false 1899 default: 1900 panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fp.selector)) 1901 } 1902 } 1903 1904 func (fp *BulkTimeSeries_FieldTerminalPath) ClearValue(item *BulkTimeSeries) { 1905 if item != nil { 1906 switch fp.selector { 1907 case BulkTimeSeries_FieldPathSelectorTimeSeries: 1908 item.TimeSeries = nil 1909 case BulkTimeSeries_FieldPathSelectorPhantomFlag: 1910 item.PhantomFlag = false 1911 default: 1912 panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fp.selector)) 1913 } 1914 } 1915 } 1916 1917 func (fp *BulkTimeSeries_FieldTerminalPath) ClearValueRaw(item proto.Message) { 1918 fp.ClearValue(item.(*BulkTimeSeries)) 1919 } 1920 1921 // IsLeaf - whether field path is holds simple value 1922 func (fp *BulkTimeSeries_FieldTerminalPath) IsLeaf() bool { 1923 return fp.selector == BulkTimeSeries_FieldPathSelectorPhantomFlag 1924 } 1925 1926 func (fp *BulkTimeSeries_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath { 1927 return []gotenobject.FieldPath{fp} 1928 } 1929 1930 func (fp *BulkTimeSeries_FieldTerminalPath) WithIValue(value interface{}) BulkTimeSeries_FieldPathValue { 1931 switch fp.selector { 1932 case BulkTimeSeries_FieldPathSelectorTimeSeries: 1933 return &BulkTimeSeries_FieldTerminalPathValue{BulkTimeSeries_FieldTerminalPath: *fp, value: value.([]*TimeSerie)} 1934 case BulkTimeSeries_FieldPathSelectorPhantomFlag: 1935 return &BulkTimeSeries_FieldTerminalPathValue{BulkTimeSeries_FieldTerminalPath: *fp, value: value.(bool)} 1936 default: 1937 panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fp.selector)) 1938 } 1939 } 1940 1941 func (fp *BulkTimeSeries_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue { 1942 return fp.WithIValue(value) 1943 } 1944 1945 func (fp *BulkTimeSeries_FieldTerminalPath) WithIArrayOfValues(values interface{}) BulkTimeSeries_FieldPathArrayOfValues { 1946 fpaov := &BulkTimeSeries_FieldTerminalPathArrayOfValues{BulkTimeSeries_FieldTerminalPath: *fp} 1947 switch fp.selector { 1948 case BulkTimeSeries_FieldPathSelectorTimeSeries: 1949 return &BulkTimeSeries_FieldTerminalPathArrayOfValues{BulkTimeSeries_FieldTerminalPath: *fp, values: values.([][]*TimeSerie)} 1950 case BulkTimeSeries_FieldPathSelectorPhantomFlag: 1951 return &BulkTimeSeries_FieldTerminalPathArrayOfValues{BulkTimeSeries_FieldTerminalPath: *fp, values: values.([]bool)} 1952 default: 1953 panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fp.selector)) 1954 } 1955 return fpaov 1956 } 1957 1958 func (fp *BulkTimeSeries_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues { 1959 return fp.WithIArrayOfValues(values) 1960 } 1961 1962 func (fp *BulkTimeSeries_FieldTerminalPath) WithIArrayItemValue(value interface{}) BulkTimeSeries_FieldPathArrayItemValue { 1963 switch fp.selector { 1964 case BulkTimeSeries_FieldPathSelectorTimeSeries: 1965 return &BulkTimeSeries_FieldTerminalPathArrayItemValue{BulkTimeSeries_FieldTerminalPath: *fp, value: value.(*TimeSerie)} 1966 default: 1967 panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fp.selector)) 1968 } 1969 } 1970 1971 func (fp *BulkTimeSeries_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue { 1972 return fp.WithIArrayItemValue(value) 1973 } 1974 1975 type BulkTimeSeries_FieldSubPath struct { 1976 selector BulkTimeSeries_FieldPathSelector 1977 subPath gotenobject.FieldPath 1978 } 1979 1980 var _ BulkTimeSeries_FieldPath = (*BulkTimeSeries_FieldSubPath)(nil) 1981 1982 func (fps *BulkTimeSeries_FieldSubPath) Selector() BulkTimeSeries_FieldPathSelector { 1983 return fps.selector 1984 } 1985 func (fps *BulkTimeSeries_FieldSubPath) AsTimeSeriesSubPath() (TimeSerie_FieldPath, bool) { 1986 res, ok := fps.subPath.(TimeSerie_FieldPath) 1987 return res, ok 1988 } 1989 1990 // String returns path representation in proto convention 1991 func (fps *BulkTimeSeries_FieldSubPath) String() string { 1992 return fps.selector.String() + "." + fps.subPath.String() 1993 } 1994 1995 // JSONString returns path representation is JSON convention 1996 func (fps *BulkTimeSeries_FieldSubPath) JSONString() string { 1997 return strcase.ToLowerCamel(fps.selector.String()) + "." + fps.subPath.JSONString() 1998 } 1999 2000 // Get returns all values pointed by selected field from source BulkTimeSeries 2001 func (fps *BulkTimeSeries_FieldSubPath) Get(source *BulkTimeSeries) (values []interface{}) { 2002 switch fps.selector { 2003 case BulkTimeSeries_FieldPathSelectorTimeSeries: 2004 for _, item := range source.GetTimeSeries() { 2005 values = append(values, fps.subPath.GetRaw(item)...) 2006 } 2007 default: 2008 panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fps.selector)) 2009 } 2010 return 2011 } 2012 2013 func (fps *BulkTimeSeries_FieldSubPath) GetRaw(source proto.Message) []interface{} { 2014 return fps.Get(source.(*BulkTimeSeries)) 2015 } 2016 2017 // GetSingle returns value of selected field from source BulkTimeSeries 2018 func (fps *BulkTimeSeries_FieldSubPath) GetSingle(source *BulkTimeSeries) (interface{}, bool) { 2019 switch fps.selector { 2020 case BulkTimeSeries_FieldPathSelectorTimeSeries: 2021 if len(source.GetTimeSeries()) == 0 { 2022 return nil, false 2023 } 2024 return fps.subPath.GetSingleRaw(source.GetTimeSeries()[0]) 2025 default: 2026 panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fps.selector)) 2027 } 2028 } 2029 2030 func (fps *BulkTimeSeries_FieldSubPath) GetSingleRaw(source proto.Message) (interface{}, bool) { 2031 return fps.GetSingle(source.(*BulkTimeSeries)) 2032 } 2033 2034 // GetDefault returns a default value of the field type 2035 func (fps *BulkTimeSeries_FieldSubPath) GetDefault() interface{} { 2036 return fps.subPath.GetDefault() 2037 } 2038 2039 func (fps *BulkTimeSeries_FieldSubPath) ClearValue(item *BulkTimeSeries) { 2040 if item != nil { 2041 switch fps.selector { 2042 case BulkTimeSeries_FieldPathSelectorTimeSeries: 2043 for _, subItem := range item.TimeSeries { 2044 fps.subPath.ClearValueRaw(subItem) 2045 } 2046 default: 2047 panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fps.selector)) 2048 } 2049 } 2050 } 2051 2052 func (fps *BulkTimeSeries_FieldSubPath) ClearValueRaw(item proto.Message) { 2053 fps.ClearValue(item.(*BulkTimeSeries)) 2054 } 2055 2056 // IsLeaf - whether field path is holds simple value 2057 func (fps *BulkTimeSeries_FieldSubPath) IsLeaf() bool { 2058 return fps.subPath.IsLeaf() 2059 } 2060 2061 func (fps *BulkTimeSeries_FieldSubPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath { 2062 iPaths := []gotenobject.FieldPath{&BulkTimeSeries_FieldTerminalPath{selector: fps.selector}} 2063 iPaths = append(iPaths, fps.subPath.SplitIntoTerminalIPaths()...) 2064 return iPaths 2065 } 2066 2067 func (fps *BulkTimeSeries_FieldSubPath) WithIValue(value interface{}) BulkTimeSeries_FieldPathValue { 2068 return &BulkTimeSeries_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)} 2069 } 2070 2071 func (fps *BulkTimeSeries_FieldSubPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue { 2072 return fps.WithIValue(value) 2073 } 2074 2075 func (fps *BulkTimeSeries_FieldSubPath) WithIArrayOfValues(values interface{}) BulkTimeSeries_FieldPathArrayOfValues { 2076 return &BulkTimeSeries_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)} 2077 } 2078 2079 func (fps *BulkTimeSeries_FieldSubPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues { 2080 return fps.WithIArrayOfValues(values) 2081 } 2082 2083 func (fps *BulkTimeSeries_FieldSubPath) WithIArrayItemValue(value interface{}) BulkTimeSeries_FieldPathArrayItemValue { 2084 return &BulkTimeSeries_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)} 2085 } 2086 2087 func (fps *BulkTimeSeries_FieldSubPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue { 2088 return fps.WithIArrayItemValue(value) 2089 } 2090 2091 // BulkTimeSeries_FieldPathValue allows storing values for BulkTimeSeries fields according to their type 2092 type BulkTimeSeries_FieldPathValue interface { 2093 BulkTimeSeries_FieldPath 2094 gotenobject.FieldPathValue 2095 SetTo(target **BulkTimeSeries) 2096 CompareWith(*BulkTimeSeries) (cmp int, comparable bool) 2097 } 2098 2099 func ParseBulkTimeSeries_FieldPathValue(pathStr, valueStr string) (BulkTimeSeries_FieldPathValue, error) { 2100 fp, err := ParseBulkTimeSeries_FieldPath(pathStr) 2101 if err != nil { 2102 return nil, err 2103 } 2104 fpv, err := gotenobject.ParseFieldPathValue(fp, valueStr) 2105 if err != nil { 2106 return nil, status.Errorf(codes.InvalidArgument, "error parsing BulkTimeSeries field path value from %s: %v", valueStr, err) 2107 } 2108 return fpv.(BulkTimeSeries_FieldPathValue), nil 2109 } 2110 2111 func MustParseBulkTimeSeries_FieldPathValue(pathStr, valueStr string) BulkTimeSeries_FieldPathValue { 2112 fpv, err := ParseBulkTimeSeries_FieldPathValue(pathStr, valueStr) 2113 if err != nil { 2114 panic(err) 2115 } 2116 return fpv 2117 } 2118 2119 type BulkTimeSeries_FieldTerminalPathValue struct { 2120 BulkTimeSeries_FieldTerminalPath 2121 value interface{} 2122 } 2123 2124 var _ BulkTimeSeries_FieldPathValue = (*BulkTimeSeries_FieldTerminalPathValue)(nil) 2125 2126 // GetRawValue returns raw value stored under selected path for 'BulkTimeSeries' as interface{} 2127 func (fpv *BulkTimeSeries_FieldTerminalPathValue) GetRawValue() interface{} { 2128 return fpv.value 2129 } 2130 func (fpv *BulkTimeSeries_FieldTerminalPathValue) AsTimeSeriesValue() ([]*TimeSerie, bool) { 2131 res, ok := fpv.value.([]*TimeSerie) 2132 return res, ok 2133 } 2134 func (fpv *BulkTimeSeries_FieldTerminalPathValue) AsPhantomFlagValue() (bool, bool) { 2135 res, ok := fpv.value.(bool) 2136 return res, ok 2137 } 2138 2139 // SetTo stores value for selected field for object BulkTimeSeries 2140 func (fpv *BulkTimeSeries_FieldTerminalPathValue) SetTo(target **BulkTimeSeries) { 2141 if *target == nil { 2142 *target = new(BulkTimeSeries) 2143 } 2144 switch fpv.selector { 2145 case BulkTimeSeries_FieldPathSelectorTimeSeries: 2146 (*target).TimeSeries = fpv.value.([]*TimeSerie) 2147 case BulkTimeSeries_FieldPathSelectorPhantomFlag: 2148 (*target).PhantomFlag = fpv.value.(bool) 2149 default: 2150 panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fpv.selector)) 2151 } 2152 } 2153 2154 func (fpv *BulkTimeSeries_FieldTerminalPathValue) SetToRaw(target proto.Message) { 2155 typedObject := target.(*BulkTimeSeries) 2156 fpv.SetTo(&typedObject) 2157 } 2158 2159 // CompareWith compares value in the 'BulkTimeSeries_FieldTerminalPathValue' with the value under path in 'BulkTimeSeries'. 2160 func (fpv *BulkTimeSeries_FieldTerminalPathValue) CompareWith(source *BulkTimeSeries) (int, bool) { 2161 switch fpv.selector { 2162 case BulkTimeSeries_FieldPathSelectorTimeSeries: 2163 return 0, false 2164 case BulkTimeSeries_FieldPathSelectorPhantomFlag: 2165 leftValue := fpv.value.(bool) 2166 rightValue := source.GetPhantomFlag() 2167 if (leftValue) == (rightValue) { 2168 return 0, true 2169 } else if !(leftValue) && (rightValue) { 2170 return -1, true 2171 } else { 2172 return 1, true 2173 } 2174 default: 2175 panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fpv.selector)) 2176 } 2177 } 2178 2179 func (fpv *BulkTimeSeries_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) { 2180 return fpv.CompareWith(source.(*BulkTimeSeries)) 2181 } 2182 2183 type BulkTimeSeries_FieldSubPathValue struct { 2184 BulkTimeSeries_FieldPath 2185 subPathValue gotenobject.FieldPathValue 2186 } 2187 2188 var _ BulkTimeSeries_FieldPathValue = (*BulkTimeSeries_FieldSubPathValue)(nil) 2189 2190 func (fpvs *BulkTimeSeries_FieldSubPathValue) AsTimeSeriesPathValue() (TimeSerie_FieldPathValue, bool) { 2191 res, ok := fpvs.subPathValue.(TimeSerie_FieldPathValue) 2192 return res, ok 2193 } 2194 2195 func (fpvs *BulkTimeSeries_FieldSubPathValue) SetTo(target **BulkTimeSeries) { 2196 if *target == nil { 2197 *target = new(BulkTimeSeries) 2198 } 2199 switch fpvs.Selector() { 2200 case BulkTimeSeries_FieldPathSelectorTimeSeries: 2201 panic("FieldPath setter is unsupported for array subpaths") 2202 default: 2203 panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fpvs.Selector())) 2204 } 2205 } 2206 2207 func (fpvs *BulkTimeSeries_FieldSubPathValue) SetToRaw(target proto.Message) { 2208 typedObject := target.(*BulkTimeSeries) 2209 fpvs.SetTo(&typedObject) 2210 } 2211 2212 func (fpvs *BulkTimeSeries_FieldSubPathValue) GetRawValue() interface{} { 2213 return fpvs.subPathValue.GetRawValue() 2214 } 2215 2216 func (fpvs *BulkTimeSeries_FieldSubPathValue) CompareWith(source *BulkTimeSeries) (int, bool) { 2217 switch fpvs.Selector() { 2218 case BulkTimeSeries_FieldPathSelectorTimeSeries: 2219 return 0, false // repeated field 2220 default: 2221 panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fpvs.Selector())) 2222 } 2223 } 2224 2225 func (fpvs *BulkTimeSeries_FieldSubPathValue) CompareWithRaw(source proto.Message) (int, bool) { 2226 return fpvs.CompareWith(source.(*BulkTimeSeries)) 2227 } 2228 2229 // BulkTimeSeries_FieldPathArrayItemValue allows storing single item in Path-specific values for BulkTimeSeries according to their type 2230 // Present only for array (repeated) types. 2231 type BulkTimeSeries_FieldPathArrayItemValue interface { 2232 gotenobject.FieldPathArrayItemValue 2233 BulkTimeSeries_FieldPath 2234 ContainsValue(*BulkTimeSeries) bool 2235 } 2236 2237 // ParseBulkTimeSeries_FieldPathArrayItemValue parses string and JSON-encoded value to its Value 2238 func ParseBulkTimeSeries_FieldPathArrayItemValue(pathStr, valueStr string) (BulkTimeSeries_FieldPathArrayItemValue, error) { 2239 fp, err := ParseBulkTimeSeries_FieldPath(pathStr) 2240 if err != nil { 2241 return nil, err 2242 } 2243 fpaiv, err := gotenobject.ParseFieldPathArrayItemValue(fp, valueStr) 2244 if err != nil { 2245 return nil, status.Errorf(codes.InvalidArgument, "error parsing BulkTimeSeries field path array item value from %s: %v", valueStr, err) 2246 } 2247 return fpaiv.(BulkTimeSeries_FieldPathArrayItemValue), nil 2248 } 2249 2250 func MustParseBulkTimeSeries_FieldPathArrayItemValue(pathStr, valueStr string) BulkTimeSeries_FieldPathArrayItemValue { 2251 fpaiv, err := ParseBulkTimeSeries_FieldPathArrayItemValue(pathStr, valueStr) 2252 if err != nil { 2253 panic(err) 2254 } 2255 return fpaiv 2256 } 2257 2258 type BulkTimeSeries_FieldTerminalPathArrayItemValue struct { 2259 BulkTimeSeries_FieldTerminalPath 2260 value interface{} 2261 } 2262 2263 var _ BulkTimeSeries_FieldPathArrayItemValue = (*BulkTimeSeries_FieldTerminalPathArrayItemValue)(nil) 2264 2265 // GetRawValue returns stored element value for array in object BulkTimeSeries as interface{} 2266 func (fpaiv *BulkTimeSeries_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} { 2267 return fpaiv.value 2268 } 2269 func (fpaiv *BulkTimeSeries_FieldTerminalPathArrayItemValue) AsTimeSeriesItemValue() (*TimeSerie, bool) { 2270 res, ok := fpaiv.value.(*TimeSerie) 2271 return res, ok 2272 } 2273 2274 func (fpaiv *BulkTimeSeries_FieldTerminalPathArrayItemValue) GetSingle(source *BulkTimeSeries) (interface{}, bool) { 2275 return nil, false 2276 } 2277 2278 func (fpaiv *BulkTimeSeries_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) { 2279 return fpaiv.GetSingle(source.(*BulkTimeSeries)) 2280 } 2281 2282 // Contains returns a boolean indicating if value that is being held is present in given 'BulkTimeSeries' 2283 func (fpaiv *BulkTimeSeries_FieldTerminalPathArrayItemValue) ContainsValue(source *BulkTimeSeries) bool { 2284 slice := fpaiv.BulkTimeSeries_FieldTerminalPath.Get(source) 2285 for _, v := range slice { 2286 if asProtoMsg, ok := fpaiv.value.(proto.Message); ok { 2287 if proto.Equal(asProtoMsg, v.(proto.Message)) { 2288 return true 2289 } 2290 } else if reflect.DeepEqual(v, fpaiv.value) { 2291 return true 2292 } 2293 } 2294 return false 2295 } 2296 2297 type BulkTimeSeries_FieldSubPathArrayItemValue struct { 2298 BulkTimeSeries_FieldPath 2299 subPathItemValue gotenobject.FieldPathArrayItemValue 2300 } 2301 2302 // GetRawValue returns stored array item value 2303 func (fpaivs *BulkTimeSeries_FieldSubPathArrayItemValue) GetRawItemValue() interface{} { 2304 return fpaivs.subPathItemValue.GetRawItemValue() 2305 } 2306 func (fpaivs *BulkTimeSeries_FieldSubPathArrayItemValue) AsTimeSeriesPathItemValue() (TimeSerie_FieldPathArrayItemValue, bool) { 2307 res, ok := fpaivs.subPathItemValue.(TimeSerie_FieldPathArrayItemValue) 2308 return res, ok 2309 } 2310 2311 // Contains returns a boolean indicating if value that is being held is present in given 'BulkTimeSeries' 2312 func (fpaivs *BulkTimeSeries_FieldSubPathArrayItemValue) ContainsValue(source *BulkTimeSeries) bool { 2313 switch fpaivs.Selector() { 2314 case BulkTimeSeries_FieldPathSelectorTimeSeries: 2315 return false // repeated/map field 2316 default: 2317 panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fpaivs.Selector())) 2318 } 2319 } 2320 2321 // BulkTimeSeries_FieldPathArrayOfValues allows storing slice of values for BulkTimeSeries fields according to their type 2322 type BulkTimeSeries_FieldPathArrayOfValues interface { 2323 gotenobject.FieldPathArrayOfValues 2324 BulkTimeSeries_FieldPath 2325 } 2326 2327 func ParseBulkTimeSeries_FieldPathArrayOfValues(pathStr, valuesStr string) (BulkTimeSeries_FieldPathArrayOfValues, error) { 2328 fp, err := ParseBulkTimeSeries_FieldPath(pathStr) 2329 if err != nil { 2330 return nil, err 2331 } 2332 fpaov, err := gotenobject.ParseFieldPathArrayOfValues(fp, valuesStr) 2333 if err != nil { 2334 return nil, status.Errorf(codes.InvalidArgument, "error parsing BulkTimeSeries field path array of values from %s: %v", valuesStr, err) 2335 } 2336 return fpaov.(BulkTimeSeries_FieldPathArrayOfValues), nil 2337 } 2338 2339 func MustParseBulkTimeSeries_FieldPathArrayOfValues(pathStr, valuesStr string) BulkTimeSeries_FieldPathArrayOfValues { 2340 fpaov, err := ParseBulkTimeSeries_FieldPathArrayOfValues(pathStr, valuesStr) 2341 if err != nil { 2342 panic(err) 2343 } 2344 return fpaov 2345 } 2346 2347 type BulkTimeSeries_FieldTerminalPathArrayOfValues struct { 2348 BulkTimeSeries_FieldTerminalPath 2349 values interface{} 2350 } 2351 2352 var _ BulkTimeSeries_FieldPathArrayOfValues = (*BulkTimeSeries_FieldTerminalPathArrayOfValues)(nil) 2353 2354 func (fpaov *BulkTimeSeries_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) { 2355 switch fpaov.selector { 2356 case BulkTimeSeries_FieldPathSelectorTimeSeries: 2357 for _, v := range fpaov.values.([][]*TimeSerie) { 2358 values = append(values, v) 2359 } 2360 case BulkTimeSeries_FieldPathSelectorPhantomFlag: 2361 for _, v := range fpaov.values.([]bool) { 2362 values = append(values, v) 2363 } 2364 } 2365 return 2366 } 2367 func (fpaov *BulkTimeSeries_FieldTerminalPathArrayOfValues) AsTimeSeriesArrayOfValues() ([][]*TimeSerie, bool) { 2368 res, ok := fpaov.values.([][]*TimeSerie) 2369 return res, ok 2370 } 2371 func (fpaov *BulkTimeSeries_FieldTerminalPathArrayOfValues) AsPhantomFlagArrayOfValues() ([]bool, bool) { 2372 res, ok := fpaov.values.([]bool) 2373 return res, ok 2374 } 2375 2376 type BulkTimeSeries_FieldSubPathArrayOfValues struct { 2377 BulkTimeSeries_FieldPath 2378 subPathArrayOfValues gotenobject.FieldPathArrayOfValues 2379 } 2380 2381 var _ BulkTimeSeries_FieldPathArrayOfValues = (*BulkTimeSeries_FieldSubPathArrayOfValues)(nil) 2382 2383 func (fpsaov *BulkTimeSeries_FieldSubPathArrayOfValues) GetRawValues() []interface{} { 2384 return fpsaov.subPathArrayOfValues.GetRawValues() 2385 } 2386 func (fpsaov *BulkTimeSeries_FieldSubPathArrayOfValues) AsTimeSeriesPathArrayOfValues() (TimeSerie_FieldPathArrayOfValues, bool) { 2387 res, ok := fpsaov.subPathArrayOfValues.(TimeSerie_FieldPathArrayOfValues) 2388 return res, ok 2389 }