github.com/cloudwan/edgelq-sdk@v1.15.4/monitoring/resources/v3/time_serie/time_serie.pb.fieldmask.go (about) 1 // Code generated by protoc-gen-goten-object 2 // File: edgelq/monitoring/proto/v3/time_serie.proto 3 // DO NOT EDIT!!! 4 5 package time_serie 6 7 import ( 8 "encoding/json" 9 "strings" 10 11 "google.golang.org/grpc/codes" 12 "google.golang.org/grpc/status" 13 "google.golang.org/protobuf/proto" 14 preflect "google.golang.org/protobuf/reflect/protoreflect" 15 googlefieldmaskpb "google.golang.org/protobuf/types/known/fieldmaskpb" 16 17 gotenobject "github.com/cloudwan/goten-sdk/runtime/object" 18 ) 19 20 // proto imports 21 import ( 22 common "github.com/cloudwan/edgelq-sdk/monitoring/resources/v3/common" 23 metric_descriptor "github.com/cloudwan/edgelq-sdk/monitoring/resources/v3/metric_descriptor" 24 ) 25 26 // ensure the imports are used 27 var ( 28 _ = new(json.Marshaler) 29 _ = strings.Builder{} 30 31 _ = codes.NotFound 32 _ = status.Status{} 33 _ = new(proto.Message) 34 _ = new(preflect.Message) 35 _ = googlefieldmaskpb.FieldMask{} 36 37 _ = new(gotenobject.FieldMask) 38 ) 39 40 // make sure we're using proto imports 41 var ( 42 _ = &common.LabelDescriptor{} 43 _ = &metric_descriptor.MetricDescriptor{} 44 ) 45 46 type Point_FieldMask struct { 47 Paths []Point_FieldPath 48 } 49 50 func FullPoint_FieldMask() *Point_FieldMask { 51 res := &Point_FieldMask{} 52 res.Paths = append(res.Paths, &Point_FieldTerminalPath{selector: Point_FieldPathSelectorInterval}) 53 res.Paths = append(res.Paths, &Point_FieldTerminalPath{selector: Point_FieldPathSelectorValue}) 54 res.Paths = append(res.Paths, &Point_FieldTerminalPath{selector: Point_FieldPathSelectorAggregation}) 55 return res 56 } 57 58 func (fieldMask *Point_FieldMask) String() string { 59 if fieldMask == nil { 60 return "<nil>" 61 } 62 pathsStr := make([]string, 0, len(fieldMask.Paths)) 63 for _, path := range fieldMask.Paths { 64 pathsStr = append(pathsStr, path.String()) 65 } 66 return strings.Join(pathsStr, ", ") 67 } 68 69 func (fieldMask *Point_FieldMask) IsFull() bool { 70 if fieldMask == nil { 71 return false 72 } 73 presentSelectors := make([]bool, 3) 74 for _, path := range fieldMask.Paths { 75 if asFinal, ok := path.(*Point_FieldTerminalPath); ok { 76 presentSelectors[int(asFinal.selector)] = true 77 } 78 } 79 for _, flag := range presentSelectors { 80 if !flag { 81 return false 82 } 83 } 84 return true 85 } 86 87 func (fieldMask *Point_FieldMask) ProtoReflect() preflect.Message { 88 return gotenobject.MakeFieldMaskReflection(fieldMask, func(raw string) (gotenobject.FieldPath, error) { 89 return ParsePoint_FieldPath(raw) 90 }) 91 } 92 93 func (fieldMask *Point_FieldMask) ProtoMessage() {} 94 95 func (fieldMask *Point_FieldMask) Reset() { 96 if fieldMask != nil { 97 fieldMask.Paths = nil 98 } 99 } 100 101 func (fieldMask *Point_FieldMask) Subtract(other *Point_FieldMask) *Point_FieldMask { 102 result := &Point_FieldMask{} 103 removedSelectors := make([]bool, 3) 104 otherSubMasks := map[Point_FieldPathSelector]gotenobject.FieldMask{ 105 Point_FieldPathSelectorInterval: &common.TimeInterval_FieldMask{}, 106 Point_FieldPathSelectorValue: &common.TypedValue_FieldMask{}, 107 Point_FieldPathSelectorAggregation: &common.Aggregation_FieldMask{}, 108 } 109 mySubMasks := map[Point_FieldPathSelector]gotenobject.FieldMask{ 110 Point_FieldPathSelectorInterval: &common.TimeInterval_FieldMask{}, 111 Point_FieldPathSelectorValue: &common.TypedValue_FieldMask{}, 112 Point_FieldPathSelectorAggregation: &common.Aggregation_FieldMask{}, 113 } 114 115 for _, path := range other.GetPaths() { 116 switch tp := path.(type) { 117 case *Point_FieldTerminalPath: 118 removedSelectors[int(tp.selector)] = true 119 case *Point_FieldSubPath: 120 otherSubMasks[tp.selector].AppendRawPath(tp.subPath) 121 } 122 } 123 for _, path := range fieldMask.GetPaths() { 124 if !removedSelectors[int(path.Selector())] { 125 if otherSubMask := otherSubMasks[path.Selector()]; otherSubMask != nil && otherSubMask.PathsCount() > 0 { 126 if tp, ok := path.(*Point_FieldTerminalPath); ok { 127 switch tp.selector { 128 case Point_FieldPathSelectorInterval: 129 mySubMasks[Point_FieldPathSelectorInterval] = common.FullTimeInterval_FieldMask() 130 case Point_FieldPathSelectorValue: 131 mySubMasks[Point_FieldPathSelectorValue] = common.FullTypedValue_FieldMask() 132 case Point_FieldPathSelectorAggregation: 133 mySubMasks[Point_FieldPathSelectorAggregation] = common.FullAggregation_FieldMask() 134 } 135 } else if tp, ok := path.(*Point_FieldSubPath); ok { 136 mySubMasks[tp.selector].AppendRawPath(tp.subPath) 137 } 138 } else { 139 result.Paths = append(result.Paths, path) 140 } 141 } 142 } 143 for selector, mySubMask := range mySubMasks { 144 if mySubMask.PathsCount() > 0 { 145 for _, allowedPath := range mySubMask.SubtractRaw(otherSubMasks[selector]).GetRawPaths() { 146 result.Paths = append(result.Paths, &Point_FieldSubPath{selector: selector, subPath: allowedPath}) 147 } 148 } 149 } 150 151 if len(result.Paths) == 0 { 152 return nil 153 } 154 return result 155 } 156 157 func (fieldMask *Point_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask { 158 return fieldMask.Subtract(other.(*Point_FieldMask)) 159 } 160 161 // FilterInputFields generates copy of field paths with output_only field paths removed 162 func (fieldMask *Point_FieldMask) FilterInputFields() *Point_FieldMask { 163 result := &Point_FieldMask{} 164 result.Paths = append(result.Paths, fieldMask.Paths...) 165 return result 166 } 167 168 // ToFieldMask is used for proto conversions 169 func (fieldMask *Point_FieldMask) ToProtoFieldMask() *googlefieldmaskpb.FieldMask { 170 protoFieldMask := &googlefieldmaskpb.FieldMask{} 171 for _, path := range fieldMask.Paths { 172 protoFieldMask.Paths = append(protoFieldMask.Paths, path.String()) 173 } 174 return protoFieldMask 175 } 176 177 func (fieldMask *Point_FieldMask) FromProtoFieldMask(protoFieldMask *googlefieldmaskpb.FieldMask) error { 178 if fieldMask == nil { 179 return status.Error(codes.Internal, "target field mask is nil") 180 } 181 fieldMask.Paths = make([]Point_FieldPath, 0, len(protoFieldMask.Paths)) 182 for _, strPath := range protoFieldMask.Paths { 183 path, err := ParsePoint_FieldPath(strPath) 184 if err != nil { 185 return err 186 } 187 fieldMask.Paths = append(fieldMask.Paths, path) 188 } 189 return nil 190 } 191 192 // implement methods required by customType 193 func (fieldMask Point_FieldMask) Marshal() ([]byte, error) { 194 protoFieldMask := fieldMask.ToProtoFieldMask() 195 return proto.Marshal(protoFieldMask) 196 } 197 198 func (fieldMask *Point_FieldMask) Unmarshal(data []byte) error { 199 protoFieldMask := &googlefieldmaskpb.FieldMask{} 200 if err := proto.Unmarshal(data, protoFieldMask); err != nil { 201 return err 202 } 203 if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil { 204 return err 205 } 206 return nil 207 } 208 209 func (fieldMask *Point_FieldMask) Size() int { 210 return proto.Size(fieldMask.ToProtoFieldMask()) 211 } 212 213 func (fieldMask Point_FieldMask) MarshalJSON() ([]byte, error) { 214 return json.Marshal(fieldMask.ToProtoFieldMask()) 215 } 216 217 func (fieldMask *Point_FieldMask) UnmarshalJSON(data []byte) error { 218 protoFieldMask := &googlefieldmaskpb.FieldMask{} 219 if err := json.Unmarshal(data, protoFieldMask); err != nil { 220 return err 221 } 222 if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil { 223 return err 224 } 225 return nil 226 } 227 228 func (fieldMask *Point_FieldMask) AppendPath(path Point_FieldPath) { 229 fieldMask.Paths = append(fieldMask.Paths, path) 230 } 231 232 func (fieldMask *Point_FieldMask) AppendRawPath(path gotenobject.FieldPath) { 233 fieldMask.Paths = append(fieldMask.Paths, path.(Point_FieldPath)) 234 } 235 236 func (fieldMask *Point_FieldMask) GetPaths() []Point_FieldPath { 237 if fieldMask == nil { 238 return nil 239 } 240 return fieldMask.Paths 241 } 242 243 func (fieldMask *Point_FieldMask) GetRawPaths() []gotenobject.FieldPath { 244 if fieldMask == nil { 245 return nil 246 } 247 rawPaths := make([]gotenobject.FieldPath, 0, len(fieldMask.Paths)) 248 for _, path := range fieldMask.Paths { 249 rawPaths = append(rawPaths, path) 250 } 251 return rawPaths 252 } 253 254 func (fieldMask *Point_FieldMask) SetFromCliFlag(raw string) error { 255 path, err := ParsePoint_FieldPath(raw) 256 if err != nil { 257 return err 258 } 259 fieldMask.Paths = append(fieldMask.Paths, path) 260 return nil 261 } 262 263 func (fieldMask *Point_FieldMask) Set(target, source *Point) { 264 for _, path := range fieldMask.Paths { 265 val, _ := path.GetSingle(source) 266 // if val is nil, then field does not exist in source, skip 267 // otherwise, process (can still reflect.ValueOf(val).IsNil!) 268 if val != nil { 269 path.WithIValue(val).SetTo(&target) 270 } 271 } 272 } 273 274 func (fieldMask *Point_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) { 275 fieldMask.Set(target.(*Point), source.(*Point)) 276 } 277 278 func (fieldMask *Point_FieldMask) Project(source *Point) *Point { 279 if source == nil { 280 return nil 281 } 282 if fieldMask == nil { 283 return source 284 } 285 result := &Point{} 286 intervalMask := &common.TimeInterval_FieldMask{} 287 wholeIntervalAccepted := false 288 valueMask := &common.TypedValue_FieldMask{} 289 wholeValueAccepted := false 290 aggregationMask := &common.Aggregation_FieldMask{} 291 wholeAggregationAccepted := false 292 293 for _, p := range fieldMask.Paths { 294 switch tp := p.(type) { 295 case *Point_FieldTerminalPath: 296 switch tp.selector { 297 case Point_FieldPathSelectorInterval: 298 result.Interval = source.Interval 299 wholeIntervalAccepted = true 300 case Point_FieldPathSelectorValue: 301 result.Value = source.Value 302 wholeValueAccepted = true 303 case Point_FieldPathSelectorAggregation: 304 result.Aggregation = source.Aggregation 305 wholeAggregationAccepted = true 306 } 307 case *Point_FieldSubPath: 308 switch tp.selector { 309 case Point_FieldPathSelectorInterval: 310 intervalMask.AppendPath(tp.subPath.(common.TimeInterval_FieldPath)) 311 case Point_FieldPathSelectorValue: 312 valueMask.AppendPath(tp.subPath.(common.TypedValue_FieldPath)) 313 case Point_FieldPathSelectorAggregation: 314 aggregationMask.AppendPath(tp.subPath.(common.Aggregation_FieldPath)) 315 } 316 } 317 } 318 if wholeIntervalAccepted == false && len(intervalMask.Paths) > 0 { 319 result.Interval = intervalMask.Project(source.GetInterval()) 320 } 321 if wholeValueAccepted == false && len(valueMask.Paths) > 0 { 322 result.Value = valueMask.Project(source.GetValue()) 323 } 324 if wholeAggregationAccepted == false && len(aggregationMask.Paths) > 0 { 325 result.Aggregation = aggregationMask.Project(source.GetAggregation()) 326 } 327 return result 328 } 329 330 func (fieldMask *Point_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt { 331 return fieldMask.Project(source.(*Point)) 332 } 333 334 func (fieldMask *Point_FieldMask) PathsCount() int { 335 if fieldMask == nil { 336 return 0 337 } 338 return len(fieldMask.Paths) 339 } 340 341 type TimeSerie_FieldMask struct { 342 Paths []TimeSerie_FieldPath 343 } 344 345 func FullTimeSerie_FieldMask() *TimeSerie_FieldMask { 346 res := &TimeSerie_FieldMask{} 347 res.Paths = append(res.Paths, &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorKey}) 348 res.Paths = append(res.Paths, &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorProject}) 349 res.Paths = append(res.Paths, &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorRegion}) 350 res.Paths = append(res.Paths, &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorMetric}) 351 res.Paths = append(res.Paths, &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorResource}) 352 res.Paths = append(res.Paths, &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorMetricKind}) 353 res.Paths = append(res.Paths, &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorValueType}) 354 res.Paths = append(res.Paths, &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorPoints}) 355 return res 356 } 357 358 func (fieldMask *TimeSerie_FieldMask) String() string { 359 if fieldMask == nil { 360 return "<nil>" 361 } 362 pathsStr := make([]string, 0, len(fieldMask.Paths)) 363 for _, path := range fieldMask.Paths { 364 pathsStr = append(pathsStr, path.String()) 365 } 366 return strings.Join(pathsStr, ", ") 367 } 368 369 func (fieldMask *TimeSerie_FieldMask) IsFull() bool { 370 if fieldMask == nil { 371 return false 372 } 373 presentSelectors := make([]bool, 8) 374 for _, path := range fieldMask.Paths { 375 if asFinal, ok := path.(*TimeSerie_FieldTerminalPath); ok { 376 presentSelectors[int(asFinal.selector)] = true 377 } 378 } 379 for _, flag := range presentSelectors { 380 if !flag { 381 return false 382 } 383 } 384 return true 385 } 386 387 func (fieldMask *TimeSerie_FieldMask) ProtoReflect() preflect.Message { 388 return gotenobject.MakeFieldMaskReflection(fieldMask, func(raw string) (gotenobject.FieldPath, error) { 389 return ParseTimeSerie_FieldPath(raw) 390 }) 391 } 392 393 func (fieldMask *TimeSerie_FieldMask) ProtoMessage() {} 394 395 func (fieldMask *TimeSerie_FieldMask) Reset() { 396 if fieldMask != nil { 397 fieldMask.Paths = nil 398 } 399 } 400 401 func (fieldMask *TimeSerie_FieldMask) Subtract(other *TimeSerie_FieldMask) *TimeSerie_FieldMask { 402 result := &TimeSerie_FieldMask{} 403 removedSelectors := make([]bool, 8) 404 otherSubMasks := map[TimeSerie_FieldPathSelector]gotenobject.FieldMask{ 405 TimeSerie_FieldPathSelectorMetric: &common.Metric_FieldMask{}, 406 TimeSerie_FieldPathSelectorResource: &common.MonitoredResource_FieldMask{}, 407 TimeSerie_FieldPathSelectorPoints: &Point_FieldMask{}, 408 } 409 mySubMasks := map[TimeSerie_FieldPathSelector]gotenobject.FieldMask{ 410 TimeSerie_FieldPathSelectorMetric: &common.Metric_FieldMask{}, 411 TimeSerie_FieldPathSelectorResource: &common.MonitoredResource_FieldMask{}, 412 TimeSerie_FieldPathSelectorPoints: &Point_FieldMask{}, 413 } 414 415 for _, path := range other.GetPaths() { 416 switch tp := path.(type) { 417 case *TimeSerie_FieldTerminalPath: 418 removedSelectors[int(tp.selector)] = true 419 case *TimeSerie_FieldSubPath: 420 otherSubMasks[tp.selector].AppendRawPath(tp.subPath) 421 } 422 } 423 for _, path := range fieldMask.GetPaths() { 424 if !removedSelectors[int(path.Selector())] { 425 if otherSubMask := otherSubMasks[path.Selector()]; otherSubMask != nil && otherSubMask.PathsCount() > 0 { 426 if tp, ok := path.(*TimeSerie_FieldTerminalPath); ok { 427 switch tp.selector { 428 case TimeSerie_FieldPathSelectorMetric: 429 mySubMasks[TimeSerie_FieldPathSelectorMetric] = common.FullMetric_FieldMask() 430 case TimeSerie_FieldPathSelectorResource: 431 mySubMasks[TimeSerie_FieldPathSelectorResource] = common.FullMonitoredResource_FieldMask() 432 case TimeSerie_FieldPathSelectorPoints: 433 mySubMasks[TimeSerie_FieldPathSelectorPoints] = FullPoint_FieldMask() 434 } 435 } else if tp, ok := path.(*TimeSerie_FieldSubPath); ok { 436 mySubMasks[tp.selector].AppendRawPath(tp.subPath) 437 } 438 } else { 439 result.Paths = append(result.Paths, path) 440 } 441 } 442 } 443 for selector, mySubMask := range mySubMasks { 444 if mySubMask.PathsCount() > 0 { 445 for _, allowedPath := range mySubMask.SubtractRaw(otherSubMasks[selector]).GetRawPaths() { 446 result.Paths = append(result.Paths, &TimeSerie_FieldSubPath{selector: selector, subPath: allowedPath}) 447 } 448 } 449 } 450 451 if len(result.Paths) == 0 { 452 return nil 453 } 454 return result 455 } 456 457 func (fieldMask *TimeSerie_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask { 458 return fieldMask.Subtract(other.(*TimeSerie_FieldMask)) 459 } 460 461 // FilterInputFields generates copy of field paths with output_only field paths removed 462 func (fieldMask *TimeSerie_FieldMask) FilterInputFields() *TimeSerie_FieldMask { 463 result := &TimeSerie_FieldMask{} 464 result.Paths = append(result.Paths, fieldMask.Paths...) 465 return result 466 } 467 468 // ToFieldMask is used for proto conversions 469 func (fieldMask *TimeSerie_FieldMask) ToProtoFieldMask() *googlefieldmaskpb.FieldMask { 470 protoFieldMask := &googlefieldmaskpb.FieldMask{} 471 for _, path := range fieldMask.Paths { 472 protoFieldMask.Paths = append(protoFieldMask.Paths, path.String()) 473 } 474 return protoFieldMask 475 } 476 477 func (fieldMask *TimeSerie_FieldMask) FromProtoFieldMask(protoFieldMask *googlefieldmaskpb.FieldMask) error { 478 if fieldMask == nil { 479 return status.Error(codes.Internal, "target field mask is nil") 480 } 481 fieldMask.Paths = make([]TimeSerie_FieldPath, 0, len(protoFieldMask.Paths)) 482 for _, strPath := range protoFieldMask.Paths { 483 path, err := ParseTimeSerie_FieldPath(strPath) 484 if err != nil { 485 return err 486 } 487 fieldMask.Paths = append(fieldMask.Paths, path) 488 } 489 return nil 490 } 491 492 // implement methods required by customType 493 func (fieldMask TimeSerie_FieldMask) Marshal() ([]byte, error) { 494 protoFieldMask := fieldMask.ToProtoFieldMask() 495 return proto.Marshal(protoFieldMask) 496 } 497 498 func (fieldMask *TimeSerie_FieldMask) Unmarshal(data []byte) error { 499 protoFieldMask := &googlefieldmaskpb.FieldMask{} 500 if err := proto.Unmarshal(data, protoFieldMask); err != nil { 501 return err 502 } 503 if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil { 504 return err 505 } 506 return nil 507 } 508 509 func (fieldMask *TimeSerie_FieldMask) Size() int { 510 return proto.Size(fieldMask.ToProtoFieldMask()) 511 } 512 513 func (fieldMask TimeSerie_FieldMask) MarshalJSON() ([]byte, error) { 514 return json.Marshal(fieldMask.ToProtoFieldMask()) 515 } 516 517 func (fieldMask *TimeSerie_FieldMask) UnmarshalJSON(data []byte) error { 518 protoFieldMask := &googlefieldmaskpb.FieldMask{} 519 if err := json.Unmarshal(data, protoFieldMask); err != nil { 520 return err 521 } 522 if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil { 523 return err 524 } 525 return nil 526 } 527 528 func (fieldMask *TimeSerie_FieldMask) AppendPath(path TimeSerie_FieldPath) { 529 fieldMask.Paths = append(fieldMask.Paths, path) 530 } 531 532 func (fieldMask *TimeSerie_FieldMask) AppendRawPath(path gotenobject.FieldPath) { 533 fieldMask.Paths = append(fieldMask.Paths, path.(TimeSerie_FieldPath)) 534 } 535 536 func (fieldMask *TimeSerie_FieldMask) GetPaths() []TimeSerie_FieldPath { 537 if fieldMask == nil { 538 return nil 539 } 540 return fieldMask.Paths 541 } 542 543 func (fieldMask *TimeSerie_FieldMask) GetRawPaths() []gotenobject.FieldPath { 544 if fieldMask == nil { 545 return nil 546 } 547 rawPaths := make([]gotenobject.FieldPath, 0, len(fieldMask.Paths)) 548 for _, path := range fieldMask.Paths { 549 rawPaths = append(rawPaths, path) 550 } 551 return rawPaths 552 } 553 554 func (fieldMask *TimeSerie_FieldMask) SetFromCliFlag(raw string) error { 555 path, err := ParseTimeSerie_FieldPath(raw) 556 if err != nil { 557 return err 558 } 559 fieldMask.Paths = append(fieldMask.Paths, path) 560 return nil 561 } 562 563 func (fieldMask *TimeSerie_FieldMask) Set(target, source *TimeSerie) { 564 for _, path := range fieldMask.Paths { 565 val, _ := path.GetSingle(source) 566 // if val is nil, then field does not exist in source, skip 567 // otherwise, process (can still reflect.ValueOf(val).IsNil!) 568 if val != nil { 569 path.WithIValue(val).SetTo(&target) 570 } 571 } 572 } 573 574 func (fieldMask *TimeSerie_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) { 575 fieldMask.Set(target.(*TimeSerie), source.(*TimeSerie)) 576 } 577 578 func (fieldMask *TimeSerie_FieldMask) Project(source *TimeSerie) *TimeSerie { 579 if source == nil { 580 return nil 581 } 582 if fieldMask == nil { 583 return source 584 } 585 result := &TimeSerie{} 586 metricMask := &common.Metric_FieldMask{} 587 wholeMetricAccepted := false 588 resourceMask := &common.MonitoredResource_FieldMask{} 589 wholeResourceAccepted := false 590 pointsMask := &Point_FieldMask{} 591 wholePointsAccepted := false 592 593 for _, p := range fieldMask.Paths { 594 switch tp := p.(type) { 595 case *TimeSerie_FieldTerminalPath: 596 switch tp.selector { 597 case TimeSerie_FieldPathSelectorKey: 598 result.Key = source.Key 599 case TimeSerie_FieldPathSelectorProject: 600 result.Project = source.Project 601 case TimeSerie_FieldPathSelectorRegion: 602 result.Region = source.Region 603 case TimeSerie_FieldPathSelectorMetric: 604 result.Metric = source.Metric 605 wholeMetricAccepted = true 606 case TimeSerie_FieldPathSelectorResource: 607 result.Resource = source.Resource 608 wholeResourceAccepted = true 609 case TimeSerie_FieldPathSelectorMetricKind: 610 result.MetricKind = source.MetricKind 611 case TimeSerie_FieldPathSelectorValueType: 612 result.ValueType = source.ValueType 613 case TimeSerie_FieldPathSelectorPoints: 614 result.Points = source.Points 615 wholePointsAccepted = true 616 } 617 case *TimeSerie_FieldSubPath: 618 switch tp.selector { 619 case TimeSerie_FieldPathSelectorMetric: 620 metricMask.AppendPath(tp.subPath.(common.Metric_FieldPath)) 621 case TimeSerie_FieldPathSelectorResource: 622 resourceMask.AppendPath(tp.subPath.(common.MonitoredResource_FieldPath)) 623 case TimeSerie_FieldPathSelectorPoints: 624 pointsMask.AppendPath(tp.subPath.(Point_FieldPath)) 625 } 626 } 627 } 628 if wholeMetricAccepted == false && len(metricMask.Paths) > 0 { 629 result.Metric = metricMask.Project(source.GetMetric()) 630 } 631 if wholeResourceAccepted == false && len(resourceMask.Paths) > 0 { 632 result.Resource = resourceMask.Project(source.GetResource()) 633 } 634 if wholePointsAccepted == false && len(pointsMask.Paths) > 0 { 635 for _, sourceItem := range source.GetPoints() { 636 result.Points = append(result.Points, pointsMask.Project(sourceItem)) 637 } 638 } 639 return result 640 } 641 642 func (fieldMask *TimeSerie_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt { 643 return fieldMask.Project(source.(*TimeSerie)) 644 } 645 646 func (fieldMask *TimeSerie_FieldMask) PathsCount() int { 647 if fieldMask == nil { 648 return 0 649 } 650 return len(fieldMask.Paths) 651 } 652 653 type BulkTimeSeries_FieldMask struct { 654 Paths []BulkTimeSeries_FieldPath 655 } 656 657 func FullBulkTimeSeries_FieldMask() *BulkTimeSeries_FieldMask { 658 res := &BulkTimeSeries_FieldMask{} 659 res.Paths = append(res.Paths, &BulkTimeSeries_FieldTerminalPath{selector: BulkTimeSeries_FieldPathSelectorTimeSeries}) 660 res.Paths = append(res.Paths, &BulkTimeSeries_FieldTerminalPath{selector: BulkTimeSeries_FieldPathSelectorPhantomFlag}) 661 return res 662 } 663 664 func (fieldMask *BulkTimeSeries_FieldMask) String() string { 665 if fieldMask == nil { 666 return "<nil>" 667 } 668 pathsStr := make([]string, 0, len(fieldMask.Paths)) 669 for _, path := range fieldMask.Paths { 670 pathsStr = append(pathsStr, path.String()) 671 } 672 return strings.Join(pathsStr, ", ") 673 } 674 675 func (fieldMask *BulkTimeSeries_FieldMask) IsFull() bool { 676 if fieldMask == nil { 677 return false 678 } 679 presentSelectors := make([]bool, 2) 680 for _, path := range fieldMask.Paths { 681 if asFinal, ok := path.(*BulkTimeSeries_FieldTerminalPath); ok { 682 presentSelectors[int(asFinal.selector)] = true 683 } 684 } 685 for _, flag := range presentSelectors { 686 if !flag { 687 return false 688 } 689 } 690 return true 691 } 692 693 func (fieldMask *BulkTimeSeries_FieldMask) ProtoReflect() preflect.Message { 694 return gotenobject.MakeFieldMaskReflection(fieldMask, func(raw string) (gotenobject.FieldPath, error) { 695 return ParseBulkTimeSeries_FieldPath(raw) 696 }) 697 } 698 699 func (fieldMask *BulkTimeSeries_FieldMask) ProtoMessage() {} 700 701 func (fieldMask *BulkTimeSeries_FieldMask) Reset() { 702 if fieldMask != nil { 703 fieldMask.Paths = nil 704 } 705 } 706 707 func (fieldMask *BulkTimeSeries_FieldMask) Subtract(other *BulkTimeSeries_FieldMask) *BulkTimeSeries_FieldMask { 708 result := &BulkTimeSeries_FieldMask{} 709 removedSelectors := make([]bool, 2) 710 otherSubMasks := map[BulkTimeSeries_FieldPathSelector]gotenobject.FieldMask{ 711 BulkTimeSeries_FieldPathSelectorTimeSeries: &TimeSerie_FieldMask{}, 712 } 713 mySubMasks := map[BulkTimeSeries_FieldPathSelector]gotenobject.FieldMask{ 714 BulkTimeSeries_FieldPathSelectorTimeSeries: &TimeSerie_FieldMask{}, 715 } 716 717 for _, path := range other.GetPaths() { 718 switch tp := path.(type) { 719 case *BulkTimeSeries_FieldTerminalPath: 720 removedSelectors[int(tp.selector)] = true 721 case *BulkTimeSeries_FieldSubPath: 722 otherSubMasks[tp.selector].AppendRawPath(tp.subPath) 723 } 724 } 725 for _, path := range fieldMask.GetPaths() { 726 if !removedSelectors[int(path.Selector())] { 727 if otherSubMask := otherSubMasks[path.Selector()]; otherSubMask != nil && otherSubMask.PathsCount() > 0 { 728 if tp, ok := path.(*BulkTimeSeries_FieldTerminalPath); ok { 729 switch tp.selector { 730 case BulkTimeSeries_FieldPathSelectorTimeSeries: 731 mySubMasks[BulkTimeSeries_FieldPathSelectorTimeSeries] = FullTimeSerie_FieldMask() 732 } 733 } else if tp, ok := path.(*BulkTimeSeries_FieldSubPath); ok { 734 mySubMasks[tp.selector].AppendRawPath(tp.subPath) 735 } 736 } else { 737 result.Paths = append(result.Paths, path) 738 } 739 } 740 } 741 for selector, mySubMask := range mySubMasks { 742 if mySubMask.PathsCount() > 0 { 743 for _, allowedPath := range mySubMask.SubtractRaw(otherSubMasks[selector]).GetRawPaths() { 744 result.Paths = append(result.Paths, &BulkTimeSeries_FieldSubPath{selector: selector, subPath: allowedPath}) 745 } 746 } 747 } 748 749 if len(result.Paths) == 0 { 750 return nil 751 } 752 return result 753 } 754 755 func (fieldMask *BulkTimeSeries_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask { 756 return fieldMask.Subtract(other.(*BulkTimeSeries_FieldMask)) 757 } 758 759 // FilterInputFields generates copy of field paths with output_only field paths removed 760 func (fieldMask *BulkTimeSeries_FieldMask) FilterInputFields() *BulkTimeSeries_FieldMask { 761 result := &BulkTimeSeries_FieldMask{} 762 result.Paths = append(result.Paths, fieldMask.Paths...) 763 return result 764 } 765 766 // ToFieldMask is used for proto conversions 767 func (fieldMask *BulkTimeSeries_FieldMask) ToProtoFieldMask() *googlefieldmaskpb.FieldMask { 768 protoFieldMask := &googlefieldmaskpb.FieldMask{} 769 for _, path := range fieldMask.Paths { 770 protoFieldMask.Paths = append(protoFieldMask.Paths, path.String()) 771 } 772 return protoFieldMask 773 } 774 775 func (fieldMask *BulkTimeSeries_FieldMask) FromProtoFieldMask(protoFieldMask *googlefieldmaskpb.FieldMask) error { 776 if fieldMask == nil { 777 return status.Error(codes.Internal, "target field mask is nil") 778 } 779 fieldMask.Paths = make([]BulkTimeSeries_FieldPath, 0, len(protoFieldMask.Paths)) 780 for _, strPath := range protoFieldMask.Paths { 781 path, err := ParseBulkTimeSeries_FieldPath(strPath) 782 if err != nil { 783 return err 784 } 785 fieldMask.Paths = append(fieldMask.Paths, path) 786 } 787 return nil 788 } 789 790 // implement methods required by customType 791 func (fieldMask BulkTimeSeries_FieldMask) Marshal() ([]byte, error) { 792 protoFieldMask := fieldMask.ToProtoFieldMask() 793 return proto.Marshal(protoFieldMask) 794 } 795 796 func (fieldMask *BulkTimeSeries_FieldMask) Unmarshal(data []byte) error { 797 protoFieldMask := &googlefieldmaskpb.FieldMask{} 798 if err := proto.Unmarshal(data, protoFieldMask); err != nil { 799 return err 800 } 801 if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil { 802 return err 803 } 804 return nil 805 } 806 807 func (fieldMask *BulkTimeSeries_FieldMask) Size() int { 808 return proto.Size(fieldMask.ToProtoFieldMask()) 809 } 810 811 func (fieldMask BulkTimeSeries_FieldMask) MarshalJSON() ([]byte, error) { 812 return json.Marshal(fieldMask.ToProtoFieldMask()) 813 } 814 815 func (fieldMask *BulkTimeSeries_FieldMask) UnmarshalJSON(data []byte) error { 816 protoFieldMask := &googlefieldmaskpb.FieldMask{} 817 if err := json.Unmarshal(data, protoFieldMask); err != nil { 818 return err 819 } 820 if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil { 821 return err 822 } 823 return nil 824 } 825 826 func (fieldMask *BulkTimeSeries_FieldMask) AppendPath(path BulkTimeSeries_FieldPath) { 827 fieldMask.Paths = append(fieldMask.Paths, path) 828 } 829 830 func (fieldMask *BulkTimeSeries_FieldMask) AppendRawPath(path gotenobject.FieldPath) { 831 fieldMask.Paths = append(fieldMask.Paths, path.(BulkTimeSeries_FieldPath)) 832 } 833 834 func (fieldMask *BulkTimeSeries_FieldMask) GetPaths() []BulkTimeSeries_FieldPath { 835 if fieldMask == nil { 836 return nil 837 } 838 return fieldMask.Paths 839 } 840 841 func (fieldMask *BulkTimeSeries_FieldMask) GetRawPaths() []gotenobject.FieldPath { 842 if fieldMask == nil { 843 return nil 844 } 845 rawPaths := make([]gotenobject.FieldPath, 0, len(fieldMask.Paths)) 846 for _, path := range fieldMask.Paths { 847 rawPaths = append(rawPaths, path) 848 } 849 return rawPaths 850 } 851 852 func (fieldMask *BulkTimeSeries_FieldMask) SetFromCliFlag(raw string) error { 853 path, err := ParseBulkTimeSeries_FieldPath(raw) 854 if err != nil { 855 return err 856 } 857 fieldMask.Paths = append(fieldMask.Paths, path) 858 return nil 859 } 860 861 func (fieldMask *BulkTimeSeries_FieldMask) Set(target, source *BulkTimeSeries) { 862 for _, path := range fieldMask.Paths { 863 val, _ := path.GetSingle(source) 864 // if val is nil, then field does not exist in source, skip 865 // otherwise, process (can still reflect.ValueOf(val).IsNil!) 866 if val != nil { 867 path.WithIValue(val).SetTo(&target) 868 } 869 } 870 } 871 872 func (fieldMask *BulkTimeSeries_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) { 873 fieldMask.Set(target.(*BulkTimeSeries), source.(*BulkTimeSeries)) 874 } 875 876 func (fieldMask *BulkTimeSeries_FieldMask) Project(source *BulkTimeSeries) *BulkTimeSeries { 877 if source == nil { 878 return nil 879 } 880 if fieldMask == nil { 881 return source 882 } 883 result := &BulkTimeSeries{} 884 timeSeriesMask := &TimeSerie_FieldMask{} 885 wholeTimeSeriesAccepted := false 886 887 for _, p := range fieldMask.Paths { 888 switch tp := p.(type) { 889 case *BulkTimeSeries_FieldTerminalPath: 890 switch tp.selector { 891 case BulkTimeSeries_FieldPathSelectorTimeSeries: 892 result.TimeSeries = source.TimeSeries 893 wholeTimeSeriesAccepted = true 894 case BulkTimeSeries_FieldPathSelectorPhantomFlag: 895 result.PhantomFlag = source.PhantomFlag 896 } 897 case *BulkTimeSeries_FieldSubPath: 898 switch tp.selector { 899 case BulkTimeSeries_FieldPathSelectorTimeSeries: 900 timeSeriesMask.AppendPath(tp.subPath.(TimeSerie_FieldPath)) 901 } 902 } 903 } 904 if wholeTimeSeriesAccepted == false && len(timeSeriesMask.Paths) > 0 { 905 for _, sourceItem := range source.GetTimeSeries() { 906 result.TimeSeries = append(result.TimeSeries, timeSeriesMask.Project(sourceItem)) 907 } 908 } 909 return result 910 } 911 912 func (fieldMask *BulkTimeSeries_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt { 913 return fieldMask.Project(source.(*BulkTimeSeries)) 914 } 915 916 func (fieldMask *BulkTimeSeries_FieldMask) PathsCount() int { 917 if fieldMask == nil { 918 return 0 919 } 920 return len(fieldMask.Paths) 921 }