github.com/cloudwan/edgelq-sdk@v1.15.4/monitoring/resources/v4/bucket/bucket.pb.fieldmask.go (about) 1 // Code generated by protoc-gen-goten-object 2 // File: edgelq/monitoring/proto/v4/bucket.proto 3 // DO NOT EDIT!!! 4 5 package bucket 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 project "github.com/cloudwan/edgelq-sdk/monitoring/resources/v4/project" 23 meta "github.com/cloudwan/goten-sdk/types/meta" 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 _ = &project.Project{} 43 _ = &meta.Meta{} 44 ) 45 46 type Bucket_FieldMask struct { 47 Paths []Bucket_FieldPath 48 } 49 50 func FullBucket_FieldMask() *Bucket_FieldMask { 51 res := &Bucket_FieldMask{} 52 res.Paths = append(res.Paths, &Bucket_FieldTerminalPath{selector: Bucket_FieldPathSelectorName}) 53 res.Paths = append(res.Paths, &Bucket_FieldTerminalPath{selector: Bucket_FieldPathSelectorMetadata}) 54 res.Paths = append(res.Paths, &Bucket_FieldTerminalPath{selector: Bucket_FieldPathSelectorMetrics}) 55 res.Paths = append(res.Paths, &Bucket_FieldTerminalPath{selector: Bucket_FieldPathSelectorResources}) 56 res.Paths = append(res.Paths, &Bucket_FieldTerminalPath{selector: Bucket_FieldPathSelectorRequiredAltKvs}) 57 return res 58 } 59 60 func (fieldMask *Bucket_FieldMask) String() string { 61 if fieldMask == nil { 62 return "<nil>" 63 } 64 pathsStr := make([]string, 0, len(fieldMask.Paths)) 65 for _, path := range fieldMask.Paths { 66 pathsStr = append(pathsStr, path.String()) 67 } 68 return strings.Join(pathsStr, ", ") 69 } 70 71 func (fieldMask *Bucket_FieldMask) IsFull() bool { 72 if fieldMask == nil { 73 return false 74 } 75 presentSelectors := make([]bool, 5) 76 for _, path := range fieldMask.Paths { 77 if asFinal, ok := path.(*Bucket_FieldTerminalPath); ok { 78 presentSelectors[int(asFinal.selector)] = true 79 } 80 } 81 for _, flag := range presentSelectors { 82 if !flag { 83 return false 84 } 85 } 86 return true 87 } 88 89 func (fieldMask *Bucket_FieldMask) ProtoReflect() preflect.Message { 90 return gotenobject.MakeFieldMaskReflection(fieldMask, func(raw string) (gotenobject.FieldPath, error) { 91 return ParseBucket_FieldPath(raw) 92 }) 93 } 94 95 func (fieldMask *Bucket_FieldMask) ProtoMessage() {} 96 97 func (fieldMask *Bucket_FieldMask) Reset() { 98 if fieldMask != nil { 99 fieldMask.Paths = nil 100 } 101 } 102 103 func (fieldMask *Bucket_FieldMask) Subtract(other *Bucket_FieldMask) *Bucket_FieldMask { 104 result := &Bucket_FieldMask{} 105 removedSelectors := make([]bool, 5) 106 otherSubMasks := map[Bucket_FieldPathSelector]gotenobject.FieldMask{ 107 Bucket_FieldPathSelectorMetadata: &meta.Meta_FieldMask{}, 108 Bucket_FieldPathSelectorMetrics: &Bucket_RequiredTypedLabels_FieldMask{}, 109 Bucket_FieldPathSelectorResources: &Bucket_RequiredTypedLabels_FieldMask{}, 110 Bucket_FieldPathSelectorRequiredAltKvs: &Bucket_ResolvedKeysWithValues_FieldMask{}, 111 } 112 mySubMasks := map[Bucket_FieldPathSelector]gotenobject.FieldMask{ 113 Bucket_FieldPathSelectorMetadata: &meta.Meta_FieldMask{}, 114 Bucket_FieldPathSelectorMetrics: &Bucket_RequiredTypedLabels_FieldMask{}, 115 Bucket_FieldPathSelectorResources: &Bucket_RequiredTypedLabels_FieldMask{}, 116 Bucket_FieldPathSelectorRequiredAltKvs: &Bucket_ResolvedKeysWithValues_FieldMask{}, 117 } 118 119 for _, path := range other.GetPaths() { 120 switch tp := path.(type) { 121 case *Bucket_FieldTerminalPath: 122 removedSelectors[int(tp.selector)] = true 123 case *Bucket_FieldSubPath: 124 otherSubMasks[tp.selector].AppendRawPath(tp.subPath) 125 } 126 } 127 for _, path := range fieldMask.GetPaths() { 128 if !removedSelectors[int(path.Selector())] { 129 if otherSubMask := otherSubMasks[path.Selector()]; otherSubMask != nil && otherSubMask.PathsCount() > 0 { 130 if tp, ok := path.(*Bucket_FieldTerminalPath); ok { 131 switch tp.selector { 132 case Bucket_FieldPathSelectorMetadata: 133 mySubMasks[Bucket_FieldPathSelectorMetadata] = meta.FullMeta_FieldMask() 134 case Bucket_FieldPathSelectorMetrics: 135 mySubMasks[Bucket_FieldPathSelectorMetrics] = FullBucket_RequiredTypedLabels_FieldMask() 136 case Bucket_FieldPathSelectorResources: 137 mySubMasks[Bucket_FieldPathSelectorResources] = FullBucket_RequiredTypedLabels_FieldMask() 138 case Bucket_FieldPathSelectorRequiredAltKvs: 139 mySubMasks[Bucket_FieldPathSelectorRequiredAltKvs] = FullBucket_ResolvedKeysWithValues_FieldMask() 140 } 141 } else if tp, ok := path.(*Bucket_FieldSubPath); ok { 142 mySubMasks[tp.selector].AppendRawPath(tp.subPath) 143 } 144 } else { 145 result.Paths = append(result.Paths, path) 146 } 147 } 148 } 149 for selector, mySubMask := range mySubMasks { 150 if mySubMask.PathsCount() > 0 { 151 for _, allowedPath := range mySubMask.SubtractRaw(otherSubMasks[selector]).GetRawPaths() { 152 result.Paths = append(result.Paths, &Bucket_FieldSubPath{selector: selector, subPath: allowedPath}) 153 } 154 } 155 } 156 157 if len(result.Paths) == 0 { 158 return nil 159 } 160 return result 161 } 162 163 func (fieldMask *Bucket_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask { 164 return fieldMask.Subtract(other.(*Bucket_FieldMask)) 165 } 166 167 // FilterInputFields generates copy of field paths with output_only field paths removed 168 func (fieldMask *Bucket_FieldMask) FilterInputFields() *Bucket_FieldMask { 169 result := &Bucket_FieldMask{} 170 for _, path := range fieldMask.Paths { 171 switch path.Selector() { 172 case Bucket_FieldPathSelectorRequiredAltKvs: 173 case Bucket_FieldPathSelectorMetadata: 174 if _, ok := path.(*Bucket_FieldTerminalPath); ok { 175 for _, subpath := range meta.FullMeta_FieldMask().FilterInputFields().Paths { 176 result.Paths = append(result.Paths, &Bucket_FieldSubPath{selector: path.Selector(), subPath: subpath}) 177 } 178 } else if sub, ok := path.(*Bucket_FieldSubPath); ok { 179 selectedMask := &meta.Meta_FieldMask{ 180 Paths: []meta.Meta_FieldPath{sub.subPath.(meta.Meta_FieldPath)}, 181 } 182 for _, allowedPath := range selectedMask.FilterInputFields().Paths { 183 result.Paths = append(result.Paths, &Bucket_FieldSubPath{selector: Bucket_FieldPathSelectorMetadata, subPath: allowedPath}) 184 } 185 } 186 default: 187 result.Paths = append(result.Paths, path) 188 } 189 } 190 return result 191 } 192 193 // ToFieldMask is used for proto conversions 194 func (fieldMask *Bucket_FieldMask) ToProtoFieldMask() *googlefieldmaskpb.FieldMask { 195 protoFieldMask := &googlefieldmaskpb.FieldMask{} 196 for _, path := range fieldMask.Paths { 197 protoFieldMask.Paths = append(protoFieldMask.Paths, path.String()) 198 } 199 return protoFieldMask 200 } 201 202 func (fieldMask *Bucket_FieldMask) FromProtoFieldMask(protoFieldMask *googlefieldmaskpb.FieldMask) error { 203 if fieldMask == nil { 204 return status.Error(codes.Internal, "target field mask is nil") 205 } 206 fieldMask.Paths = make([]Bucket_FieldPath, 0, len(protoFieldMask.Paths)) 207 for _, strPath := range protoFieldMask.Paths { 208 path, err := ParseBucket_FieldPath(strPath) 209 if err != nil { 210 return err 211 } 212 fieldMask.Paths = append(fieldMask.Paths, path) 213 } 214 return nil 215 } 216 217 // implement methods required by customType 218 func (fieldMask Bucket_FieldMask) Marshal() ([]byte, error) { 219 protoFieldMask := fieldMask.ToProtoFieldMask() 220 return proto.Marshal(protoFieldMask) 221 } 222 223 func (fieldMask *Bucket_FieldMask) Unmarshal(data []byte) error { 224 protoFieldMask := &googlefieldmaskpb.FieldMask{} 225 if err := proto.Unmarshal(data, protoFieldMask); err != nil { 226 return err 227 } 228 if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil { 229 return err 230 } 231 return nil 232 } 233 234 func (fieldMask *Bucket_FieldMask) Size() int { 235 return proto.Size(fieldMask.ToProtoFieldMask()) 236 } 237 238 func (fieldMask Bucket_FieldMask) MarshalJSON() ([]byte, error) { 239 return json.Marshal(fieldMask.ToProtoFieldMask()) 240 } 241 242 func (fieldMask *Bucket_FieldMask) UnmarshalJSON(data []byte) error { 243 protoFieldMask := &googlefieldmaskpb.FieldMask{} 244 if err := json.Unmarshal(data, protoFieldMask); err != nil { 245 return err 246 } 247 if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil { 248 return err 249 } 250 return nil 251 } 252 253 func (fieldMask *Bucket_FieldMask) AppendPath(path Bucket_FieldPath) { 254 fieldMask.Paths = append(fieldMask.Paths, path) 255 } 256 257 func (fieldMask *Bucket_FieldMask) AppendRawPath(path gotenobject.FieldPath) { 258 fieldMask.Paths = append(fieldMask.Paths, path.(Bucket_FieldPath)) 259 } 260 261 func (fieldMask *Bucket_FieldMask) GetPaths() []Bucket_FieldPath { 262 if fieldMask == nil { 263 return nil 264 } 265 return fieldMask.Paths 266 } 267 268 func (fieldMask *Bucket_FieldMask) GetRawPaths() []gotenobject.FieldPath { 269 if fieldMask == nil { 270 return nil 271 } 272 rawPaths := make([]gotenobject.FieldPath, 0, len(fieldMask.Paths)) 273 for _, path := range fieldMask.Paths { 274 rawPaths = append(rawPaths, path) 275 } 276 return rawPaths 277 } 278 279 func (fieldMask *Bucket_FieldMask) SetFromCliFlag(raw string) error { 280 path, err := ParseBucket_FieldPath(raw) 281 if err != nil { 282 return err 283 } 284 fieldMask.Paths = append(fieldMask.Paths, path) 285 return nil 286 } 287 288 func (fieldMask *Bucket_FieldMask) Set(target, source *Bucket) { 289 for _, path := range fieldMask.Paths { 290 val, _ := path.GetSingle(source) 291 // if val is nil, then field does not exist in source, skip 292 // otherwise, process (can still reflect.ValueOf(val).IsNil!) 293 if val != nil { 294 path.WithIValue(val).SetTo(&target) 295 } 296 } 297 } 298 299 func (fieldMask *Bucket_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) { 300 fieldMask.Set(target.(*Bucket), source.(*Bucket)) 301 } 302 303 func (fieldMask *Bucket_FieldMask) Project(source *Bucket) *Bucket { 304 if source == nil { 305 return nil 306 } 307 if fieldMask == nil { 308 return source 309 } 310 result := &Bucket{} 311 metadataMask := &meta.Meta_FieldMask{} 312 wholeMetadataAccepted := false 313 metricsMask := &Bucket_RequiredTypedLabels_FieldMask{} 314 wholeMetricsAccepted := false 315 resourcesMask := &Bucket_RequiredTypedLabels_FieldMask{} 316 wholeResourcesAccepted := false 317 requiredAltKvsMask := &Bucket_ResolvedKeysWithValues_FieldMask{} 318 wholeRequiredAltKvsAccepted := false 319 320 for _, p := range fieldMask.Paths { 321 switch tp := p.(type) { 322 case *Bucket_FieldTerminalPath: 323 switch tp.selector { 324 case Bucket_FieldPathSelectorName: 325 result.Name = source.Name 326 case Bucket_FieldPathSelectorMetadata: 327 result.Metadata = source.Metadata 328 wholeMetadataAccepted = true 329 case Bucket_FieldPathSelectorMetrics: 330 result.Metrics = source.Metrics 331 wholeMetricsAccepted = true 332 case Bucket_FieldPathSelectorResources: 333 result.Resources = source.Resources 334 wholeResourcesAccepted = true 335 case Bucket_FieldPathSelectorRequiredAltKvs: 336 result.RequiredAltKvs = source.RequiredAltKvs 337 wholeRequiredAltKvsAccepted = true 338 } 339 case *Bucket_FieldSubPath: 340 switch tp.selector { 341 case Bucket_FieldPathSelectorMetadata: 342 metadataMask.AppendPath(tp.subPath.(meta.Meta_FieldPath)) 343 case Bucket_FieldPathSelectorMetrics: 344 metricsMask.AppendPath(tp.subPath.(BucketRequiredTypedLabels_FieldPath)) 345 case Bucket_FieldPathSelectorResources: 346 resourcesMask.AppendPath(tp.subPath.(BucketRequiredTypedLabels_FieldPath)) 347 case Bucket_FieldPathSelectorRequiredAltKvs: 348 requiredAltKvsMask.AppendPath(tp.subPath.(BucketResolvedKeysWithValues_FieldPath)) 349 } 350 } 351 } 352 if wholeMetadataAccepted == false && len(metadataMask.Paths) > 0 { 353 result.Metadata = metadataMask.Project(source.GetMetadata()) 354 } 355 if wholeMetricsAccepted == false && len(metricsMask.Paths) > 0 { 356 for _, sourceItem := range source.GetMetrics() { 357 result.Metrics = append(result.Metrics, metricsMask.Project(sourceItem)) 358 } 359 } 360 if wholeResourcesAccepted == false && len(resourcesMask.Paths) > 0 { 361 for _, sourceItem := range source.GetResources() { 362 result.Resources = append(result.Resources, resourcesMask.Project(sourceItem)) 363 } 364 } 365 if wholeRequiredAltKvsAccepted == false && len(requiredAltKvsMask.Paths) > 0 { 366 for _, sourceItem := range source.GetRequiredAltKvs() { 367 result.RequiredAltKvs = append(result.RequiredAltKvs, requiredAltKvsMask.Project(sourceItem)) 368 } 369 } 370 return result 371 } 372 373 func (fieldMask *Bucket_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt { 374 return fieldMask.Project(source.(*Bucket)) 375 } 376 377 func (fieldMask *Bucket_FieldMask) PathsCount() int { 378 if fieldMask == nil { 379 return 0 380 } 381 return len(fieldMask.Paths) 382 } 383 384 type Bucket_ResolvedValues_FieldMask struct { 385 Paths []BucketResolvedValues_FieldPath 386 } 387 388 func FullBucket_ResolvedValues_FieldMask() *Bucket_ResolvedValues_FieldMask { 389 res := &Bucket_ResolvedValues_FieldMask{} 390 res.Paths = append(res.Paths, &BucketResolvedValues_FieldTerminalPath{selector: BucketResolvedValues_FieldPathSelectorKey}) 391 res.Paths = append(res.Paths, &BucketResolvedValues_FieldTerminalPath{selector: BucketResolvedValues_FieldPathSelectorValues}) 392 return res 393 } 394 395 func (fieldMask *Bucket_ResolvedValues_FieldMask) String() string { 396 if fieldMask == nil { 397 return "<nil>" 398 } 399 pathsStr := make([]string, 0, len(fieldMask.Paths)) 400 for _, path := range fieldMask.Paths { 401 pathsStr = append(pathsStr, path.String()) 402 } 403 return strings.Join(pathsStr, ", ") 404 } 405 406 func (fieldMask *Bucket_ResolvedValues_FieldMask) IsFull() bool { 407 if fieldMask == nil { 408 return false 409 } 410 presentSelectors := make([]bool, 2) 411 for _, path := range fieldMask.Paths { 412 if asFinal, ok := path.(*BucketResolvedValues_FieldTerminalPath); ok { 413 presentSelectors[int(asFinal.selector)] = true 414 } 415 } 416 for _, flag := range presentSelectors { 417 if !flag { 418 return false 419 } 420 } 421 return true 422 } 423 424 func (fieldMask *Bucket_ResolvedValues_FieldMask) ProtoReflect() preflect.Message { 425 return gotenobject.MakeFieldMaskReflection(fieldMask, func(raw string) (gotenobject.FieldPath, error) { 426 return ParseBucketResolvedValues_FieldPath(raw) 427 }) 428 } 429 430 func (fieldMask *Bucket_ResolvedValues_FieldMask) ProtoMessage() {} 431 432 func (fieldMask *Bucket_ResolvedValues_FieldMask) Reset() { 433 if fieldMask != nil { 434 fieldMask.Paths = nil 435 } 436 } 437 438 func (fieldMask *Bucket_ResolvedValues_FieldMask) Subtract(other *Bucket_ResolvedValues_FieldMask) *Bucket_ResolvedValues_FieldMask { 439 result := &Bucket_ResolvedValues_FieldMask{} 440 removedSelectors := make([]bool, 2) 441 442 for _, path := range other.GetPaths() { 443 switch tp := path.(type) { 444 case *BucketResolvedValues_FieldTerminalPath: 445 removedSelectors[int(tp.selector)] = true 446 } 447 } 448 for _, path := range fieldMask.GetPaths() { 449 if !removedSelectors[int(path.Selector())] { 450 result.Paths = append(result.Paths, path) 451 } 452 } 453 454 if len(result.Paths) == 0 { 455 return nil 456 } 457 return result 458 } 459 460 func (fieldMask *Bucket_ResolvedValues_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask { 461 return fieldMask.Subtract(other.(*Bucket_ResolvedValues_FieldMask)) 462 } 463 464 // FilterInputFields generates copy of field paths with output_only field paths removed 465 func (fieldMask *Bucket_ResolvedValues_FieldMask) FilterInputFields() *Bucket_ResolvedValues_FieldMask { 466 result := &Bucket_ResolvedValues_FieldMask{} 467 result.Paths = append(result.Paths, fieldMask.Paths...) 468 return result 469 } 470 471 // ToFieldMask is used for proto conversions 472 func (fieldMask *Bucket_ResolvedValues_FieldMask) ToProtoFieldMask() *googlefieldmaskpb.FieldMask { 473 protoFieldMask := &googlefieldmaskpb.FieldMask{} 474 for _, path := range fieldMask.Paths { 475 protoFieldMask.Paths = append(protoFieldMask.Paths, path.String()) 476 } 477 return protoFieldMask 478 } 479 480 func (fieldMask *Bucket_ResolvedValues_FieldMask) FromProtoFieldMask(protoFieldMask *googlefieldmaskpb.FieldMask) error { 481 if fieldMask == nil { 482 return status.Error(codes.Internal, "target field mask is nil") 483 } 484 fieldMask.Paths = make([]BucketResolvedValues_FieldPath, 0, len(protoFieldMask.Paths)) 485 for _, strPath := range protoFieldMask.Paths { 486 path, err := ParseBucketResolvedValues_FieldPath(strPath) 487 if err != nil { 488 return err 489 } 490 fieldMask.Paths = append(fieldMask.Paths, path) 491 } 492 return nil 493 } 494 495 // implement methods required by customType 496 func (fieldMask Bucket_ResolvedValues_FieldMask) Marshal() ([]byte, error) { 497 protoFieldMask := fieldMask.ToProtoFieldMask() 498 return proto.Marshal(protoFieldMask) 499 } 500 501 func (fieldMask *Bucket_ResolvedValues_FieldMask) Unmarshal(data []byte) error { 502 protoFieldMask := &googlefieldmaskpb.FieldMask{} 503 if err := proto.Unmarshal(data, protoFieldMask); err != nil { 504 return err 505 } 506 if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil { 507 return err 508 } 509 return nil 510 } 511 512 func (fieldMask *Bucket_ResolvedValues_FieldMask) Size() int { 513 return proto.Size(fieldMask.ToProtoFieldMask()) 514 } 515 516 func (fieldMask Bucket_ResolvedValues_FieldMask) MarshalJSON() ([]byte, error) { 517 return json.Marshal(fieldMask.ToProtoFieldMask()) 518 } 519 520 func (fieldMask *Bucket_ResolvedValues_FieldMask) UnmarshalJSON(data []byte) error { 521 protoFieldMask := &googlefieldmaskpb.FieldMask{} 522 if err := json.Unmarshal(data, protoFieldMask); err != nil { 523 return err 524 } 525 if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil { 526 return err 527 } 528 return nil 529 } 530 531 func (fieldMask *Bucket_ResolvedValues_FieldMask) AppendPath(path BucketResolvedValues_FieldPath) { 532 fieldMask.Paths = append(fieldMask.Paths, path) 533 } 534 535 func (fieldMask *Bucket_ResolvedValues_FieldMask) AppendRawPath(path gotenobject.FieldPath) { 536 fieldMask.Paths = append(fieldMask.Paths, path.(BucketResolvedValues_FieldPath)) 537 } 538 539 func (fieldMask *Bucket_ResolvedValues_FieldMask) GetPaths() []BucketResolvedValues_FieldPath { 540 if fieldMask == nil { 541 return nil 542 } 543 return fieldMask.Paths 544 } 545 546 func (fieldMask *Bucket_ResolvedValues_FieldMask) GetRawPaths() []gotenobject.FieldPath { 547 if fieldMask == nil { 548 return nil 549 } 550 rawPaths := make([]gotenobject.FieldPath, 0, len(fieldMask.Paths)) 551 for _, path := range fieldMask.Paths { 552 rawPaths = append(rawPaths, path) 553 } 554 return rawPaths 555 } 556 557 func (fieldMask *Bucket_ResolvedValues_FieldMask) SetFromCliFlag(raw string) error { 558 path, err := ParseBucketResolvedValues_FieldPath(raw) 559 if err != nil { 560 return err 561 } 562 fieldMask.Paths = append(fieldMask.Paths, path) 563 return nil 564 } 565 566 func (fieldMask *Bucket_ResolvedValues_FieldMask) Set(target, source *Bucket_ResolvedValues) { 567 for _, path := range fieldMask.Paths { 568 val, _ := path.GetSingle(source) 569 // if val is nil, then field does not exist in source, skip 570 // otherwise, process (can still reflect.ValueOf(val).IsNil!) 571 if val != nil { 572 path.WithIValue(val).SetTo(&target) 573 } 574 } 575 } 576 577 func (fieldMask *Bucket_ResolvedValues_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) { 578 fieldMask.Set(target.(*Bucket_ResolvedValues), source.(*Bucket_ResolvedValues)) 579 } 580 581 func (fieldMask *Bucket_ResolvedValues_FieldMask) Project(source *Bucket_ResolvedValues) *Bucket_ResolvedValues { 582 if source == nil { 583 return nil 584 } 585 if fieldMask == nil { 586 return source 587 } 588 result := &Bucket_ResolvedValues{} 589 590 for _, p := range fieldMask.Paths { 591 switch tp := p.(type) { 592 case *BucketResolvedValues_FieldTerminalPath: 593 switch tp.selector { 594 case BucketResolvedValues_FieldPathSelectorKey: 595 result.Key = source.Key 596 case BucketResolvedValues_FieldPathSelectorValues: 597 result.Values = source.Values 598 } 599 } 600 } 601 return result 602 } 603 604 func (fieldMask *Bucket_ResolvedValues_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt { 605 return fieldMask.Project(source.(*Bucket_ResolvedValues)) 606 } 607 608 func (fieldMask *Bucket_ResolvedValues_FieldMask) PathsCount() int { 609 if fieldMask == nil { 610 return 0 611 } 612 return len(fieldMask.Paths) 613 } 614 615 type Bucket_ResolvedKeysWithValues_FieldMask struct { 616 Paths []BucketResolvedKeysWithValues_FieldPath 617 } 618 619 func FullBucket_ResolvedKeysWithValues_FieldMask() *Bucket_ResolvedKeysWithValues_FieldMask { 620 res := &Bucket_ResolvedKeysWithValues_FieldMask{} 621 res.Paths = append(res.Paths, &BucketResolvedKeysWithValues_FieldTerminalPath{selector: BucketResolvedKeysWithValues_FieldPathSelectorResolvedKvs}) 622 return res 623 } 624 625 func (fieldMask *Bucket_ResolvedKeysWithValues_FieldMask) String() string { 626 if fieldMask == nil { 627 return "<nil>" 628 } 629 pathsStr := make([]string, 0, len(fieldMask.Paths)) 630 for _, path := range fieldMask.Paths { 631 pathsStr = append(pathsStr, path.String()) 632 } 633 return strings.Join(pathsStr, ", ") 634 } 635 636 func (fieldMask *Bucket_ResolvedKeysWithValues_FieldMask) IsFull() bool { 637 if fieldMask == nil { 638 return false 639 } 640 presentSelectors := make([]bool, 1) 641 for _, path := range fieldMask.Paths { 642 if asFinal, ok := path.(*BucketResolvedKeysWithValues_FieldTerminalPath); ok { 643 presentSelectors[int(asFinal.selector)] = true 644 } 645 } 646 for _, flag := range presentSelectors { 647 if !flag { 648 return false 649 } 650 } 651 return true 652 } 653 654 func (fieldMask *Bucket_ResolvedKeysWithValues_FieldMask) ProtoReflect() preflect.Message { 655 return gotenobject.MakeFieldMaskReflection(fieldMask, func(raw string) (gotenobject.FieldPath, error) { 656 return ParseBucketResolvedKeysWithValues_FieldPath(raw) 657 }) 658 } 659 660 func (fieldMask *Bucket_ResolvedKeysWithValues_FieldMask) ProtoMessage() {} 661 662 func (fieldMask *Bucket_ResolvedKeysWithValues_FieldMask) Reset() { 663 if fieldMask != nil { 664 fieldMask.Paths = nil 665 } 666 } 667 668 func (fieldMask *Bucket_ResolvedKeysWithValues_FieldMask) Subtract(other *Bucket_ResolvedKeysWithValues_FieldMask) *Bucket_ResolvedKeysWithValues_FieldMask { 669 result := &Bucket_ResolvedKeysWithValues_FieldMask{} 670 removedSelectors := make([]bool, 1) 671 otherSubMasks := map[BucketResolvedKeysWithValues_FieldPathSelector]gotenobject.FieldMask{ 672 BucketResolvedKeysWithValues_FieldPathSelectorResolvedKvs: &Bucket_ResolvedValues_FieldMask{}, 673 } 674 mySubMasks := map[BucketResolvedKeysWithValues_FieldPathSelector]gotenobject.FieldMask{ 675 BucketResolvedKeysWithValues_FieldPathSelectorResolvedKvs: &Bucket_ResolvedValues_FieldMask{}, 676 } 677 678 for _, path := range other.GetPaths() { 679 switch tp := path.(type) { 680 case *BucketResolvedKeysWithValues_FieldTerminalPath: 681 removedSelectors[int(tp.selector)] = true 682 case *BucketResolvedKeysWithValues_FieldSubPath: 683 otherSubMasks[tp.selector].AppendRawPath(tp.subPath) 684 } 685 } 686 for _, path := range fieldMask.GetPaths() { 687 if !removedSelectors[int(path.Selector())] { 688 if otherSubMask := otherSubMasks[path.Selector()]; otherSubMask != nil && otherSubMask.PathsCount() > 0 { 689 if tp, ok := path.(*BucketResolvedKeysWithValues_FieldTerminalPath); ok { 690 switch tp.selector { 691 case BucketResolvedKeysWithValues_FieldPathSelectorResolvedKvs: 692 mySubMasks[BucketResolvedKeysWithValues_FieldPathSelectorResolvedKvs] = FullBucket_ResolvedValues_FieldMask() 693 } 694 } else if tp, ok := path.(*BucketResolvedKeysWithValues_FieldSubPath); ok { 695 mySubMasks[tp.selector].AppendRawPath(tp.subPath) 696 } 697 } else { 698 result.Paths = append(result.Paths, path) 699 } 700 } 701 } 702 for selector, mySubMask := range mySubMasks { 703 if mySubMask.PathsCount() > 0 { 704 for _, allowedPath := range mySubMask.SubtractRaw(otherSubMasks[selector]).GetRawPaths() { 705 result.Paths = append(result.Paths, &BucketResolvedKeysWithValues_FieldSubPath{selector: selector, subPath: allowedPath}) 706 } 707 } 708 } 709 710 if len(result.Paths) == 0 { 711 return nil 712 } 713 return result 714 } 715 716 func (fieldMask *Bucket_ResolvedKeysWithValues_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask { 717 return fieldMask.Subtract(other.(*Bucket_ResolvedKeysWithValues_FieldMask)) 718 } 719 720 // FilterInputFields generates copy of field paths with output_only field paths removed 721 func (fieldMask *Bucket_ResolvedKeysWithValues_FieldMask) FilterInputFields() *Bucket_ResolvedKeysWithValues_FieldMask { 722 result := &Bucket_ResolvedKeysWithValues_FieldMask{} 723 result.Paths = append(result.Paths, fieldMask.Paths...) 724 return result 725 } 726 727 // ToFieldMask is used for proto conversions 728 func (fieldMask *Bucket_ResolvedKeysWithValues_FieldMask) ToProtoFieldMask() *googlefieldmaskpb.FieldMask { 729 protoFieldMask := &googlefieldmaskpb.FieldMask{} 730 for _, path := range fieldMask.Paths { 731 protoFieldMask.Paths = append(protoFieldMask.Paths, path.String()) 732 } 733 return protoFieldMask 734 } 735 736 func (fieldMask *Bucket_ResolvedKeysWithValues_FieldMask) FromProtoFieldMask(protoFieldMask *googlefieldmaskpb.FieldMask) error { 737 if fieldMask == nil { 738 return status.Error(codes.Internal, "target field mask is nil") 739 } 740 fieldMask.Paths = make([]BucketResolvedKeysWithValues_FieldPath, 0, len(protoFieldMask.Paths)) 741 for _, strPath := range protoFieldMask.Paths { 742 path, err := ParseBucketResolvedKeysWithValues_FieldPath(strPath) 743 if err != nil { 744 return err 745 } 746 fieldMask.Paths = append(fieldMask.Paths, path) 747 } 748 return nil 749 } 750 751 // implement methods required by customType 752 func (fieldMask Bucket_ResolvedKeysWithValues_FieldMask) Marshal() ([]byte, error) { 753 protoFieldMask := fieldMask.ToProtoFieldMask() 754 return proto.Marshal(protoFieldMask) 755 } 756 757 func (fieldMask *Bucket_ResolvedKeysWithValues_FieldMask) Unmarshal(data []byte) error { 758 protoFieldMask := &googlefieldmaskpb.FieldMask{} 759 if err := proto.Unmarshal(data, protoFieldMask); err != nil { 760 return err 761 } 762 if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil { 763 return err 764 } 765 return nil 766 } 767 768 func (fieldMask *Bucket_ResolvedKeysWithValues_FieldMask) Size() int { 769 return proto.Size(fieldMask.ToProtoFieldMask()) 770 } 771 772 func (fieldMask Bucket_ResolvedKeysWithValues_FieldMask) MarshalJSON() ([]byte, error) { 773 return json.Marshal(fieldMask.ToProtoFieldMask()) 774 } 775 776 func (fieldMask *Bucket_ResolvedKeysWithValues_FieldMask) UnmarshalJSON(data []byte) error { 777 protoFieldMask := &googlefieldmaskpb.FieldMask{} 778 if err := json.Unmarshal(data, protoFieldMask); err != nil { 779 return err 780 } 781 if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil { 782 return err 783 } 784 return nil 785 } 786 787 func (fieldMask *Bucket_ResolvedKeysWithValues_FieldMask) AppendPath(path BucketResolvedKeysWithValues_FieldPath) { 788 fieldMask.Paths = append(fieldMask.Paths, path) 789 } 790 791 func (fieldMask *Bucket_ResolvedKeysWithValues_FieldMask) AppendRawPath(path gotenobject.FieldPath) { 792 fieldMask.Paths = append(fieldMask.Paths, path.(BucketResolvedKeysWithValues_FieldPath)) 793 } 794 795 func (fieldMask *Bucket_ResolvedKeysWithValues_FieldMask) GetPaths() []BucketResolvedKeysWithValues_FieldPath { 796 if fieldMask == nil { 797 return nil 798 } 799 return fieldMask.Paths 800 } 801 802 func (fieldMask *Bucket_ResolvedKeysWithValues_FieldMask) GetRawPaths() []gotenobject.FieldPath { 803 if fieldMask == nil { 804 return nil 805 } 806 rawPaths := make([]gotenobject.FieldPath, 0, len(fieldMask.Paths)) 807 for _, path := range fieldMask.Paths { 808 rawPaths = append(rawPaths, path) 809 } 810 return rawPaths 811 } 812 813 func (fieldMask *Bucket_ResolvedKeysWithValues_FieldMask) SetFromCliFlag(raw string) error { 814 path, err := ParseBucketResolvedKeysWithValues_FieldPath(raw) 815 if err != nil { 816 return err 817 } 818 fieldMask.Paths = append(fieldMask.Paths, path) 819 return nil 820 } 821 822 func (fieldMask *Bucket_ResolvedKeysWithValues_FieldMask) Set(target, source *Bucket_ResolvedKeysWithValues) { 823 for _, path := range fieldMask.Paths { 824 val, _ := path.GetSingle(source) 825 // if val is nil, then field does not exist in source, skip 826 // otherwise, process (can still reflect.ValueOf(val).IsNil!) 827 if val != nil { 828 path.WithIValue(val).SetTo(&target) 829 } 830 } 831 } 832 833 func (fieldMask *Bucket_ResolvedKeysWithValues_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) { 834 fieldMask.Set(target.(*Bucket_ResolvedKeysWithValues), source.(*Bucket_ResolvedKeysWithValues)) 835 } 836 837 func (fieldMask *Bucket_ResolvedKeysWithValues_FieldMask) Project(source *Bucket_ResolvedKeysWithValues) *Bucket_ResolvedKeysWithValues { 838 if source == nil { 839 return nil 840 } 841 if fieldMask == nil { 842 return source 843 } 844 result := &Bucket_ResolvedKeysWithValues{} 845 resolvedKvsMask := &Bucket_ResolvedValues_FieldMask{} 846 wholeResolvedKvsAccepted := false 847 848 for _, p := range fieldMask.Paths { 849 switch tp := p.(type) { 850 case *BucketResolvedKeysWithValues_FieldTerminalPath: 851 switch tp.selector { 852 case BucketResolvedKeysWithValues_FieldPathSelectorResolvedKvs: 853 result.ResolvedKvs = source.ResolvedKvs 854 wholeResolvedKvsAccepted = true 855 } 856 case *BucketResolvedKeysWithValues_FieldSubPath: 857 switch tp.selector { 858 case BucketResolvedKeysWithValues_FieldPathSelectorResolvedKvs: 859 resolvedKvsMask.AppendPath(tp.subPath.(BucketResolvedValues_FieldPath)) 860 } 861 } 862 } 863 if wholeResolvedKvsAccepted == false && len(resolvedKvsMask.Paths) > 0 { 864 for _, sourceItem := range source.GetResolvedKvs() { 865 result.ResolvedKvs = append(result.ResolvedKvs, resolvedKvsMask.Project(sourceItem)) 866 } 867 } 868 return result 869 } 870 871 func (fieldMask *Bucket_ResolvedKeysWithValues_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt { 872 return fieldMask.Project(source.(*Bucket_ResolvedKeysWithValues)) 873 } 874 875 func (fieldMask *Bucket_ResolvedKeysWithValues_FieldMask) PathsCount() int { 876 if fieldMask == nil { 877 return 0 878 } 879 return len(fieldMask.Paths) 880 } 881 882 type Bucket_RequiredTypedLabels_FieldMask struct { 883 Paths []BucketRequiredTypedLabels_FieldPath 884 } 885 886 func FullBucket_RequiredTypedLabels_FieldMask() *Bucket_RequiredTypedLabels_FieldMask { 887 res := &Bucket_RequiredTypedLabels_FieldMask{} 888 res.Paths = append(res.Paths, &BucketRequiredTypedLabels_FieldTerminalPath{selector: BucketRequiredTypedLabels_FieldPathSelectorTypes}) 889 res.Paths = append(res.Paths, &BucketRequiredTypedLabels_FieldTerminalPath{selector: BucketRequiredTypedLabels_FieldPathSelectorLabels}) 890 return res 891 } 892 893 func (fieldMask *Bucket_RequiredTypedLabels_FieldMask) String() string { 894 if fieldMask == nil { 895 return "<nil>" 896 } 897 pathsStr := make([]string, 0, len(fieldMask.Paths)) 898 for _, path := range fieldMask.Paths { 899 pathsStr = append(pathsStr, path.String()) 900 } 901 return strings.Join(pathsStr, ", ") 902 } 903 904 func (fieldMask *Bucket_RequiredTypedLabels_FieldMask) IsFull() bool { 905 if fieldMask == nil { 906 return false 907 } 908 presentSelectors := make([]bool, 2) 909 for _, path := range fieldMask.Paths { 910 if asFinal, ok := path.(*BucketRequiredTypedLabels_FieldTerminalPath); ok { 911 presentSelectors[int(asFinal.selector)] = true 912 } 913 } 914 for _, flag := range presentSelectors { 915 if !flag { 916 return false 917 } 918 } 919 return true 920 } 921 922 func (fieldMask *Bucket_RequiredTypedLabels_FieldMask) ProtoReflect() preflect.Message { 923 return gotenobject.MakeFieldMaskReflection(fieldMask, func(raw string) (gotenobject.FieldPath, error) { 924 return ParseBucketRequiredTypedLabels_FieldPath(raw) 925 }) 926 } 927 928 func (fieldMask *Bucket_RequiredTypedLabels_FieldMask) ProtoMessage() {} 929 930 func (fieldMask *Bucket_RequiredTypedLabels_FieldMask) Reset() { 931 if fieldMask != nil { 932 fieldMask.Paths = nil 933 } 934 } 935 936 func (fieldMask *Bucket_RequiredTypedLabels_FieldMask) Subtract(other *Bucket_RequiredTypedLabels_FieldMask) *Bucket_RequiredTypedLabels_FieldMask { 937 result := &Bucket_RequiredTypedLabels_FieldMask{} 938 removedSelectors := make([]bool, 2) 939 940 for _, path := range other.GetPaths() { 941 switch tp := path.(type) { 942 case *BucketRequiredTypedLabels_FieldTerminalPath: 943 removedSelectors[int(tp.selector)] = true 944 } 945 } 946 for _, path := range fieldMask.GetPaths() { 947 if !removedSelectors[int(path.Selector())] { 948 result.Paths = append(result.Paths, path) 949 } 950 } 951 952 if len(result.Paths) == 0 { 953 return nil 954 } 955 return result 956 } 957 958 func (fieldMask *Bucket_RequiredTypedLabels_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask { 959 return fieldMask.Subtract(other.(*Bucket_RequiredTypedLabels_FieldMask)) 960 } 961 962 // FilterInputFields generates copy of field paths with output_only field paths removed 963 func (fieldMask *Bucket_RequiredTypedLabels_FieldMask) FilterInputFields() *Bucket_RequiredTypedLabels_FieldMask { 964 result := &Bucket_RequiredTypedLabels_FieldMask{} 965 result.Paths = append(result.Paths, fieldMask.Paths...) 966 return result 967 } 968 969 // ToFieldMask is used for proto conversions 970 func (fieldMask *Bucket_RequiredTypedLabels_FieldMask) ToProtoFieldMask() *googlefieldmaskpb.FieldMask { 971 protoFieldMask := &googlefieldmaskpb.FieldMask{} 972 for _, path := range fieldMask.Paths { 973 protoFieldMask.Paths = append(protoFieldMask.Paths, path.String()) 974 } 975 return protoFieldMask 976 } 977 978 func (fieldMask *Bucket_RequiredTypedLabels_FieldMask) FromProtoFieldMask(protoFieldMask *googlefieldmaskpb.FieldMask) error { 979 if fieldMask == nil { 980 return status.Error(codes.Internal, "target field mask is nil") 981 } 982 fieldMask.Paths = make([]BucketRequiredTypedLabels_FieldPath, 0, len(protoFieldMask.Paths)) 983 for _, strPath := range protoFieldMask.Paths { 984 path, err := ParseBucketRequiredTypedLabels_FieldPath(strPath) 985 if err != nil { 986 return err 987 } 988 fieldMask.Paths = append(fieldMask.Paths, path) 989 } 990 return nil 991 } 992 993 // implement methods required by customType 994 func (fieldMask Bucket_RequiredTypedLabels_FieldMask) Marshal() ([]byte, error) { 995 protoFieldMask := fieldMask.ToProtoFieldMask() 996 return proto.Marshal(protoFieldMask) 997 } 998 999 func (fieldMask *Bucket_RequiredTypedLabels_FieldMask) Unmarshal(data []byte) error { 1000 protoFieldMask := &googlefieldmaskpb.FieldMask{} 1001 if err := proto.Unmarshal(data, protoFieldMask); err != nil { 1002 return err 1003 } 1004 if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil { 1005 return err 1006 } 1007 return nil 1008 } 1009 1010 func (fieldMask *Bucket_RequiredTypedLabels_FieldMask) Size() int { 1011 return proto.Size(fieldMask.ToProtoFieldMask()) 1012 } 1013 1014 func (fieldMask Bucket_RequiredTypedLabels_FieldMask) MarshalJSON() ([]byte, error) { 1015 return json.Marshal(fieldMask.ToProtoFieldMask()) 1016 } 1017 1018 func (fieldMask *Bucket_RequiredTypedLabels_FieldMask) UnmarshalJSON(data []byte) error { 1019 protoFieldMask := &googlefieldmaskpb.FieldMask{} 1020 if err := json.Unmarshal(data, protoFieldMask); err != nil { 1021 return err 1022 } 1023 if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil { 1024 return err 1025 } 1026 return nil 1027 } 1028 1029 func (fieldMask *Bucket_RequiredTypedLabels_FieldMask) AppendPath(path BucketRequiredTypedLabels_FieldPath) { 1030 fieldMask.Paths = append(fieldMask.Paths, path) 1031 } 1032 1033 func (fieldMask *Bucket_RequiredTypedLabels_FieldMask) AppendRawPath(path gotenobject.FieldPath) { 1034 fieldMask.Paths = append(fieldMask.Paths, path.(BucketRequiredTypedLabels_FieldPath)) 1035 } 1036 1037 func (fieldMask *Bucket_RequiredTypedLabels_FieldMask) GetPaths() []BucketRequiredTypedLabels_FieldPath { 1038 if fieldMask == nil { 1039 return nil 1040 } 1041 return fieldMask.Paths 1042 } 1043 1044 func (fieldMask *Bucket_RequiredTypedLabels_FieldMask) GetRawPaths() []gotenobject.FieldPath { 1045 if fieldMask == nil { 1046 return nil 1047 } 1048 rawPaths := make([]gotenobject.FieldPath, 0, len(fieldMask.Paths)) 1049 for _, path := range fieldMask.Paths { 1050 rawPaths = append(rawPaths, path) 1051 } 1052 return rawPaths 1053 } 1054 1055 func (fieldMask *Bucket_RequiredTypedLabels_FieldMask) SetFromCliFlag(raw string) error { 1056 path, err := ParseBucketRequiredTypedLabels_FieldPath(raw) 1057 if err != nil { 1058 return err 1059 } 1060 fieldMask.Paths = append(fieldMask.Paths, path) 1061 return nil 1062 } 1063 1064 func (fieldMask *Bucket_RequiredTypedLabels_FieldMask) Set(target, source *Bucket_RequiredTypedLabels) { 1065 for _, path := range fieldMask.Paths { 1066 val, _ := path.GetSingle(source) 1067 // if val is nil, then field does not exist in source, skip 1068 // otherwise, process (can still reflect.ValueOf(val).IsNil!) 1069 if val != nil { 1070 path.WithIValue(val).SetTo(&target) 1071 } 1072 } 1073 } 1074 1075 func (fieldMask *Bucket_RequiredTypedLabels_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) { 1076 fieldMask.Set(target.(*Bucket_RequiredTypedLabels), source.(*Bucket_RequiredTypedLabels)) 1077 } 1078 1079 func (fieldMask *Bucket_RequiredTypedLabels_FieldMask) Project(source *Bucket_RequiredTypedLabels) *Bucket_RequiredTypedLabels { 1080 if source == nil { 1081 return nil 1082 } 1083 if fieldMask == nil { 1084 return source 1085 } 1086 result := &Bucket_RequiredTypedLabels{} 1087 var labelsMapKeys []string 1088 wholeLabelsAccepted := false 1089 1090 for _, p := range fieldMask.Paths { 1091 switch tp := p.(type) { 1092 case *BucketRequiredTypedLabels_FieldTerminalPath: 1093 switch tp.selector { 1094 case BucketRequiredTypedLabels_FieldPathSelectorTypes: 1095 result.Types = source.Types 1096 case BucketRequiredTypedLabels_FieldPathSelectorLabels: 1097 result.Labels = source.Labels 1098 wholeLabelsAccepted = true 1099 } 1100 case *BucketRequiredTypedLabels_FieldPathMap: 1101 switch tp.selector { 1102 case BucketRequiredTypedLabels_FieldPathSelectorLabels: 1103 labelsMapKeys = append(labelsMapKeys, tp.key) 1104 } 1105 } 1106 } 1107 if wholeLabelsAccepted == false && len(labelsMapKeys) > 0 && source.GetLabels() != nil { 1108 copiedMap := map[string]*Bucket_RequiredTypedLabels_Strings{} 1109 sourceMap := source.GetLabels() 1110 for _, key := range labelsMapKeys { 1111 copiedMap[key] = sourceMap[key] 1112 } 1113 result.Labels = copiedMap 1114 } 1115 return result 1116 } 1117 1118 func (fieldMask *Bucket_RequiredTypedLabels_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt { 1119 return fieldMask.Project(source.(*Bucket_RequiredTypedLabels)) 1120 } 1121 1122 func (fieldMask *Bucket_RequiredTypedLabels_FieldMask) PathsCount() int { 1123 if fieldMask == nil { 1124 return 0 1125 } 1126 return len(fieldMask.Paths) 1127 } 1128 1129 type Bucket_RequiredTypedLabels_Strings_FieldMask struct { 1130 Paths []BucketRequiredTypedLabelsStrings_FieldPath 1131 } 1132 1133 func FullBucket_RequiredTypedLabels_Strings_FieldMask() *Bucket_RequiredTypedLabels_Strings_FieldMask { 1134 res := &Bucket_RequiredTypedLabels_Strings_FieldMask{} 1135 res.Paths = append(res.Paths, &BucketRequiredTypedLabelsStrings_FieldTerminalPath{selector: BucketRequiredTypedLabelsStrings_FieldPathSelectorStrings}) 1136 return res 1137 } 1138 1139 func (fieldMask *Bucket_RequiredTypedLabels_Strings_FieldMask) String() string { 1140 if fieldMask == nil { 1141 return "<nil>" 1142 } 1143 pathsStr := make([]string, 0, len(fieldMask.Paths)) 1144 for _, path := range fieldMask.Paths { 1145 pathsStr = append(pathsStr, path.String()) 1146 } 1147 return strings.Join(pathsStr, ", ") 1148 } 1149 1150 func (fieldMask *Bucket_RequiredTypedLabels_Strings_FieldMask) IsFull() bool { 1151 if fieldMask == nil { 1152 return false 1153 } 1154 presentSelectors := make([]bool, 1) 1155 for _, path := range fieldMask.Paths { 1156 if asFinal, ok := path.(*BucketRequiredTypedLabelsStrings_FieldTerminalPath); ok { 1157 presentSelectors[int(asFinal.selector)] = true 1158 } 1159 } 1160 for _, flag := range presentSelectors { 1161 if !flag { 1162 return false 1163 } 1164 } 1165 return true 1166 } 1167 1168 func (fieldMask *Bucket_RequiredTypedLabels_Strings_FieldMask) ProtoReflect() preflect.Message { 1169 return gotenobject.MakeFieldMaskReflection(fieldMask, func(raw string) (gotenobject.FieldPath, error) { 1170 return ParseBucketRequiredTypedLabelsStrings_FieldPath(raw) 1171 }) 1172 } 1173 1174 func (fieldMask *Bucket_RequiredTypedLabels_Strings_FieldMask) ProtoMessage() {} 1175 1176 func (fieldMask *Bucket_RequiredTypedLabels_Strings_FieldMask) Reset() { 1177 if fieldMask != nil { 1178 fieldMask.Paths = nil 1179 } 1180 } 1181 1182 func (fieldMask *Bucket_RequiredTypedLabels_Strings_FieldMask) Subtract(other *Bucket_RequiredTypedLabels_Strings_FieldMask) *Bucket_RequiredTypedLabels_Strings_FieldMask { 1183 result := &Bucket_RequiredTypedLabels_Strings_FieldMask{} 1184 removedSelectors := make([]bool, 1) 1185 1186 for _, path := range other.GetPaths() { 1187 switch tp := path.(type) { 1188 case *BucketRequiredTypedLabelsStrings_FieldTerminalPath: 1189 removedSelectors[int(tp.selector)] = true 1190 } 1191 } 1192 for _, path := range fieldMask.GetPaths() { 1193 if !removedSelectors[int(path.Selector())] { 1194 result.Paths = append(result.Paths, path) 1195 } 1196 } 1197 1198 if len(result.Paths) == 0 { 1199 return nil 1200 } 1201 return result 1202 } 1203 1204 func (fieldMask *Bucket_RequiredTypedLabels_Strings_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask { 1205 return fieldMask.Subtract(other.(*Bucket_RequiredTypedLabels_Strings_FieldMask)) 1206 } 1207 1208 // FilterInputFields generates copy of field paths with output_only field paths removed 1209 func (fieldMask *Bucket_RequiredTypedLabels_Strings_FieldMask) FilterInputFields() *Bucket_RequiredTypedLabels_Strings_FieldMask { 1210 result := &Bucket_RequiredTypedLabels_Strings_FieldMask{} 1211 result.Paths = append(result.Paths, fieldMask.Paths...) 1212 return result 1213 } 1214 1215 // ToFieldMask is used for proto conversions 1216 func (fieldMask *Bucket_RequiredTypedLabels_Strings_FieldMask) ToProtoFieldMask() *googlefieldmaskpb.FieldMask { 1217 protoFieldMask := &googlefieldmaskpb.FieldMask{} 1218 for _, path := range fieldMask.Paths { 1219 protoFieldMask.Paths = append(protoFieldMask.Paths, path.String()) 1220 } 1221 return protoFieldMask 1222 } 1223 1224 func (fieldMask *Bucket_RequiredTypedLabels_Strings_FieldMask) FromProtoFieldMask(protoFieldMask *googlefieldmaskpb.FieldMask) error { 1225 if fieldMask == nil { 1226 return status.Error(codes.Internal, "target field mask is nil") 1227 } 1228 fieldMask.Paths = make([]BucketRequiredTypedLabelsStrings_FieldPath, 0, len(protoFieldMask.Paths)) 1229 for _, strPath := range protoFieldMask.Paths { 1230 path, err := ParseBucketRequiredTypedLabelsStrings_FieldPath(strPath) 1231 if err != nil { 1232 return err 1233 } 1234 fieldMask.Paths = append(fieldMask.Paths, path) 1235 } 1236 return nil 1237 } 1238 1239 // implement methods required by customType 1240 func (fieldMask Bucket_RequiredTypedLabels_Strings_FieldMask) Marshal() ([]byte, error) { 1241 protoFieldMask := fieldMask.ToProtoFieldMask() 1242 return proto.Marshal(protoFieldMask) 1243 } 1244 1245 func (fieldMask *Bucket_RequiredTypedLabels_Strings_FieldMask) Unmarshal(data []byte) error { 1246 protoFieldMask := &googlefieldmaskpb.FieldMask{} 1247 if err := proto.Unmarshal(data, protoFieldMask); err != nil { 1248 return err 1249 } 1250 if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil { 1251 return err 1252 } 1253 return nil 1254 } 1255 1256 func (fieldMask *Bucket_RequiredTypedLabels_Strings_FieldMask) Size() int { 1257 return proto.Size(fieldMask.ToProtoFieldMask()) 1258 } 1259 1260 func (fieldMask Bucket_RequiredTypedLabels_Strings_FieldMask) MarshalJSON() ([]byte, error) { 1261 return json.Marshal(fieldMask.ToProtoFieldMask()) 1262 } 1263 1264 func (fieldMask *Bucket_RequiredTypedLabels_Strings_FieldMask) UnmarshalJSON(data []byte) error { 1265 protoFieldMask := &googlefieldmaskpb.FieldMask{} 1266 if err := json.Unmarshal(data, protoFieldMask); err != nil { 1267 return err 1268 } 1269 if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil { 1270 return err 1271 } 1272 return nil 1273 } 1274 1275 func (fieldMask *Bucket_RequiredTypedLabels_Strings_FieldMask) AppendPath(path BucketRequiredTypedLabelsStrings_FieldPath) { 1276 fieldMask.Paths = append(fieldMask.Paths, path) 1277 } 1278 1279 func (fieldMask *Bucket_RequiredTypedLabels_Strings_FieldMask) AppendRawPath(path gotenobject.FieldPath) { 1280 fieldMask.Paths = append(fieldMask.Paths, path.(BucketRequiredTypedLabelsStrings_FieldPath)) 1281 } 1282 1283 func (fieldMask *Bucket_RequiredTypedLabels_Strings_FieldMask) GetPaths() []BucketRequiredTypedLabelsStrings_FieldPath { 1284 if fieldMask == nil { 1285 return nil 1286 } 1287 return fieldMask.Paths 1288 } 1289 1290 func (fieldMask *Bucket_RequiredTypedLabels_Strings_FieldMask) GetRawPaths() []gotenobject.FieldPath { 1291 if fieldMask == nil { 1292 return nil 1293 } 1294 rawPaths := make([]gotenobject.FieldPath, 0, len(fieldMask.Paths)) 1295 for _, path := range fieldMask.Paths { 1296 rawPaths = append(rawPaths, path) 1297 } 1298 return rawPaths 1299 } 1300 1301 func (fieldMask *Bucket_RequiredTypedLabels_Strings_FieldMask) SetFromCliFlag(raw string) error { 1302 path, err := ParseBucketRequiredTypedLabelsStrings_FieldPath(raw) 1303 if err != nil { 1304 return err 1305 } 1306 fieldMask.Paths = append(fieldMask.Paths, path) 1307 return nil 1308 } 1309 1310 func (fieldMask *Bucket_RequiredTypedLabels_Strings_FieldMask) Set(target, source *Bucket_RequiredTypedLabels_Strings) { 1311 for _, path := range fieldMask.Paths { 1312 val, _ := path.GetSingle(source) 1313 // if val is nil, then field does not exist in source, skip 1314 // otherwise, process (can still reflect.ValueOf(val).IsNil!) 1315 if val != nil { 1316 path.WithIValue(val).SetTo(&target) 1317 } 1318 } 1319 } 1320 1321 func (fieldMask *Bucket_RequiredTypedLabels_Strings_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) { 1322 fieldMask.Set(target.(*Bucket_RequiredTypedLabels_Strings), source.(*Bucket_RequiredTypedLabels_Strings)) 1323 } 1324 1325 func (fieldMask *Bucket_RequiredTypedLabels_Strings_FieldMask) Project(source *Bucket_RequiredTypedLabels_Strings) *Bucket_RequiredTypedLabels_Strings { 1326 if source == nil { 1327 return nil 1328 } 1329 if fieldMask == nil { 1330 return source 1331 } 1332 result := &Bucket_RequiredTypedLabels_Strings{} 1333 1334 for _, p := range fieldMask.Paths { 1335 switch tp := p.(type) { 1336 case *BucketRequiredTypedLabelsStrings_FieldTerminalPath: 1337 switch tp.selector { 1338 case BucketRequiredTypedLabelsStrings_FieldPathSelectorStrings: 1339 result.Strings = source.Strings 1340 } 1341 } 1342 } 1343 return result 1344 } 1345 1346 func (fieldMask *Bucket_RequiredTypedLabels_Strings_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt { 1347 return fieldMask.Project(source.(*Bucket_RequiredTypedLabels_Strings)) 1348 } 1349 1350 func (fieldMask *Bucket_RequiredTypedLabels_Strings_FieldMask) PathsCount() int { 1351 if fieldMask == nil { 1352 return 0 1353 } 1354 return len(fieldMask.Paths) 1355 }