github.com/cloudwan/edgelq-sdk@v1.15.4/monitoring/resources/v4/time_serie/time_serie.pb.fieldmask.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 "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/v4/common" 23 metric_descriptor "github.com/cloudwan/edgelq-sdk/monitoring/resources/v4/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_FieldPathSelectorUnit}) 351 res.Paths = append(res.Paths, &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorMetric}) 352 res.Paths = append(res.Paths, &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorResource}) 353 res.Paths = append(res.Paths, &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorMetricKind}) 354 res.Paths = append(res.Paths, &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorValueType}) 355 res.Paths = append(res.Paths, &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorPoints}) 356 return res 357 } 358 359 func (fieldMask *TimeSerie_FieldMask) String() string { 360 if fieldMask == nil { 361 return "<nil>" 362 } 363 pathsStr := make([]string, 0, len(fieldMask.Paths)) 364 for _, path := range fieldMask.Paths { 365 pathsStr = append(pathsStr, path.String()) 366 } 367 return strings.Join(pathsStr, ", ") 368 } 369 370 func (fieldMask *TimeSerie_FieldMask) IsFull() bool { 371 if fieldMask == nil { 372 return false 373 } 374 presentSelectors := make([]bool, 9) 375 for _, path := range fieldMask.Paths { 376 if asFinal, ok := path.(*TimeSerie_FieldTerminalPath); ok { 377 presentSelectors[int(asFinal.selector)] = true 378 } 379 } 380 for _, flag := range presentSelectors { 381 if !flag { 382 return false 383 } 384 } 385 return true 386 } 387 388 func (fieldMask *TimeSerie_FieldMask) ProtoReflect() preflect.Message { 389 return gotenobject.MakeFieldMaskReflection(fieldMask, func(raw string) (gotenobject.FieldPath, error) { 390 return ParseTimeSerie_FieldPath(raw) 391 }) 392 } 393 394 func (fieldMask *TimeSerie_FieldMask) ProtoMessage() {} 395 396 func (fieldMask *TimeSerie_FieldMask) Reset() { 397 if fieldMask != nil { 398 fieldMask.Paths = nil 399 } 400 } 401 402 func (fieldMask *TimeSerie_FieldMask) Subtract(other *TimeSerie_FieldMask) *TimeSerie_FieldMask { 403 result := &TimeSerie_FieldMask{} 404 removedSelectors := make([]bool, 9) 405 otherSubMasks := map[TimeSerie_FieldPathSelector]gotenobject.FieldMask{ 406 TimeSerie_FieldPathSelectorMetric: &common.Metric_FieldMask{}, 407 TimeSerie_FieldPathSelectorResource: &common.MonitoredResource_FieldMask{}, 408 TimeSerie_FieldPathSelectorPoints: &Point_FieldMask{}, 409 } 410 mySubMasks := map[TimeSerie_FieldPathSelector]gotenobject.FieldMask{ 411 TimeSerie_FieldPathSelectorMetric: &common.Metric_FieldMask{}, 412 TimeSerie_FieldPathSelectorResource: &common.MonitoredResource_FieldMask{}, 413 TimeSerie_FieldPathSelectorPoints: &Point_FieldMask{}, 414 } 415 416 for _, path := range other.GetPaths() { 417 switch tp := path.(type) { 418 case *TimeSerie_FieldTerminalPath: 419 removedSelectors[int(tp.selector)] = true 420 case *TimeSerie_FieldSubPath: 421 otherSubMasks[tp.selector].AppendRawPath(tp.subPath) 422 } 423 } 424 for _, path := range fieldMask.GetPaths() { 425 if !removedSelectors[int(path.Selector())] { 426 if otherSubMask := otherSubMasks[path.Selector()]; otherSubMask != nil && otherSubMask.PathsCount() > 0 { 427 if tp, ok := path.(*TimeSerie_FieldTerminalPath); ok { 428 switch tp.selector { 429 case TimeSerie_FieldPathSelectorMetric: 430 mySubMasks[TimeSerie_FieldPathSelectorMetric] = common.FullMetric_FieldMask() 431 case TimeSerie_FieldPathSelectorResource: 432 mySubMasks[TimeSerie_FieldPathSelectorResource] = common.FullMonitoredResource_FieldMask() 433 case TimeSerie_FieldPathSelectorPoints: 434 mySubMasks[TimeSerie_FieldPathSelectorPoints] = FullPoint_FieldMask() 435 } 436 } else if tp, ok := path.(*TimeSerie_FieldSubPath); ok { 437 mySubMasks[tp.selector].AppendRawPath(tp.subPath) 438 } 439 } else { 440 result.Paths = append(result.Paths, path) 441 } 442 } 443 } 444 for selector, mySubMask := range mySubMasks { 445 if mySubMask.PathsCount() > 0 { 446 for _, allowedPath := range mySubMask.SubtractRaw(otherSubMasks[selector]).GetRawPaths() { 447 result.Paths = append(result.Paths, &TimeSerie_FieldSubPath{selector: selector, subPath: allowedPath}) 448 } 449 } 450 } 451 452 if len(result.Paths) == 0 { 453 return nil 454 } 455 return result 456 } 457 458 func (fieldMask *TimeSerie_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask { 459 return fieldMask.Subtract(other.(*TimeSerie_FieldMask)) 460 } 461 462 // FilterInputFields generates copy of field paths with output_only field paths removed 463 func (fieldMask *TimeSerie_FieldMask) FilterInputFields() *TimeSerie_FieldMask { 464 result := &TimeSerie_FieldMask{} 465 result.Paths = append(result.Paths, fieldMask.Paths...) 466 return result 467 } 468 469 // ToFieldMask is used for proto conversions 470 func (fieldMask *TimeSerie_FieldMask) ToProtoFieldMask() *googlefieldmaskpb.FieldMask { 471 protoFieldMask := &googlefieldmaskpb.FieldMask{} 472 for _, path := range fieldMask.Paths { 473 protoFieldMask.Paths = append(protoFieldMask.Paths, path.String()) 474 } 475 return protoFieldMask 476 } 477 478 func (fieldMask *TimeSerie_FieldMask) FromProtoFieldMask(protoFieldMask *googlefieldmaskpb.FieldMask) error { 479 if fieldMask == nil { 480 return status.Error(codes.Internal, "target field mask is nil") 481 } 482 fieldMask.Paths = make([]TimeSerie_FieldPath, 0, len(protoFieldMask.Paths)) 483 for _, strPath := range protoFieldMask.Paths { 484 path, err := ParseTimeSerie_FieldPath(strPath) 485 if err != nil { 486 return err 487 } 488 fieldMask.Paths = append(fieldMask.Paths, path) 489 } 490 return nil 491 } 492 493 // implement methods required by customType 494 func (fieldMask TimeSerie_FieldMask) Marshal() ([]byte, error) { 495 protoFieldMask := fieldMask.ToProtoFieldMask() 496 return proto.Marshal(protoFieldMask) 497 } 498 499 func (fieldMask *TimeSerie_FieldMask) Unmarshal(data []byte) error { 500 protoFieldMask := &googlefieldmaskpb.FieldMask{} 501 if err := proto.Unmarshal(data, protoFieldMask); err != nil { 502 return err 503 } 504 if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil { 505 return err 506 } 507 return nil 508 } 509 510 func (fieldMask *TimeSerie_FieldMask) Size() int { 511 return proto.Size(fieldMask.ToProtoFieldMask()) 512 } 513 514 func (fieldMask TimeSerie_FieldMask) MarshalJSON() ([]byte, error) { 515 return json.Marshal(fieldMask.ToProtoFieldMask()) 516 } 517 518 func (fieldMask *TimeSerie_FieldMask) UnmarshalJSON(data []byte) error { 519 protoFieldMask := &googlefieldmaskpb.FieldMask{} 520 if err := json.Unmarshal(data, protoFieldMask); err != nil { 521 return err 522 } 523 if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil { 524 return err 525 } 526 return nil 527 } 528 529 func (fieldMask *TimeSerie_FieldMask) AppendPath(path TimeSerie_FieldPath) { 530 fieldMask.Paths = append(fieldMask.Paths, path) 531 } 532 533 func (fieldMask *TimeSerie_FieldMask) AppendRawPath(path gotenobject.FieldPath) { 534 fieldMask.Paths = append(fieldMask.Paths, path.(TimeSerie_FieldPath)) 535 } 536 537 func (fieldMask *TimeSerie_FieldMask) GetPaths() []TimeSerie_FieldPath { 538 if fieldMask == nil { 539 return nil 540 } 541 return fieldMask.Paths 542 } 543 544 func (fieldMask *TimeSerie_FieldMask) GetRawPaths() []gotenobject.FieldPath { 545 if fieldMask == nil { 546 return nil 547 } 548 rawPaths := make([]gotenobject.FieldPath, 0, len(fieldMask.Paths)) 549 for _, path := range fieldMask.Paths { 550 rawPaths = append(rawPaths, path) 551 } 552 return rawPaths 553 } 554 555 func (fieldMask *TimeSerie_FieldMask) SetFromCliFlag(raw string) error { 556 path, err := ParseTimeSerie_FieldPath(raw) 557 if err != nil { 558 return err 559 } 560 fieldMask.Paths = append(fieldMask.Paths, path) 561 return nil 562 } 563 564 func (fieldMask *TimeSerie_FieldMask) Set(target, source *TimeSerie) { 565 for _, path := range fieldMask.Paths { 566 val, _ := path.GetSingle(source) 567 // if val is nil, then field does not exist in source, skip 568 // otherwise, process (can still reflect.ValueOf(val).IsNil!) 569 if val != nil { 570 path.WithIValue(val).SetTo(&target) 571 } 572 } 573 } 574 575 func (fieldMask *TimeSerie_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) { 576 fieldMask.Set(target.(*TimeSerie), source.(*TimeSerie)) 577 } 578 579 func (fieldMask *TimeSerie_FieldMask) Project(source *TimeSerie) *TimeSerie { 580 if source == nil { 581 return nil 582 } 583 if fieldMask == nil { 584 return source 585 } 586 result := &TimeSerie{} 587 metricMask := &common.Metric_FieldMask{} 588 wholeMetricAccepted := false 589 resourceMask := &common.MonitoredResource_FieldMask{} 590 wholeResourceAccepted := false 591 pointsMask := &Point_FieldMask{} 592 wholePointsAccepted := false 593 594 for _, p := range fieldMask.Paths { 595 switch tp := p.(type) { 596 case *TimeSerie_FieldTerminalPath: 597 switch tp.selector { 598 case TimeSerie_FieldPathSelectorKey: 599 result.Key = source.Key 600 case TimeSerie_FieldPathSelectorProject: 601 result.Project = source.Project 602 case TimeSerie_FieldPathSelectorRegion: 603 result.Region = source.Region 604 case TimeSerie_FieldPathSelectorUnit: 605 result.Unit = source.Unit 606 case TimeSerie_FieldPathSelectorMetric: 607 result.Metric = source.Metric 608 wholeMetricAccepted = true 609 case TimeSerie_FieldPathSelectorResource: 610 result.Resource = source.Resource 611 wholeResourceAccepted = true 612 case TimeSerie_FieldPathSelectorMetricKind: 613 result.MetricKind = source.MetricKind 614 case TimeSerie_FieldPathSelectorValueType: 615 result.ValueType = source.ValueType 616 case TimeSerie_FieldPathSelectorPoints: 617 result.Points = source.Points 618 wholePointsAccepted = true 619 } 620 case *TimeSerie_FieldSubPath: 621 switch tp.selector { 622 case TimeSerie_FieldPathSelectorMetric: 623 metricMask.AppendPath(tp.subPath.(common.Metric_FieldPath)) 624 case TimeSerie_FieldPathSelectorResource: 625 resourceMask.AppendPath(tp.subPath.(common.MonitoredResource_FieldPath)) 626 case TimeSerie_FieldPathSelectorPoints: 627 pointsMask.AppendPath(tp.subPath.(Point_FieldPath)) 628 } 629 } 630 } 631 if wholeMetricAccepted == false && len(metricMask.Paths) > 0 { 632 result.Metric = metricMask.Project(source.GetMetric()) 633 } 634 if wholeResourceAccepted == false && len(resourceMask.Paths) > 0 { 635 result.Resource = resourceMask.Project(source.GetResource()) 636 } 637 if wholePointsAccepted == false && len(pointsMask.Paths) > 0 { 638 for _, sourceItem := range source.GetPoints() { 639 result.Points = append(result.Points, pointsMask.Project(sourceItem)) 640 } 641 } 642 return result 643 } 644 645 func (fieldMask *TimeSerie_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt { 646 return fieldMask.Project(source.(*TimeSerie)) 647 } 648 649 func (fieldMask *TimeSerie_FieldMask) PathsCount() int { 650 if fieldMask == nil { 651 return 0 652 } 653 return len(fieldMask.Paths) 654 } 655 656 type BulkTimeSeries_FieldMask struct { 657 Paths []BulkTimeSeries_FieldPath 658 } 659 660 func FullBulkTimeSeries_FieldMask() *BulkTimeSeries_FieldMask { 661 res := &BulkTimeSeries_FieldMask{} 662 res.Paths = append(res.Paths, &BulkTimeSeries_FieldTerminalPath{selector: BulkTimeSeries_FieldPathSelectorTimeSeries}) 663 res.Paths = append(res.Paths, &BulkTimeSeries_FieldTerminalPath{selector: BulkTimeSeries_FieldPathSelectorPhantomFlag}) 664 return res 665 } 666 667 func (fieldMask *BulkTimeSeries_FieldMask) String() string { 668 if fieldMask == nil { 669 return "<nil>" 670 } 671 pathsStr := make([]string, 0, len(fieldMask.Paths)) 672 for _, path := range fieldMask.Paths { 673 pathsStr = append(pathsStr, path.String()) 674 } 675 return strings.Join(pathsStr, ", ") 676 } 677 678 func (fieldMask *BulkTimeSeries_FieldMask) IsFull() bool { 679 if fieldMask == nil { 680 return false 681 } 682 presentSelectors := make([]bool, 2) 683 for _, path := range fieldMask.Paths { 684 if asFinal, ok := path.(*BulkTimeSeries_FieldTerminalPath); ok { 685 presentSelectors[int(asFinal.selector)] = true 686 } 687 } 688 for _, flag := range presentSelectors { 689 if !flag { 690 return false 691 } 692 } 693 return true 694 } 695 696 func (fieldMask *BulkTimeSeries_FieldMask) ProtoReflect() preflect.Message { 697 return gotenobject.MakeFieldMaskReflection(fieldMask, func(raw string) (gotenobject.FieldPath, error) { 698 return ParseBulkTimeSeries_FieldPath(raw) 699 }) 700 } 701 702 func (fieldMask *BulkTimeSeries_FieldMask) ProtoMessage() {} 703 704 func (fieldMask *BulkTimeSeries_FieldMask) Reset() { 705 if fieldMask != nil { 706 fieldMask.Paths = nil 707 } 708 } 709 710 func (fieldMask *BulkTimeSeries_FieldMask) Subtract(other *BulkTimeSeries_FieldMask) *BulkTimeSeries_FieldMask { 711 result := &BulkTimeSeries_FieldMask{} 712 removedSelectors := make([]bool, 2) 713 otherSubMasks := map[BulkTimeSeries_FieldPathSelector]gotenobject.FieldMask{ 714 BulkTimeSeries_FieldPathSelectorTimeSeries: &TimeSerie_FieldMask{}, 715 } 716 mySubMasks := map[BulkTimeSeries_FieldPathSelector]gotenobject.FieldMask{ 717 BulkTimeSeries_FieldPathSelectorTimeSeries: &TimeSerie_FieldMask{}, 718 } 719 720 for _, path := range other.GetPaths() { 721 switch tp := path.(type) { 722 case *BulkTimeSeries_FieldTerminalPath: 723 removedSelectors[int(tp.selector)] = true 724 case *BulkTimeSeries_FieldSubPath: 725 otherSubMasks[tp.selector].AppendRawPath(tp.subPath) 726 } 727 } 728 for _, path := range fieldMask.GetPaths() { 729 if !removedSelectors[int(path.Selector())] { 730 if otherSubMask := otherSubMasks[path.Selector()]; otherSubMask != nil && otherSubMask.PathsCount() > 0 { 731 if tp, ok := path.(*BulkTimeSeries_FieldTerminalPath); ok { 732 switch tp.selector { 733 case BulkTimeSeries_FieldPathSelectorTimeSeries: 734 mySubMasks[BulkTimeSeries_FieldPathSelectorTimeSeries] = FullTimeSerie_FieldMask() 735 } 736 } else if tp, ok := path.(*BulkTimeSeries_FieldSubPath); ok { 737 mySubMasks[tp.selector].AppendRawPath(tp.subPath) 738 } 739 } else { 740 result.Paths = append(result.Paths, path) 741 } 742 } 743 } 744 for selector, mySubMask := range mySubMasks { 745 if mySubMask.PathsCount() > 0 { 746 for _, allowedPath := range mySubMask.SubtractRaw(otherSubMasks[selector]).GetRawPaths() { 747 result.Paths = append(result.Paths, &BulkTimeSeries_FieldSubPath{selector: selector, subPath: allowedPath}) 748 } 749 } 750 } 751 752 if len(result.Paths) == 0 { 753 return nil 754 } 755 return result 756 } 757 758 func (fieldMask *BulkTimeSeries_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask { 759 return fieldMask.Subtract(other.(*BulkTimeSeries_FieldMask)) 760 } 761 762 // FilterInputFields generates copy of field paths with output_only field paths removed 763 func (fieldMask *BulkTimeSeries_FieldMask) FilterInputFields() *BulkTimeSeries_FieldMask { 764 result := &BulkTimeSeries_FieldMask{} 765 result.Paths = append(result.Paths, fieldMask.Paths...) 766 return result 767 } 768 769 // ToFieldMask is used for proto conversions 770 func (fieldMask *BulkTimeSeries_FieldMask) ToProtoFieldMask() *googlefieldmaskpb.FieldMask { 771 protoFieldMask := &googlefieldmaskpb.FieldMask{} 772 for _, path := range fieldMask.Paths { 773 protoFieldMask.Paths = append(protoFieldMask.Paths, path.String()) 774 } 775 return protoFieldMask 776 } 777 778 func (fieldMask *BulkTimeSeries_FieldMask) FromProtoFieldMask(protoFieldMask *googlefieldmaskpb.FieldMask) error { 779 if fieldMask == nil { 780 return status.Error(codes.Internal, "target field mask is nil") 781 } 782 fieldMask.Paths = make([]BulkTimeSeries_FieldPath, 0, len(protoFieldMask.Paths)) 783 for _, strPath := range protoFieldMask.Paths { 784 path, err := ParseBulkTimeSeries_FieldPath(strPath) 785 if err != nil { 786 return err 787 } 788 fieldMask.Paths = append(fieldMask.Paths, path) 789 } 790 return nil 791 } 792 793 // implement methods required by customType 794 func (fieldMask BulkTimeSeries_FieldMask) Marshal() ([]byte, error) { 795 protoFieldMask := fieldMask.ToProtoFieldMask() 796 return proto.Marshal(protoFieldMask) 797 } 798 799 func (fieldMask *BulkTimeSeries_FieldMask) Unmarshal(data []byte) error { 800 protoFieldMask := &googlefieldmaskpb.FieldMask{} 801 if err := proto.Unmarshal(data, protoFieldMask); err != nil { 802 return err 803 } 804 if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil { 805 return err 806 } 807 return nil 808 } 809 810 func (fieldMask *BulkTimeSeries_FieldMask) Size() int { 811 return proto.Size(fieldMask.ToProtoFieldMask()) 812 } 813 814 func (fieldMask BulkTimeSeries_FieldMask) MarshalJSON() ([]byte, error) { 815 return json.Marshal(fieldMask.ToProtoFieldMask()) 816 } 817 818 func (fieldMask *BulkTimeSeries_FieldMask) UnmarshalJSON(data []byte) error { 819 protoFieldMask := &googlefieldmaskpb.FieldMask{} 820 if err := json.Unmarshal(data, protoFieldMask); err != nil { 821 return err 822 } 823 if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil { 824 return err 825 } 826 return nil 827 } 828 829 func (fieldMask *BulkTimeSeries_FieldMask) AppendPath(path BulkTimeSeries_FieldPath) { 830 fieldMask.Paths = append(fieldMask.Paths, path) 831 } 832 833 func (fieldMask *BulkTimeSeries_FieldMask) AppendRawPath(path gotenobject.FieldPath) { 834 fieldMask.Paths = append(fieldMask.Paths, path.(BulkTimeSeries_FieldPath)) 835 } 836 837 func (fieldMask *BulkTimeSeries_FieldMask) GetPaths() []BulkTimeSeries_FieldPath { 838 if fieldMask == nil { 839 return nil 840 } 841 return fieldMask.Paths 842 } 843 844 func (fieldMask *BulkTimeSeries_FieldMask) GetRawPaths() []gotenobject.FieldPath { 845 if fieldMask == nil { 846 return nil 847 } 848 rawPaths := make([]gotenobject.FieldPath, 0, len(fieldMask.Paths)) 849 for _, path := range fieldMask.Paths { 850 rawPaths = append(rawPaths, path) 851 } 852 return rawPaths 853 } 854 855 func (fieldMask *BulkTimeSeries_FieldMask) SetFromCliFlag(raw string) error { 856 path, err := ParseBulkTimeSeries_FieldPath(raw) 857 if err != nil { 858 return err 859 } 860 fieldMask.Paths = append(fieldMask.Paths, path) 861 return nil 862 } 863 864 func (fieldMask *BulkTimeSeries_FieldMask) Set(target, source *BulkTimeSeries) { 865 for _, path := range fieldMask.Paths { 866 val, _ := path.GetSingle(source) 867 // if val is nil, then field does not exist in source, skip 868 // otherwise, process (can still reflect.ValueOf(val).IsNil!) 869 if val != nil { 870 path.WithIValue(val).SetTo(&target) 871 } 872 } 873 } 874 875 func (fieldMask *BulkTimeSeries_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) { 876 fieldMask.Set(target.(*BulkTimeSeries), source.(*BulkTimeSeries)) 877 } 878 879 func (fieldMask *BulkTimeSeries_FieldMask) Project(source *BulkTimeSeries) *BulkTimeSeries { 880 if source == nil { 881 return nil 882 } 883 if fieldMask == nil { 884 return source 885 } 886 result := &BulkTimeSeries{} 887 timeSeriesMask := &TimeSerie_FieldMask{} 888 wholeTimeSeriesAccepted := false 889 890 for _, p := range fieldMask.Paths { 891 switch tp := p.(type) { 892 case *BulkTimeSeries_FieldTerminalPath: 893 switch tp.selector { 894 case BulkTimeSeries_FieldPathSelectorTimeSeries: 895 result.TimeSeries = source.TimeSeries 896 wholeTimeSeriesAccepted = true 897 case BulkTimeSeries_FieldPathSelectorPhantomFlag: 898 result.PhantomFlag = source.PhantomFlag 899 } 900 case *BulkTimeSeries_FieldSubPath: 901 switch tp.selector { 902 case BulkTimeSeries_FieldPathSelectorTimeSeries: 903 timeSeriesMask.AppendPath(tp.subPath.(TimeSerie_FieldPath)) 904 } 905 } 906 } 907 if wholeTimeSeriesAccepted == false && len(timeSeriesMask.Paths) > 0 { 908 for _, sourceItem := range source.GetTimeSeries() { 909 result.TimeSeries = append(result.TimeSeries, timeSeriesMask.Project(sourceItem)) 910 } 911 } 912 return result 913 } 914 915 func (fieldMask *BulkTimeSeries_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt { 916 return fieldMask.Project(source.(*BulkTimeSeries)) 917 } 918 919 func (fieldMask *BulkTimeSeries_FieldMask) PathsCount() int { 920 if fieldMask == nil { 921 return 0 922 } 923 return len(fieldMask.Paths) 924 }