github.com/cloudwan/edgelq-sdk@v1.15.4/limits/resources/v1alpha2/plan_assignment_request/plan_assignment_request.pb.fieldmask.go (about) 1 // Code generated by protoc-gen-goten-object 2 // File: edgelq/limits/proto/v1alpha2/plan_assignment_request.proto 3 // DO NOT EDIT!!! 4 5 package plan_assignment_request 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 iam_organization "github.com/cloudwan/edgelq-sdk/iam/resources/v1alpha2/organization" 23 iam_project "github.com/cloudwan/edgelq-sdk/iam/resources/v1alpha2/project" 24 common "github.com/cloudwan/edgelq-sdk/limits/resources/v1alpha2/common" 25 plan "github.com/cloudwan/edgelq-sdk/limits/resources/v1alpha2/plan" 26 plan_assignment "github.com/cloudwan/edgelq-sdk/limits/resources/v1alpha2/plan_assignment" 27 meta_service "github.com/cloudwan/edgelq-sdk/meta/resources/v1alpha2/service" 28 meta "github.com/cloudwan/goten-sdk/types/meta" 29 ) 30 31 // ensure the imports are used 32 var ( 33 _ = new(json.Marshaler) 34 _ = strings.Builder{} 35 36 _ = codes.NotFound 37 _ = status.Status{} 38 _ = new(proto.Message) 39 _ = new(preflect.Message) 40 _ = googlefieldmaskpb.FieldMask{} 41 42 _ = new(gotenobject.FieldMask) 43 ) 44 45 // make sure we're using proto imports 46 var ( 47 _ = &iam_organization.Organization{} 48 _ = &iam_project.Project{} 49 _ = &common.Allowance{} 50 _ = &plan.Plan{} 51 _ = &plan_assignment.PlanAssignment{} 52 _ = &meta_service.Service{} 53 _ = &meta.Meta{} 54 ) 55 56 type PlanAssignmentRequest_FieldMask struct { 57 Paths []PlanAssignmentRequest_FieldPath 58 } 59 60 func FullPlanAssignmentRequest_FieldMask() *PlanAssignmentRequest_FieldMask { 61 res := &PlanAssignmentRequest_FieldMask{} 62 res.Paths = append(res.Paths, &PlanAssignmentRequest_FieldTerminalPath{selector: PlanAssignmentRequest_FieldPathSelectorName}) 63 res.Paths = append(res.Paths, &PlanAssignmentRequest_FieldTerminalPath{selector: PlanAssignmentRequest_FieldPathSelectorRequest}) 64 res.Paths = append(res.Paths, &PlanAssignmentRequest_FieldTerminalPath{selector: PlanAssignmentRequest_FieldPathSelectorService}) 65 res.Paths = append(res.Paths, &PlanAssignmentRequest_FieldTerminalPath{selector: PlanAssignmentRequest_FieldPathSelectorApprover}) 66 res.Paths = append(res.Paths, &PlanAssignmentRequest_FieldTerminalPath{selector: PlanAssignmentRequest_FieldPathSelectorStatus}) 67 res.Paths = append(res.Paths, &PlanAssignmentRequest_FieldTerminalPath{selector: PlanAssignmentRequest_FieldPathSelectorMetadata}) 68 return res 69 } 70 71 func (fieldMask *PlanAssignmentRequest_FieldMask) String() string { 72 if fieldMask == nil { 73 return "<nil>" 74 } 75 pathsStr := make([]string, 0, len(fieldMask.Paths)) 76 for _, path := range fieldMask.Paths { 77 pathsStr = append(pathsStr, path.String()) 78 } 79 return strings.Join(pathsStr, ", ") 80 } 81 82 func (fieldMask *PlanAssignmentRequest_FieldMask) IsFull() bool { 83 if fieldMask == nil { 84 return false 85 } 86 presentSelectors := make([]bool, 6) 87 for _, path := range fieldMask.Paths { 88 if asFinal, ok := path.(*PlanAssignmentRequest_FieldTerminalPath); ok { 89 presentSelectors[int(asFinal.selector)] = true 90 } 91 } 92 for _, flag := range presentSelectors { 93 if !flag { 94 return false 95 } 96 } 97 return true 98 } 99 100 func (fieldMask *PlanAssignmentRequest_FieldMask) ProtoReflect() preflect.Message { 101 return gotenobject.MakeFieldMaskReflection(fieldMask, func(raw string) (gotenobject.FieldPath, error) { 102 return ParsePlanAssignmentRequest_FieldPath(raw) 103 }) 104 } 105 106 func (fieldMask *PlanAssignmentRequest_FieldMask) ProtoMessage() {} 107 108 func (fieldMask *PlanAssignmentRequest_FieldMask) Reset() { 109 if fieldMask != nil { 110 fieldMask.Paths = nil 111 } 112 } 113 114 func (fieldMask *PlanAssignmentRequest_FieldMask) Subtract(other *PlanAssignmentRequest_FieldMask) *PlanAssignmentRequest_FieldMask { 115 result := &PlanAssignmentRequest_FieldMask{} 116 removedSelectors := make([]bool, 6) 117 otherSubMasks := map[PlanAssignmentRequest_FieldPathSelector]gotenobject.FieldMask{ 118 PlanAssignmentRequest_FieldPathSelectorRequest: &PlanAssignmentRequest_RequestType_FieldMask{}, 119 PlanAssignmentRequest_FieldPathSelectorStatus: &PlanAssignmentRequest_Status_FieldMask{}, 120 PlanAssignmentRequest_FieldPathSelectorMetadata: &meta.Meta_FieldMask{}, 121 } 122 mySubMasks := map[PlanAssignmentRequest_FieldPathSelector]gotenobject.FieldMask{ 123 PlanAssignmentRequest_FieldPathSelectorRequest: &PlanAssignmentRequest_RequestType_FieldMask{}, 124 PlanAssignmentRequest_FieldPathSelectorStatus: &PlanAssignmentRequest_Status_FieldMask{}, 125 PlanAssignmentRequest_FieldPathSelectorMetadata: &meta.Meta_FieldMask{}, 126 } 127 128 for _, path := range other.GetPaths() { 129 switch tp := path.(type) { 130 case *PlanAssignmentRequest_FieldTerminalPath: 131 removedSelectors[int(tp.selector)] = true 132 case *PlanAssignmentRequest_FieldSubPath: 133 otherSubMasks[tp.selector].AppendRawPath(tp.subPath) 134 } 135 } 136 for _, path := range fieldMask.GetPaths() { 137 if !removedSelectors[int(path.Selector())] { 138 if otherSubMask := otherSubMasks[path.Selector()]; otherSubMask != nil && otherSubMask.PathsCount() > 0 { 139 if tp, ok := path.(*PlanAssignmentRequest_FieldTerminalPath); ok { 140 switch tp.selector { 141 case PlanAssignmentRequest_FieldPathSelectorRequest: 142 mySubMasks[PlanAssignmentRequest_FieldPathSelectorRequest] = FullPlanAssignmentRequest_RequestType_FieldMask() 143 case PlanAssignmentRequest_FieldPathSelectorStatus: 144 mySubMasks[PlanAssignmentRequest_FieldPathSelectorStatus] = FullPlanAssignmentRequest_Status_FieldMask() 145 case PlanAssignmentRequest_FieldPathSelectorMetadata: 146 mySubMasks[PlanAssignmentRequest_FieldPathSelectorMetadata] = meta.FullMeta_FieldMask() 147 } 148 } else if tp, ok := path.(*PlanAssignmentRequest_FieldSubPath); ok { 149 mySubMasks[tp.selector].AppendRawPath(tp.subPath) 150 } 151 } else { 152 result.Paths = append(result.Paths, path) 153 } 154 } 155 } 156 for selector, mySubMask := range mySubMasks { 157 if mySubMask.PathsCount() > 0 { 158 for _, allowedPath := range mySubMask.SubtractRaw(otherSubMasks[selector]).GetRawPaths() { 159 result.Paths = append(result.Paths, &PlanAssignmentRequest_FieldSubPath{selector: selector, subPath: allowedPath}) 160 } 161 } 162 } 163 164 if len(result.Paths) == 0 { 165 return nil 166 } 167 return result 168 } 169 170 func (fieldMask *PlanAssignmentRequest_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask { 171 return fieldMask.Subtract(other.(*PlanAssignmentRequest_FieldMask)) 172 } 173 174 // FilterInputFields generates copy of field paths with output_only field paths removed 175 func (fieldMask *PlanAssignmentRequest_FieldMask) FilterInputFields() *PlanAssignmentRequest_FieldMask { 176 result := &PlanAssignmentRequest_FieldMask{} 177 for _, path := range fieldMask.Paths { 178 switch path.Selector() { 179 case PlanAssignmentRequest_FieldPathSelectorService: 180 case PlanAssignmentRequest_FieldPathSelectorApprover: 181 case PlanAssignmentRequest_FieldPathSelectorStatus: 182 case PlanAssignmentRequest_FieldPathSelectorMetadata: 183 if _, ok := path.(*PlanAssignmentRequest_FieldTerminalPath); ok { 184 for _, subpath := range meta.FullMeta_FieldMask().FilterInputFields().Paths { 185 result.Paths = append(result.Paths, &PlanAssignmentRequest_FieldSubPath{selector: path.Selector(), subPath: subpath}) 186 } 187 } else if sub, ok := path.(*PlanAssignmentRequest_FieldSubPath); ok { 188 selectedMask := &meta.Meta_FieldMask{ 189 Paths: []meta.Meta_FieldPath{sub.subPath.(meta.Meta_FieldPath)}, 190 } 191 for _, allowedPath := range selectedMask.FilterInputFields().Paths { 192 result.Paths = append(result.Paths, &PlanAssignmentRequest_FieldSubPath{selector: PlanAssignmentRequest_FieldPathSelectorMetadata, subPath: allowedPath}) 193 } 194 } 195 default: 196 result.Paths = append(result.Paths, path) 197 } 198 } 199 return result 200 } 201 202 // ToFieldMask is used for proto conversions 203 func (fieldMask *PlanAssignmentRequest_FieldMask) ToProtoFieldMask() *googlefieldmaskpb.FieldMask { 204 protoFieldMask := &googlefieldmaskpb.FieldMask{} 205 for _, path := range fieldMask.Paths { 206 protoFieldMask.Paths = append(protoFieldMask.Paths, path.String()) 207 } 208 return protoFieldMask 209 } 210 211 func (fieldMask *PlanAssignmentRequest_FieldMask) FromProtoFieldMask(protoFieldMask *googlefieldmaskpb.FieldMask) error { 212 if fieldMask == nil { 213 return status.Error(codes.Internal, "target field mask is nil") 214 } 215 fieldMask.Paths = make([]PlanAssignmentRequest_FieldPath, 0, len(protoFieldMask.Paths)) 216 for _, strPath := range protoFieldMask.Paths { 217 path, err := ParsePlanAssignmentRequest_FieldPath(strPath) 218 if err != nil { 219 return err 220 } 221 fieldMask.Paths = append(fieldMask.Paths, path) 222 } 223 return nil 224 } 225 226 // implement methods required by customType 227 func (fieldMask PlanAssignmentRequest_FieldMask) Marshal() ([]byte, error) { 228 protoFieldMask := fieldMask.ToProtoFieldMask() 229 return proto.Marshal(protoFieldMask) 230 } 231 232 func (fieldMask *PlanAssignmentRequest_FieldMask) Unmarshal(data []byte) error { 233 protoFieldMask := &googlefieldmaskpb.FieldMask{} 234 if err := proto.Unmarshal(data, protoFieldMask); err != nil { 235 return err 236 } 237 if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil { 238 return err 239 } 240 return nil 241 } 242 243 func (fieldMask *PlanAssignmentRequest_FieldMask) Size() int { 244 return proto.Size(fieldMask.ToProtoFieldMask()) 245 } 246 247 func (fieldMask PlanAssignmentRequest_FieldMask) MarshalJSON() ([]byte, error) { 248 return json.Marshal(fieldMask.ToProtoFieldMask()) 249 } 250 251 func (fieldMask *PlanAssignmentRequest_FieldMask) UnmarshalJSON(data []byte) error { 252 protoFieldMask := &googlefieldmaskpb.FieldMask{} 253 if err := json.Unmarshal(data, protoFieldMask); err != nil { 254 return err 255 } 256 if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil { 257 return err 258 } 259 return nil 260 } 261 262 func (fieldMask *PlanAssignmentRequest_FieldMask) AppendPath(path PlanAssignmentRequest_FieldPath) { 263 fieldMask.Paths = append(fieldMask.Paths, path) 264 } 265 266 func (fieldMask *PlanAssignmentRequest_FieldMask) AppendRawPath(path gotenobject.FieldPath) { 267 fieldMask.Paths = append(fieldMask.Paths, path.(PlanAssignmentRequest_FieldPath)) 268 } 269 270 func (fieldMask *PlanAssignmentRequest_FieldMask) GetPaths() []PlanAssignmentRequest_FieldPath { 271 if fieldMask == nil { 272 return nil 273 } 274 return fieldMask.Paths 275 } 276 277 func (fieldMask *PlanAssignmentRequest_FieldMask) GetRawPaths() []gotenobject.FieldPath { 278 if fieldMask == nil { 279 return nil 280 } 281 rawPaths := make([]gotenobject.FieldPath, 0, len(fieldMask.Paths)) 282 for _, path := range fieldMask.Paths { 283 rawPaths = append(rawPaths, path) 284 } 285 return rawPaths 286 } 287 288 func (fieldMask *PlanAssignmentRequest_FieldMask) SetFromCliFlag(raw string) error { 289 path, err := ParsePlanAssignmentRequest_FieldPath(raw) 290 if err != nil { 291 return err 292 } 293 fieldMask.Paths = append(fieldMask.Paths, path) 294 return nil 295 } 296 297 func (fieldMask *PlanAssignmentRequest_FieldMask) Set(target, source *PlanAssignmentRequest) { 298 for _, path := range fieldMask.Paths { 299 val, _ := path.GetSingle(source) 300 // if val is nil, then field does not exist in source, skip 301 // otherwise, process (can still reflect.ValueOf(val).IsNil!) 302 if val != nil { 303 path.WithIValue(val).SetTo(&target) 304 } 305 } 306 } 307 308 func (fieldMask *PlanAssignmentRequest_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) { 309 fieldMask.Set(target.(*PlanAssignmentRequest), source.(*PlanAssignmentRequest)) 310 } 311 312 func (fieldMask *PlanAssignmentRequest_FieldMask) Project(source *PlanAssignmentRequest) *PlanAssignmentRequest { 313 if source == nil { 314 return nil 315 } 316 if fieldMask == nil { 317 return source 318 } 319 result := &PlanAssignmentRequest{} 320 requestMask := &PlanAssignmentRequest_RequestType_FieldMask{} 321 wholeRequestAccepted := false 322 statusMask := &PlanAssignmentRequest_Status_FieldMask{} 323 wholeStatusAccepted := false 324 metadataMask := &meta.Meta_FieldMask{} 325 wholeMetadataAccepted := false 326 327 for _, p := range fieldMask.Paths { 328 switch tp := p.(type) { 329 case *PlanAssignmentRequest_FieldTerminalPath: 330 switch tp.selector { 331 case PlanAssignmentRequest_FieldPathSelectorName: 332 result.Name = source.Name 333 case PlanAssignmentRequest_FieldPathSelectorRequest: 334 result.Request = source.Request 335 wholeRequestAccepted = true 336 case PlanAssignmentRequest_FieldPathSelectorService: 337 result.Service = source.Service 338 case PlanAssignmentRequest_FieldPathSelectorApprover: 339 result.Approver = source.Approver 340 case PlanAssignmentRequest_FieldPathSelectorStatus: 341 result.Status = source.Status 342 wholeStatusAccepted = true 343 case PlanAssignmentRequest_FieldPathSelectorMetadata: 344 result.Metadata = source.Metadata 345 wholeMetadataAccepted = true 346 } 347 case *PlanAssignmentRequest_FieldSubPath: 348 switch tp.selector { 349 case PlanAssignmentRequest_FieldPathSelectorRequest: 350 requestMask.AppendPath(tp.subPath.(PlanAssignmentRequestRequestType_FieldPath)) 351 case PlanAssignmentRequest_FieldPathSelectorStatus: 352 statusMask.AppendPath(tp.subPath.(PlanAssignmentRequestStatus_FieldPath)) 353 case PlanAssignmentRequest_FieldPathSelectorMetadata: 354 metadataMask.AppendPath(tp.subPath.(meta.Meta_FieldPath)) 355 } 356 } 357 } 358 if wholeRequestAccepted == false && len(requestMask.Paths) > 0 { 359 result.Request = requestMask.Project(source.GetRequest()) 360 } 361 if wholeStatusAccepted == false && len(statusMask.Paths) > 0 { 362 result.Status = statusMask.Project(source.GetStatus()) 363 } 364 if wholeMetadataAccepted == false && len(metadataMask.Paths) > 0 { 365 result.Metadata = metadataMask.Project(source.GetMetadata()) 366 } 367 return result 368 } 369 370 func (fieldMask *PlanAssignmentRequest_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt { 371 return fieldMask.Project(source.(*PlanAssignmentRequest)) 372 } 373 374 func (fieldMask *PlanAssignmentRequest_FieldMask) PathsCount() int { 375 if fieldMask == nil { 376 return 0 377 } 378 return len(fieldMask.Paths) 379 } 380 381 type PlanAssignmentRequest_Status_FieldMask struct { 382 Paths []PlanAssignmentRequestStatus_FieldPath 383 } 384 385 func FullPlanAssignmentRequest_Status_FieldMask() *PlanAssignmentRequest_Status_FieldMask { 386 res := &PlanAssignmentRequest_Status_FieldMask{} 387 res.Paths = append(res.Paths, &PlanAssignmentRequestStatus_FieldTerminalPath{selector: PlanAssignmentRequestStatus_FieldPathSelectorConclusion}) 388 res.Paths = append(res.Paths, &PlanAssignmentRequestStatus_FieldTerminalPath{selector: PlanAssignmentRequestStatus_FieldPathSelectorReason}) 389 return res 390 } 391 392 func (fieldMask *PlanAssignmentRequest_Status_FieldMask) String() string { 393 if fieldMask == nil { 394 return "<nil>" 395 } 396 pathsStr := make([]string, 0, len(fieldMask.Paths)) 397 for _, path := range fieldMask.Paths { 398 pathsStr = append(pathsStr, path.String()) 399 } 400 return strings.Join(pathsStr, ", ") 401 } 402 403 func (fieldMask *PlanAssignmentRequest_Status_FieldMask) IsFull() bool { 404 if fieldMask == nil { 405 return false 406 } 407 presentSelectors := make([]bool, 2) 408 for _, path := range fieldMask.Paths { 409 if asFinal, ok := path.(*PlanAssignmentRequestStatus_FieldTerminalPath); ok { 410 presentSelectors[int(asFinal.selector)] = true 411 } 412 } 413 for _, flag := range presentSelectors { 414 if !flag { 415 return false 416 } 417 } 418 return true 419 } 420 421 func (fieldMask *PlanAssignmentRequest_Status_FieldMask) ProtoReflect() preflect.Message { 422 return gotenobject.MakeFieldMaskReflection(fieldMask, func(raw string) (gotenobject.FieldPath, error) { 423 return ParsePlanAssignmentRequestStatus_FieldPath(raw) 424 }) 425 } 426 427 func (fieldMask *PlanAssignmentRequest_Status_FieldMask) ProtoMessage() {} 428 429 func (fieldMask *PlanAssignmentRequest_Status_FieldMask) Reset() { 430 if fieldMask != nil { 431 fieldMask.Paths = nil 432 } 433 } 434 435 func (fieldMask *PlanAssignmentRequest_Status_FieldMask) Subtract(other *PlanAssignmentRequest_Status_FieldMask) *PlanAssignmentRequest_Status_FieldMask { 436 result := &PlanAssignmentRequest_Status_FieldMask{} 437 removedSelectors := make([]bool, 2) 438 439 for _, path := range other.GetPaths() { 440 switch tp := path.(type) { 441 case *PlanAssignmentRequestStatus_FieldTerminalPath: 442 removedSelectors[int(tp.selector)] = true 443 } 444 } 445 for _, path := range fieldMask.GetPaths() { 446 if !removedSelectors[int(path.Selector())] { 447 result.Paths = append(result.Paths, path) 448 } 449 } 450 451 if len(result.Paths) == 0 { 452 return nil 453 } 454 return result 455 } 456 457 func (fieldMask *PlanAssignmentRequest_Status_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask { 458 return fieldMask.Subtract(other.(*PlanAssignmentRequest_Status_FieldMask)) 459 } 460 461 // FilterInputFields generates copy of field paths with output_only field paths removed 462 func (fieldMask *PlanAssignmentRequest_Status_FieldMask) FilterInputFields() *PlanAssignmentRequest_Status_FieldMask { 463 result := &PlanAssignmentRequest_Status_FieldMask{} 464 result.Paths = append(result.Paths, fieldMask.Paths...) 465 return result 466 } 467 468 // ToFieldMask is used for proto conversions 469 func (fieldMask *PlanAssignmentRequest_Status_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 *PlanAssignmentRequest_Status_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([]PlanAssignmentRequestStatus_FieldPath, 0, len(protoFieldMask.Paths)) 482 for _, strPath := range protoFieldMask.Paths { 483 path, err := ParsePlanAssignmentRequestStatus_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 PlanAssignmentRequest_Status_FieldMask) Marshal() ([]byte, error) { 494 protoFieldMask := fieldMask.ToProtoFieldMask() 495 return proto.Marshal(protoFieldMask) 496 } 497 498 func (fieldMask *PlanAssignmentRequest_Status_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 *PlanAssignmentRequest_Status_FieldMask) Size() int { 510 return proto.Size(fieldMask.ToProtoFieldMask()) 511 } 512 513 func (fieldMask PlanAssignmentRequest_Status_FieldMask) MarshalJSON() ([]byte, error) { 514 return json.Marshal(fieldMask.ToProtoFieldMask()) 515 } 516 517 func (fieldMask *PlanAssignmentRequest_Status_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 *PlanAssignmentRequest_Status_FieldMask) AppendPath(path PlanAssignmentRequestStatus_FieldPath) { 529 fieldMask.Paths = append(fieldMask.Paths, path) 530 } 531 532 func (fieldMask *PlanAssignmentRequest_Status_FieldMask) AppendRawPath(path gotenobject.FieldPath) { 533 fieldMask.Paths = append(fieldMask.Paths, path.(PlanAssignmentRequestStatus_FieldPath)) 534 } 535 536 func (fieldMask *PlanAssignmentRequest_Status_FieldMask) GetPaths() []PlanAssignmentRequestStatus_FieldPath { 537 if fieldMask == nil { 538 return nil 539 } 540 return fieldMask.Paths 541 } 542 543 func (fieldMask *PlanAssignmentRequest_Status_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 *PlanAssignmentRequest_Status_FieldMask) SetFromCliFlag(raw string) error { 555 path, err := ParsePlanAssignmentRequestStatus_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 *PlanAssignmentRequest_Status_FieldMask) Set(target, source *PlanAssignmentRequest_Status) { 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 *PlanAssignmentRequest_Status_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) { 575 fieldMask.Set(target.(*PlanAssignmentRequest_Status), source.(*PlanAssignmentRequest_Status)) 576 } 577 578 func (fieldMask *PlanAssignmentRequest_Status_FieldMask) Project(source *PlanAssignmentRequest_Status) *PlanAssignmentRequest_Status { 579 if source == nil { 580 return nil 581 } 582 if fieldMask == nil { 583 return source 584 } 585 result := &PlanAssignmentRequest_Status{} 586 587 for _, p := range fieldMask.Paths { 588 switch tp := p.(type) { 589 case *PlanAssignmentRequestStatus_FieldTerminalPath: 590 switch tp.selector { 591 case PlanAssignmentRequestStatus_FieldPathSelectorConclusion: 592 result.Conclusion = source.Conclusion 593 case PlanAssignmentRequestStatus_FieldPathSelectorReason: 594 result.Reason = source.Reason 595 } 596 } 597 } 598 return result 599 } 600 601 func (fieldMask *PlanAssignmentRequest_Status_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt { 602 return fieldMask.Project(source.(*PlanAssignmentRequest_Status)) 603 } 604 605 func (fieldMask *PlanAssignmentRequest_Status_FieldMask) PathsCount() int { 606 if fieldMask == nil { 607 return 0 608 } 609 return len(fieldMask.Paths) 610 } 611 612 type PlanAssignmentRequest_RequestType_FieldMask struct { 613 Paths []PlanAssignmentRequestRequestType_FieldPath 614 } 615 616 func FullPlanAssignmentRequest_RequestType_FieldMask() *PlanAssignmentRequest_RequestType_FieldMask { 617 res := &PlanAssignmentRequest_RequestType_FieldMask{} 618 res.Paths = append(res.Paths, &PlanAssignmentRequestRequestType_FieldTerminalPath{selector: PlanAssignmentRequestRequestType_FieldPathSelectorAssign}) 619 res.Paths = append(res.Paths, &PlanAssignmentRequestRequestType_FieldTerminalPath{selector: PlanAssignmentRequestRequestType_FieldPathSelectorExtend}) 620 res.Paths = append(res.Paths, &PlanAssignmentRequestRequestType_FieldTerminalPath{selector: PlanAssignmentRequestRequestType_FieldPathSelectorRedistribute}) 621 res.Paths = append(res.Paths, &PlanAssignmentRequestRequestType_FieldTerminalPath{selector: PlanAssignmentRequestRequestType_FieldPathSelectorUnassign}) 622 return res 623 } 624 625 func (fieldMask *PlanAssignmentRequest_RequestType_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 *PlanAssignmentRequest_RequestType_FieldMask) IsFull() bool { 637 if fieldMask == nil { 638 return false 639 } 640 presentSelectors := make([]bool, 4) 641 for _, path := range fieldMask.Paths { 642 if asFinal, ok := path.(*PlanAssignmentRequestRequestType_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 *PlanAssignmentRequest_RequestType_FieldMask) ProtoReflect() preflect.Message { 655 return gotenobject.MakeFieldMaskReflection(fieldMask, func(raw string) (gotenobject.FieldPath, error) { 656 return ParsePlanAssignmentRequestRequestType_FieldPath(raw) 657 }) 658 } 659 660 func (fieldMask *PlanAssignmentRequest_RequestType_FieldMask) ProtoMessage() {} 661 662 func (fieldMask *PlanAssignmentRequest_RequestType_FieldMask) Reset() { 663 if fieldMask != nil { 664 fieldMask.Paths = nil 665 } 666 } 667 668 func (fieldMask *PlanAssignmentRequest_RequestType_FieldMask) Subtract(other *PlanAssignmentRequest_RequestType_FieldMask) *PlanAssignmentRequest_RequestType_FieldMask { 669 result := &PlanAssignmentRequest_RequestType_FieldMask{} 670 removedSelectors := make([]bool, 4) 671 otherSubMasks := map[PlanAssignmentRequestRequestType_FieldPathSelector]gotenobject.FieldMask{ 672 PlanAssignmentRequestRequestType_FieldPathSelectorAssign: &PlanAssignmentRequest_RequestType_Assign_FieldMask{}, 673 PlanAssignmentRequestRequestType_FieldPathSelectorExtend: &PlanAssignmentRequest_RequestType_Extend_FieldMask{}, 674 PlanAssignmentRequestRequestType_FieldPathSelectorRedistribute: &PlanAssignmentRequest_RequestType_Redistribute_FieldMask{}, 675 PlanAssignmentRequestRequestType_FieldPathSelectorUnassign: &PlanAssignmentRequest_RequestType_Unassign_FieldMask{}, 676 } 677 mySubMasks := map[PlanAssignmentRequestRequestType_FieldPathSelector]gotenobject.FieldMask{ 678 PlanAssignmentRequestRequestType_FieldPathSelectorAssign: &PlanAssignmentRequest_RequestType_Assign_FieldMask{}, 679 PlanAssignmentRequestRequestType_FieldPathSelectorExtend: &PlanAssignmentRequest_RequestType_Extend_FieldMask{}, 680 PlanAssignmentRequestRequestType_FieldPathSelectorRedistribute: &PlanAssignmentRequest_RequestType_Redistribute_FieldMask{}, 681 PlanAssignmentRequestRequestType_FieldPathSelectorUnassign: &PlanAssignmentRequest_RequestType_Unassign_FieldMask{}, 682 } 683 684 for _, path := range other.GetPaths() { 685 switch tp := path.(type) { 686 case *PlanAssignmentRequestRequestType_FieldTerminalPath: 687 removedSelectors[int(tp.selector)] = true 688 case *PlanAssignmentRequestRequestType_FieldSubPath: 689 otherSubMasks[tp.selector].AppendRawPath(tp.subPath) 690 } 691 } 692 for _, path := range fieldMask.GetPaths() { 693 if !removedSelectors[int(path.Selector())] { 694 if otherSubMask := otherSubMasks[path.Selector()]; otherSubMask != nil && otherSubMask.PathsCount() > 0 { 695 if tp, ok := path.(*PlanAssignmentRequestRequestType_FieldTerminalPath); ok { 696 switch tp.selector { 697 case PlanAssignmentRequestRequestType_FieldPathSelectorAssign: 698 mySubMasks[PlanAssignmentRequestRequestType_FieldPathSelectorAssign] = FullPlanAssignmentRequest_RequestType_Assign_FieldMask() 699 case PlanAssignmentRequestRequestType_FieldPathSelectorExtend: 700 mySubMasks[PlanAssignmentRequestRequestType_FieldPathSelectorExtend] = FullPlanAssignmentRequest_RequestType_Extend_FieldMask() 701 case PlanAssignmentRequestRequestType_FieldPathSelectorRedistribute: 702 mySubMasks[PlanAssignmentRequestRequestType_FieldPathSelectorRedistribute] = FullPlanAssignmentRequest_RequestType_Redistribute_FieldMask() 703 case PlanAssignmentRequestRequestType_FieldPathSelectorUnassign: 704 mySubMasks[PlanAssignmentRequestRequestType_FieldPathSelectorUnassign] = FullPlanAssignmentRequest_RequestType_Unassign_FieldMask() 705 } 706 } else if tp, ok := path.(*PlanAssignmentRequestRequestType_FieldSubPath); ok { 707 mySubMasks[tp.selector].AppendRawPath(tp.subPath) 708 } 709 } else { 710 result.Paths = append(result.Paths, path) 711 } 712 } 713 } 714 for selector, mySubMask := range mySubMasks { 715 if mySubMask.PathsCount() > 0 { 716 for _, allowedPath := range mySubMask.SubtractRaw(otherSubMasks[selector]).GetRawPaths() { 717 result.Paths = append(result.Paths, &PlanAssignmentRequestRequestType_FieldSubPath{selector: selector, subPath: allowedPath}) 718 } 719 } 720 } 721 722 if len(result.Paths) == 0 { 723 return nil 724 } 725 return result 726 } 727 728 func (fieldMask *PlanAssignmentRequest_RequestType_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask { 729 return fieldMask.Subtract(other.(*PlanAssignmentRequest_RequestType_FieldMask)) 730 } 731 732 // FilterInputFields generates copy of field paths with output_only field paths removed 733 func (fieldMask *PlanAssignmentRequest_RequestType_FieldMask) FilterInputFields() *PlanAssignmentRequest_RequestType_FieldMask { 734 result := &PlanAssignmentRequest_RequestType_FieldMask{} 735 result.Paths = append(result.Paths, fieldMask.Paths...) 736 return result 737 } 738 739 // ToFieldMask is used for proto conversions 740 func (fieldMask *PlanAssignmentRequest_RequestType_FieldMask) ToProtoFieldMask() *googlefieldmaskpb.FieldMask { 741 protoFieldMask := &googlefieldmaskpb.FieldMask{} 742 for _, path := range fieldMask.Paths { 743 protoFieldMask.Paths = append(protoFieldMask.Paths, path.String()) 744 } 745 return protoFieldMask 746 } 747 748 func (fieldMask *PlanAssignmentRequest_RequestType_FieldMask) FromProtoFieldMask(protoFieldMask *googlefieldmaskpb.FieldMask) error { 749 if fieldMask == nil { 750 return status.Error(codes.Internal, "target field mask is nil") 751 } 752 fieldMask.Paths = make([]PlanAssignmentRequestRequestType_FieldPath, 0, len(protoFieldMask.Paths)) 753 for _, strPath := range protoFieldMask.Paths { 754 path, err := ParsePlanAssignmentRequestRequestType_FieldPath(strPath) 755 if err != nil { 756 return err 757 } 758 fieldMask.Paths = append(fieldMask.Paths, path) 759 } 760 return nil 761 } 762 763 // implement methods required by customType 764 func (fieldMask PlanAssignmentRequest_RequestType_FieldMask) Marshal() ([]byte, error) { 765 protoFieldMask := fieldMask.ToProtoFieldMask() 766 return proto.Marshal(protoFieldMask) 767 } 768 769 func (fieldMask *PlanAssignmentRequest_RequestType_FieldMask) Unmarshal(data []byte) error { 770 protoFieldMask := &googlefieldmaskpb.FieldMask{} 771 if err := proto.Unmarshal(data, protoFieldMask); err != nil { 772 return err 773 } 774 if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil { 775 return err 776 } 777 return nil 778 } 779 780 func (fieldMask *PlanAssignmentRequest_RequestType_FieldMask) Size() int { 781 return proto.Size(fieldMask.ToProtoFieldMask()) 782 } 783 784 func (fieldMask PlanAssignmentRequest_RequestType_FieldMask) MarshalJSON() ([]byte, error) { 785 return json.Marshal(fieldMask.ToProtoFieldMask()) 786 } 787 788 func (fieldMask *PlanAssignmentRequest_RequestType_FieldMask) UnmarshalJSON(data []byte) error { 789 protoFieldMask := &googlefieldmaskpb.FieldMask{} 790 if err := json.Unmarshal(data, protoFieldMask); err != nil { 791 return err 792 } 793 if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil { 794 return err 795 } 796 return nil 797 } 798 799 func (fieldMask *PlanAssignmentRequest_RequestType_FieldMask) AppendPath(path PlanAssignmentRequestRequestType_FieldPath) { 800 fieldMask.Paths = append(fieldMask.Paths, path) 801 } 802 803 func (fieldMask *PlanAssignmentRequest_RequestType_FieldMask) AppendRawPath(path gotenobject.FieldPath) { 804 fieldMask.Paths = append(fieldMask.Paths, path.(PlanAssignmentRequestRequestType_FieldPath)) 805 } 806 807 func (fieldMask *PlanAssignmentRequest_RequestType_FieldMask) GetPaths() []PlanAssignmentRequestRequestType_FieldPath { 808 if fieldMask == nil { 809 return nil 810 } 811 return fieldMask.Paths 812 } 813 814 func (fieldMask *PlanAssignmentRequest_RequestType_FieldMask) GetRawPaths() []gotenobject.FieldPath { 815 if fieldMask == nil { 816 return nil 817 } 818 rawPaths := make([]gotenobject.FieldPath, 0, len(fieldMask.Paths)) 819 for _, path := range fieldMask.Paths { 820 rawPaths = append(rawPaths, path) 821 } 822 return rawPaths 823 } 824 825 func (fieldMask *PlanAssignmentRequest_RequestType_FieldMask) SetFromCliFlag(raw string) error { 826 path, err := ParsePlanAssignmentRequestRequestType_FieldPath(raw) 827 if err != nil { 828 return err 829 } 830 fieldMask.Paths = append(fieldMask.Paths, path) 831 return nil 832 } 833 834 func (fieldMask *PlanAssignmentRequest_RequestType_FieldMask) Set(target, source *PlanAssignmentRequest_RequestType) { 835 for _, path := range fieldMask.Paths { 836 val, _ := path.GetSingle(source) 837 // if val is nil, then field does not exist in source, skip 838 // otherwise, process (can still reflect.ValueOf(val).IsNil!) 839 if val != nil { 840 path.WithIValue(val).SetTo(&target) 841 } 842 } 843 } 844 845 func (fieldMask *PlanAssignmentRequest_RequestType_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) { 846 fieldMask.Set(target.(*PlanAssignmentRequest_RequestType), source.(*PlanAssignmentRequest_RequestType)) 847 } 848 849 func (fieldMask *PlanAssignmentRequest_RequestType_FieldMask) Project(source *PlanAssignmentRequest_RequestType) *PlanAssignmentRequest_RequestType { 850 if source == nil { 851 return nil 852 } 853 if fieldMask == nil { 854 return source 855 } 856 result := &PlanAssignmentRequest_RequestType{} 857 assignMask := &PlanAssignmentRequest_RequestType_Assign_FieldMask{} 858 wholeAssignAccepted := false 859 extendMask := &PlanAssignmentRequest_RequestType_Extend_FieldMask{} 860 wholeExtendAccepted := false 861 redistributeMask := &PlanAssignmentRequest_RequestType_Redistribute_FieldMask{} 862 wholeRedistributeAccepted := false 863 unassignMask := &PlanAssignmentRequest_RequestType_Unassign_FieldMask{} 864 wholeUnassignAccepted := false 865 866 for _, p := range fieldMask.Paths { 867 switch tp := p.(type) { 868 case *PlanAssignmentRequestRequestType_FieldTerminalPath: 869 switch tp.selector { 870 case PlanAssignmentRequestRequestType_FieldPathSelectorAssign: 871 if source, ok := source.Request.(*PlanAssignmentRequest_RequestType_Assign_); ok { 872 result.Request = &PlanAssignmentRequest_RequestType_Assign_{ 873 Assign: source.Assign, 874 } 875 } 876 wholeAssignAccepted = true 877 case PlanAssignmentRequestRequestType_FieldPathSelectorExtend: 878 if source, ok := source.Request.(*PlanAssignmentRequest_RequestType_Extend_); ok { 879 result.Request = &PlanAssignmentRequest_RequestType_Extend_{ 880 Extend: source.Extend, 881 } 882 } 883 wholeExtendAccepted = true 884 case PlanAssignmentRequestRequestType_FieldPathSelectorRedistribute: 885 if source, ok := source.Request.(*PlanAssignmentRequest_RequestType_Redistribute_); ok { 886 result.Request = &PlanAssignmentRequest_RequestType_Redistribute_{ 887 Redistribute: source.Redistribute, 888 } 889 } 890 wholeRedistributeAccepted = true 891 case PlanAssignmentRequestRequestType_FieldPathSelectorUnassign: 892 if source, ok := source.Request.(*PlanAssignmentRequest_RequestType_Unassign_); ok { 893 result.Request = &PlanAssignmentRequest_RequestType_Unassign_{ 894 Unassign: source.Unassign, 895 } 896 } 897 wholeUnassignAccepted = true 898 } 899 case *PlanAssignmentRequestRequestType_FieldSubPath: 900 switch tp.selector { 901 case PlanAssignmentRequestRequestType_FieldPathSelectorAssign: 902 assignMask.AppendPath(tp.subPath.(PlanAssignmentRequestRequestTypeAssign_FieldPath)) 903 case PlanAssignmentRequestRequestType_FieldPathSelectorExtend: 904 extendMask.AppendPath(tp.subPath.(PlanAssignmentRequestRequestTypeExtend_FieldPath)) 905 case PlanAssignmentRequestRequestType_FieldPathSelectorRedistribute: 906 redistributeMask.AppendPath(tp.subPath.(PlanAssignmentRequestRequestTypeRedistribute_FieldPath)) 907 case PlanAssignmentRequestRequestType_FieldPathSelectorUnassign: 908 unassignMask.AppendPath(tp.subPath.(PlanAssignmentRequestRequestTypeUnassign_FieldPath)) 909 } 910 } 911 } 912 if wholeAssignAccepted == false && len(assignMask.Paths) > 0 { 913 if asOneOf, ok := source.Request.(*PlanAssignmentRequest_RequestType_Assign_); ok { 914 result.Request = (*PlanAssignmentRequest_RequestType_Assign_)(nil) 915 if asOneOf != nil { 916 oneOfRes := &PlanAssignmentRequest_RequestType_Assign_{} 917 oneOfRes.Assign = assignMask.Project(asOneOf.Assign) 918 result.Request = oneOfRes 919 } 920 } 921 } 922 if wholeExtendAccepted == false && len(extendMask.Paths) > 0 { 923 if asOneOf, ok := source.Request.(*PlanAssignmentRequest_RequestType_Extend_); ok { 924 result.Request = (*PlanAssignmentRequest_RequestType_Extend_)(nil) 925 if asOneOf != nil { 926 oneOfRes := &PlanAssignmentRequest_RequestType_Extend_{} 927 oneOfRes.Extend = extendMask.Project(asOneOf.Extend) 928 result.Request = oneOfRes 929 } 930 } 931 } 932 if wholeRedistributeAccepted == false && len(redistributeMask.Paths) > 0 { 933 if asOneOf, ok := source.Request.(*PlanAssignmentRequest_RequestType_Redistribute_); ok { 934 result.Request = (*PlanAssignmentRequest_RequestType_Redistribute_)(nil) 935 if asOneOf != nil { 936 oneOfRes := &PlanAssignmentRequest_RequestType_Redistribute_{} 937 oneOfRes.Redistribute = redistributeMask.Project(asOneOf.Redistribute) 938 result.Request = oneOfRes 939 } 940 } 941 } 942 if wholeUnassignAccepted == false && len(unassignMask.Paths) > 0 { 943 if asOneOf, ok := source.Request.(*PlanAssignmentRequest_RequestType_Unassign_); ok { 944 result.Request = (*PlanAssignmentRequest_RequestType_Unassign_)(nil) 945 if asOneOf != nil { 946 oneOfRes := &PlanAssignmentRequest_RequestType_Unassign_{} 947 oneOfRes.Unassign = unassignMask.Project(asOneOf.Unassign) 948 result.Request = oneOfRes 949 } 950 } 951 } 952 return result 953 } 954 955 func (fieldMask *PlanAssignmentRequest_RequestType_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt { 956 return fieldMask.Project(source.(*PlanAssignmentRequest_RequestType)) 957 } 958 959 func (fieldMask *PlanAssignmentRequest_RequestType_FieldMask) PathsCount() int { 960 if fieldMask == nil { 961 return 0 962 } 963 return len(fieldMask.Paths) 964 } 965 966 type PlanAssignmentRequest_RequestType_Assign_FieldMask struct { 967 Paths []PlanAssignmentRequestRequestTypeAssign_FieldPath 968 } 969 970 func FullPlanAssignmentRequest_RequestType_Assign_FieldMask() *PlanAssignmentRequest_RequestType_Assign_FieldMask { 971 res := &PlanAssignmentRequest_RequestType_Assign_FieldMask{} 972 res.Paths = append(res.Paths, &PlanAssignmentRequestRequestTypeAssign_FieldTerminalPath{selector: PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorPlan}) 973 res.Paths = append(res.Paths, &PlanAssignmentRequestRequestTypeAssign_FieldTerminalPath{selector: PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorExtensions}) 974 res.Paths = append(res.Paths, &PlanAssignmentRequestRequestTypeAssign_FieldTerminalPath{selector: PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorRegionalDistributions}) 975 return res 976 } 977 978 func (fieldMask *PlanAssignmentRequest_RequestType_Assign_FieldMask) String() string { 979 if fieldMask == nil { 980 return "<nil>" 981 } 982 pathsStr := make([]string, 0, len(fieldMask.Paths)) 983 for _, path := range fieldMask.Paths { 984 pathsStr = append(pathsStr, path.String()) 985 } 986 return strings.Join(pathsStr, ", ") 987 } 988 989 func (fieldMask *PlanAssignmentRequest_RequestType_Assign_FieldMask) IsFull() bool { 990 if fieldMask == nil { 991 return false 992 } 993 presentSelectors := make([]bool, 3) 994 for _, path := range fieldMask.Paths { 995 if asFinal, ok := path.(*PlanAssignmentRequestRequestTypeAssign_FieldTerminalPath); ok { 996 presentSelectors[int(asFinal.selector)] = true 997 } 998 } 999 for _, flag := range presentSelectors { 1000 if !flag { 1001 return false 1002 } 1003 } 1004 return true 1005 } 1006 1007 func (fieldMask *PlanAssignmentRequest_RequestType_Assign_FieldMask) ProtoReflect() preflect.Message { 1008 return gotenobject.MakeFieldMaskReflection(fieldMask, func(raw string) (gotenobject.FieldPath, error) { 1009 return ParsePlanAssignmentRequestRequestTypeAssign_FieldPath(raw) 1010 }) 1011 } 1012 1013 func (fieldMask *PlanAssignmentRequest_RequestType_Assign_FieldMask) ProtoMessage() {} 1014 1015 func (fieldMask *PlanAssignmentRequest_RequestType_Assign_FieldMask) Reset() { 1016 if fieldMask != nil { 1017 fieldMask.Paths = nil 1018 } 1019 } 1020 1021 func (fieldMask *PlanAssignmentRequest_RequestType_Assign_FieldMask) Subtract(other *PlanAssignmentRequest_RequestType_Assign_FieldMask) *PlanAssignmentRequest_RequestType_Assign_FieldMask { 1022 result := &PlanAssignmentRequest_RequestType_Assign_FieldMask{} 1023 removedSelectors := make([]bool, 3) 1024 otherSubMasks := map[PlanAssignmentRequestRequestTypeAssign_FieldPathSelector]gotenobject.FieldMask{ 1025 PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorExtensions: &common.Allowance_FieldMask{}, 1026 PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorRegionalDistributions: &common.RegionalDistribution_FieldMask{}, 1027 } 1028 mySubMasks := map[PlanAssignmentRequestRequestTypeAssign_FieldPathSelector]gotenobject.FieldMask{ 1029 PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorExtensions: &common.Allowance_FieldMask{}, 1030 PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorRegionalDistributions: &common.RegionalDistribution_FieldMask{}, 1031 } 1032 1033 for _, path := range other.GetPaths() { 1034 switch tp := path.(type) { 1035 case *PlanAssignmentRequestRequestTypeAssign_FieldTerminalPath: 1036 removedSelectors[int(tp.selector)] = true 1037 case *PlanAssignmentRequestRequestTypeAssign_FieldSubPath: 1038 otherSubMasks[tp.selector].AppendRawPath(tp.subPath) 1039 } 1040 } 1041 for _, path := range fieldMask.GetPaths() { 1042 if !removedSelectors[int(path.Selector())] { 1043 if otherSubMask := otherSubMasks[path.Selector()]; otherSubMask != nil && otherSubMask.PathsCount() > 0 { 1044 if tp, ok := path.(*PlanAssignmentRequestRequestTypeAssign_FieldTerminalPath); ok { 1045 switch tp.selector { 1046 case PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorExtensions: 1047 mySubMasks[PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorExtensions] = common.FullAllowance_FieldMask() 1048 case PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorRegionalDistributions: 1049 mySubMasks[PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorRegionalDistributions] = common.FullRegionalDistribution_FieldMask() 1050 } 1051 } else if tp, ok := path.(*PlanAssignmentRequestRequestTypeAssign_FieldSubPath); ok { 1052 mySubMasks[tp.selector].AppendRawPath(tp.subPath) 1053 } 1054 } else { 1055 result.Paths = append(result.Paths, path) 1056 } 1057 } 1058 } 1059 for selector, mySubMask := range mySubMasks { 1060 if mySubMask.PathsCount() > 0 { 1061 for _, allowedPath := range mySubMask.SubtractRaw(otherSubMasks[selector]).GetRawPaths() { 1062 result.Paths = append(result.Paths, &PlanAssignmentRequestRequestTypeAssign_FieldSubPath{selector: selector, subPath: allowedPath}) 1063 } 1064 } 1065 } 1066 1067 if len(result.Paths) == 0 { 1068 return nil 1069 } 1070 return result 1071 } 1072 1073 func (fieldMask *PlanAssignmentRequest_RequestType_Assign_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask { 1074 return fieldMask.Subtract(other.(*PlanAssignmentRequest_RequestType_Assign_FieldMask)) 1075 } 1076 1077 // FilterInputFields generates copy of field paths with output_only field paths removed 1078 func (fieldMask *PlanAssignmentRequest_RequestType_Assign_FieldMask) FilterInputFields() *PlanAssignmentRequest_RequestType_Assign_FieldMask { 1079 result := &PlanAssignmentRequest_RequestType_Assign_FieldMask{} 1080 result.Paths = append(result.Paths, fieldMask.Paths...) 1081 return result 1082 } 1083 1084 // ToFieldMask is used for proto conversions 1085 func (fieldMask *PlanAssignmentRequest_RequestType_Assign_FieldMask) ToProtoFieldMask() *googlefieldmaskpb.FieldMask { 1086 protoFieldMask := &googlefieldmaskpb.FieldMask{} 1087 for _, path := range fieldMask.Paths { 1088 protoFieldMask.Paths = append(protoFieldMask.Paths, path.String()) 1089 } 1090 return protoFieldMask 1091 } 1092 1093 func (fieldMask *PlanAssignmentRequest_RequestType_Assign_FieldMask) FromProtoFieldMask(protoFieldMask *googlefieldmaskpb.FieldMask) error { 1094 if fieldMask == nil { 1095 return status.Error(codes.Internal, "target field mask is nil") 1096 } 1097 fieldMask.Paths = make([]PlanAssignmentRequestRequestTypeAssign_FieldPath, 0, len(protoFieldMask.Paths)) 1098 for _, strPath := range protoFieldMask.Paths { 1099 path, err := ParsePlanAssignmentRequestRequestTypeAssign_FieldPath(strPath) 1100 if err != nil { 1101 return err 1102 } 1103 fieldMask.Paths = append(fieldMask.Paths, path) 1104 } 1105 return nil 1106 } 1107 1108 // implement methods required by customType 1109 func (fieldMask PlanAssignmentRequest_RequestType_Assign_FieldMask) Marshal() ([]byte, error) { 1110 protoFieldMask := fieldMask.ToProtoFieldMask() 1111 return proto.Marshal(protoFieldMask) 1112 } 1113 1114 func (fieldMask *PlanAssignmentRequest_RequestType_Assign_FieldMask) Unmarshal(data []byte) error { 1115 protoFieldMask := &googlefieldmaskpb.FieldMask{} 1116 if err := proto.Unmarshal(data, protoFieldMask); err != nil { 1117 return err 1118 } 1119 if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil { 1120 return err 1121 } 1122 return nil 1123 } 1124 1125 func (fieldMask *PlanAssignmentRequest_RequestType_Assign_FieldMask) Size() int { 1126 return proto.Size(fieldMask.ToProtoFieldMask()) 1127 } 1128 1129 func (fieldMask PlanAssignmentRequest_RequestType_Assign_FieldMask) MarshalJSON() ([]byte, error) { 1130 return json.Marshal(fieldMask.ToProtoFieldMask()) 1131 } 1132 1133 func (fieldMask *PlanAssignmentRequest_RequestType_Assign_FieldMask) UnmarshalJSON(data []byte) error { 1134 protoFieldMask := &googlefieldmaskpb.FieldMask{} 1135 if err := json.Unmarshal(data, protoFieldMask); err != nil { 1136 return err 1137 } 1138 if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil { 1139 return err 1140 } 1141 return nil 1142 } 1143 1144 func (fieldMask *PlanAssignmentRequest_RequestType_Assign_FieldMask) AppendPath(path PlanAssignmentRequestRequestTypeAssign_FieldPath) { 1145 fieldMask.Paths = append(fieldMask.Paths, path) 1146 } 1147 1148 func (fieldMask *PlanAssignmentRequest_RequestType_Assign_FieldMask) AppendRawPath(path gotenobject.FieldPath) { 1149 fieldMask.Paths = append(fieldMask.Paths, path.(PlanAssignmentRequestRequestTypeAssign_FieldPath)) 1150 } 1151 1152 func (fieldMask *PlanAssignmentRequest_RequestType_Assign_FieldMask) GetPaths() []PlanAssignmentRequestRequestTypeAssign_FieldPath { 1153 if fieldMask == nil { 1154 return nil 1155 } 1156 return fieldMask.Paths 1157 } 1158 1159 func (fieldMask *PlanAssignmentRequest_RequestType_Assign_FieldMask) GetRawPaths() []gotenobject.FieldPath { 1160 if fieldMask == nil { 1161 return nil 1162 } 1163 rawPaths := make([]gotenobject.FieldPath, 0, len(fieldMask.Paths)) 1164 for _, path := range fieldMask.Paths { 1165 rawPaths = append(rawPaths, path) 1166 } 1167 return rawPaths 1168 } 1169 1170 func (fieldMask *PlanAssignmentRequest_RequestType_Assign_FieldMask) SetFromCliFlag(raw string) error { 1171 path, err := ParsePlanAssignmentRequestRequestTypeAssign_FieldPath(raw) 1172 if err != nil { 1173 return err 1174 } 1175 fieldMask.Paths = append(fieldMask.Paths, path) 1176 return nil 1177 } 1178 1179 func (fieldMask *PlanAssignmentRequest_RequestType_Assign_FieldMask) Set(target, source *PlanAssignmentRequest_RequestType_Assign) { 1180 for _, path := range fieldMask.Paths { 1181 val, _ := path.GetSingle(source) 1182 // if val is nil, then field does not exist in source, skip 1183 // otherwise, process (can still reflect.ValueOf(val).IsNil!) 1184 if val != nil { 1185 path.WithIValue(val).SetTo(&target) 1186 } 1187 } 1188 } 1189 1190 func (fieldMask *PlanAssignmentRequest_RequestType_Assign_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) { 1191 fieldMask.Set(target.(*PlanAssignmentRequest_RequestType_Assign), source.(*PlanAssignmentRequest_RequestType_Assign)) 1192 } 1193 1194 func (fieldMask *PlanAssignmentRequest_RequestType_Assign_FieldMask) Project(source *PlanAssignmentRequest_RequestType_Assign) *PlanAssignmentRequest_RequestType_Assign { 1195 if source == nil { 1196 return nil 1197 } 1198 if fieldMask == nil { 1199 return source 1200 } 1201 result := &PlanAssignmentRequest_RequestType_Assign{} 1202 extensionsMask := &common.Allowance_FieldMask{} 1203 wholeExtensionsAccepted := false 1204 regionalDistributionsMask := &common.RegionalDistribution_FieldMask{} 1205 wholeRegionalDistributionsAccepted := false 1206 1207 for _, p := range fieldMask.Paths { 1208 switch tp := p.(type) { 1209 case *PlanAssignmentRequestRequestTypeAssign_FieldTerminalPath: 1210 switch tp.selector { 1211 case PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorPlan: 1212 result.Plan = source.Plan 1213 case PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorExtensions: 1214 result.Extensions = source.Extensions 1215 wholeExtensionsAccepted = true 1216 case PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorRegionalDistributions: 1217 result.RegionalDistributions = source.RegionalDistributions 1218 wholeRegionalDistributionsAccepted = true 1219 } 1220 case *PlanAssignmentRequestRequestTypeAssign_FieldSubPath: 1221 switch tp.selector { 1222 case PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorExtensions: 1223 extensionsMask.AppendPath(tp.subPath.(common.Allowance_FieldPath)) 1224 case PlanAssignmentRequestRequestTypeAssign_FieldPathSelectorRegionalDistributions: 1225 regionalDistributionsMask.AppendPath(tp.subPath.(common.RegionalDistribution_FieldPath)) 1226 } 1227 } 1228 } 1229 if wholeExtensionsAccepted == false && len(extensionsMask.Paths) > 0 { 1230 for _, sourceItem := range source.GetExtensions() { 1231 result.Extensions = append(result.Extensions, extensionsMask.Project(sourceItem)) 1232 } 1233 } 1234 if wholeRegionalDistributionsAccepted == false && len(regionalDistributionsMask.Paths) > 0 { 1235 for _, sourceItem := range source.GetRegionalDistributions() { 1236 result.RegionalDistributions = append(result.RegionalDistributions, regionalDistributionsMask.Project(sourceItem)) 1237 } 1238 } 1239 return result 1240 } 1241 1242 func (fieldMask *PlanAssignmentRequest_RequestType_Assign_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt { 1243 return fieldMask.Project(source.(*PlanAssignmentRequest_RequestType_Assign)) 1244 } 1245 1246 func (fieldMask *PlanAssignmentRequest_RequestType_Assign_FieldMask) PathsCount() int { 1247 if fieldMask == nil { 1248 return 0 1249 } 1250 return len(fieldMask.Paths) 1251 } 1252 1253 type PlanAssignmentRequest_RequestType_Extend_FieldMask struct { 1254 Paths []PlanAssignmentRequestRequestTypeExtend_FieldPath 1255 } 1256 1257 func FullPlanAssignmentRequest_RequestType_Extend_FieldMask() *PlanAssignmentRequest_RequestType_Extend_FieldMask { 1258 res := &PlanAssignmentRequest_RequestType_Extend_FieldMask{} 1259 res.Paths = append(res.Paths, &PlanAssignmentRequestRequestTypeExtend_FieldTerminalPath{selector: PlanAssignmentRequestRequestTypeExtend_FieldPathSelectorAssignment}) 1260 res.Paths = append(res.Paths, &PlanAssignmentRequestRequestTypeExtend_FieldTerminalPath{selector: PlanAssignmentRequestRequestTypeExtend_FieldPathSelectorAdditions}) 1261 res.Paths = append(res.Paths, &PlanAssignmentRequestRequestTypeExtend_FieldTerminalPath{selector: PlanAssignmentRequestRequestTypeExtend_FieldPathSelectorRegionalDistributions}) 1262 return res 1263 } 1264 1265 func (fieldMask *PlanAssignmentRequest_RequestType_Extend_FieldMask) String() string { 1266 if fieldMask == nil { 1267 return "<nil>" 1268 } 1269 pathsStr := make([]string, 0, len(fieldMask.Paths)) 1270 for _, path := range fieldMask.Paths { 1271 pathsStr = append(pathsStr, path.String()) 1272 } 1273 return strings.Join(pathsStr, ", ") 1274 } 1275 1276 func (fieldMask *PlanAssignmentRequest_RequestType_Extend_FieldMask) IsFull() bool { 1277 if fieldMask == nil { 1278 return false 1279 } 1280 presentSelectors := make([]bool, 3) 1281 for _, path := range fieldMask.Paths { 1282 if asFinal, ok := path.(*PlanAssignmentRequestRequestTypeExtend_FieldTerminalPath); ok { 1283 presentSelectors[int(asFinal.selector)] = true 1284 } 1285 } 1286 for _, flag := range presentSelectors { 1287 if !flag { 1288 return false 1289 } 1290 } 1291 return true 1292 } 1293 1294 func (fieldMask *PlanAssignmentRequest_RequestType_Extend_FieldMask) ProtoReflect() preflect.Message { 1295 return gotenobject.MakeFieldMaskReflection(fieldMask, func(raw string) (gotenobject.FieldPath, error) { 1296 return ParsePlanAssignmentRequestRequestTypeExtend_FieldPath(raw) 1297 }) 1298 } 1299 1300 func (fieldMask *PlanAssignmentRequest_RequestType_Extend_FieldMask) ProtoMessage() {} 1301 1302 func (fieldMask *PlanAssignmentRequest_RequestType_Extend_FieldMask) Reset() { 1303 if fieldMask != nil { 1304 fieldMask.Paths = nil 1305 } 1306 } 1307 1308 func (fieldMask *PlanAssignmentRequest_RequestType_Extend_FieldMask) Subtract(other *PlanAssignmentRequest_RequestType_Extend_FieldMask) *PlanAssignmentRequest_RequestType_Extend_FieldMask { 1309 result := &PlanAssignmentRequest_RequestType_Extend_FieldMask{} 1310 removedSelectors := make([]bool, 3) 1311 otherSubMasks := map[PlanAssignmentRequestRequestTypeExtend_FieldPathSelector]gotenobject.FieldMask{ 1312 PlanAssignmentRequestRequestTypeExtend_FieldPathSelectorAdditions: &common.Allowance_FieldMask{}, 1313 PlanAssignmentRequestRequestTypeExtend_FieldPathSelectorRegionalDistributions: &common.RegionalDistribution_FieldMask{}, 1314 } 1315 mySubMasks := map[PlanAssignmentRequestRequestTypeExtend_FieldPathSelector]gotenobject.FieldMask{ 1316 PlanAssignmentRequestRequestTypeExtend_FieldPathSelectorAdditions: &common.Allowance_FieldMask{}, 1317 PlanAssignmentRequestRequestTypeExtend_FieldPathSelectorRegionalDistributions: &common.RegionalDistribution_FieldMask{}, 1318 } 1319 1320 for _, path := range other.GetPaths() { 1321 switch tp := path.(type) { 1322 case *PlanAssignmentRequestRequestTypeExtend_FieldTerminalPath: 1323 removedSelectors[int(tp.selector)] = true 1324 case *PlanAssignmentRequestRequestTypeExtend_FieldSubPath: 1325 otherSubMasks[tp.selector].AppendRawPath(tp.subPath) 1326 } 1327 } 1328 for _, path := range fieldMask.GetPaths() { 1329 if !removedSelectors[int(path.Selector())] { 1330 if otherSubMask := otherSubMasks[path.Selector()]; otherSubMask != nil && otherSubMask.PathsCount() > 0 { 1331 if tp, ok := path.(*PlanAssignmentRequestRequestTypeExtend_FieldTerminalPath); ok { 1332 switch tp.selector { 1333 case PlanAssignmentRequestRequestTypeExtend_FieldPathSelectorAdditions: 1334 mySubMasks[PlanAssignmentRequestRequestTypeExtend_FieldPathSelectorAdditions] = common.FullAllowance_FieldMask() 1335 case PlanAssignmentRequestRequestTypeExtend_FieldPathSelectorRegionalDistributions: 1336 mySubMasks[PlanAssignmentRequestRequestTypeExtend_FieldPathSelectorRegionalDistributions] = common.FullRegionalDistribution_FieldMask() 1337 } 1338 } else if tp, ok := path.(*PlanAssignmentRequestRequestTypeExtend_FieldSubPath); ok { 1339 mySubMasks[tp.selector].AppendRawPath(tp.subPath) 1340 } 1341 } else { 1342 result.Paths = append(result.Paths, path) 1343 } 1344 } 1345 } 1346 for selector, mySubMask := range mySubMasks { 1347 if mySubMask.PathsCount() > 0 { 1348 for _, allowedPath := range mySubMask.SubtractRaw(otherSubMasks[selector]).GetRawPaths() { 1349 result.Paths = append(result.Paths, &PlanAssignmentRequestRequestTypeExtend_FieldSubPath{selector: selector, subPath: allowedPath}) 1350 } 1351 } 1352 } 1353 1354 if len(result.Paths) == 0 { 1355 return nil 1356 } 1357 return result 1358 } 1359 1360 func (fieldMask *PlanAssignmentRequest_RequestType_Extend_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask { 1361 return fieldMask.Subtract(other.(*PlanAssignmentRequest_RequestType_Extend_FieldMask)) 1362 } 1363 1364 // FilterInputFields generates copy of field paths with output_only field paths removed 1365 func (fieldMask *PlanAssignmentRequest_RequestType_Extend_FieldMask) FilterInputFields() *PlanAssignmentRequest_RequestType_Extend_FieldMask { 1366 result := &PlanAssignmentRequest_RequestType_Extend_FieldMask{} 1367 result.Paths = append(result.Paths, fieldMask.Paths...) 1368 return result 1369 } 1370 1371 // ToFieldMask is used for proto conversions 1372 func (fieldMask *PlanAssignmentRequest_RequestType_Extend_FieldMask) ToProtoFieldMask() *googlefieldmaskpb.FieldMask { 1373 protoFieldMask := &googlefieldmaskpb.FieldMask{} 1374 for _, path := range fieldMask.Paths { 1375 protoFieldMask.Paths = append(protoFieldMask.Paths, path.String()) 1376 } 1377 return protoFieldMask 1378 } 1379 1380 func (fieldMask *PlanAssignmentRequest_RequestType_Extend_FieldMask) FromProtoFieldMask(protoFieldMask *googlefieldmaskpb.FieldMask) error { 1381 if fieldMask == nil { 1382 return status.Error(codes.Internal, "target field mask is nil") 1383 } 1384 fieldMask.Paths = make([]PlanAssignmentRequestRequestTypeExtend_FieldPath, 0, len(protoFieldMask.Paths)) 1385 for _, strPath := range protoFieldMask.Paths { 1386 path, err := ParsePlanAssignmentRequestRequestTypeExtend_FieldPath(strPath) 1387 if err != nil { 1388 return err 1389 } 1390 fieldMask.Paths = append(fieldMask.Paths, path) 1391 } 1392 return nil 1393 } 1394 1395 // implement methods required by customType 1396 func (fieldMask PlanAssignmentRequest_RequestType_Extend_FieldMask) Marshal() ([]byte, error) { 1397 protoFieldMask := fieldMask.ToProtoFieldMask() 1398 return proto.Marshal(protoFieldMask) 1399 } 1400 1401 func (fieldMask *PlanAssignmentRequest_RequestType_Extend_FieldMask) Unmarshal(data []byte) error { 1402 protoFieldMask := &googlefieldmaskpb.FieldMask{} 1403 if err := proto.Unmarshal(data, protoFieldMask); err != nil { 1404 return err 1405 } 1406 if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil { 1407 return err 1408 } 1409 return nil 1410 } 1411 1412 func (fieldMask *PlanAssignmentRequest_RequestType_Extend_FieldMask) Size() int { 1413 return proto.Size(fieldMask.ToProtoFieldMask()) 1414 } 1415 1416 func (fieldMask PlanAssignmentRequest_RequestType_Extend_FieldMask) MarshalJSON() ([]byte, error) { 1417 return json.Marshal(fieldMask.ToProtoFieldMask()) 1418 } 1419 1420 func (fieldMask *PlanAssignmentRequest_RequestType_Extend_FieldMask) UnmarshalJSON(data []byte) error { 1421 protoFieldMask := &googlefieldmaskpb.FieldMask{} 1422 if err := json.Unmarshal(data, protoFieldMask); err != nil { 1423 return err 1424 } 1425 if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil { 1426 return err 1427 } 1428 return nil 1429 } 1430 1431 func (fieldMask *PlanAssignmentRequest_RequestType_Extend_FieldMask) AppendPath(path PlanAssignmentRequestRequestTypeExtend_FieldPath) { 1432 fieldMask.Paths = append(fieldMask.Paths, path) 1433 } 1434 1435 func (fieldMask *PlanAssignmentRequest_RequestType_Extend_FieldMask) AppendRawPath(path gotenobject.FieldPath) { 1436 fieldMask.Paths = append(fieldMask.Paths, path.(PlanAssignmentRequestRequestTypeExtend_FieldPath)) 1437 } 1438 1439 func (fieldMask *PlanAssignmentRequest_RequestType_Extend_FieldMask) GetPaths() []PlanAssignmentRequestRequestTypeExtend_FieldPath { 1440 if fieldMask == nil { 1441 return nil 1442 } 1443 return fieldMask.Paths 1444 } 1445 1446 func (fieldMask *PlanAssignmentRequest_RequestType_Extend_FieldMask) GetRawPaths() []gotenobject.FieldPath { 1447 if fieldMask == nil { 1448 return nil 1449 } 1450 rawPaths := make([]gotenobject.FieldPath, 0, len(fieldMask.Paths)) 1451 for _, path := range fieldMask.Paths { 1452 rawPaths = append(rawPaths, path) 1453 } 1454 return rawPaths 1455 } 1456 1457 func (fieldMask *PlanAssignmentRequest_RequestType_Extend_FieldMask) SetFromCliFlag(raw string) error { 1458 path, err := ParsePlanAssignmentRequestRequestTypeExtend_FieldPath(raw) 1459 if err != nil { 1460 return err 1461 } 1462 fieldMask.Paths = append(fieldMask.Paths, path) 1463 return nil 1464 } 1465 1466 func (fieldMask *PlanAssignmentRequest_RequestType_Extend_FieldMask) Set(target, source *PlanAssignmentRequest_RequestType_Extend) { 1467 for _, path := range fieldMask.Paths { 1468 val, _ := path.GetSingle(source) 1469 // if val is nil, then field does not exist in source, skip 1470 // otherwise, process (can still reflect.ValueOf(val).IsNil!) 1471 if val != nil { 1472 path.WithIValue(val).SetTo(&target) 1473 } 1474 } 1475 } 1476 1477 func (fieldMask *PlanAssignmentRequest_RequestType_Extend_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) { 1478 fieldMask.Set(target.(*PlanAssignmentRequest_RequestType_Extend), source.(*PlanAssignmentRequest_RequestType_Extend)) 1479 } 1480 1481 func (fieldMask *PlanAssignmentRequest_RequestType_Extend_FieldMask) Project(source *PlanAssignmentRequest_RequestType_Extend) *PlanAssignmentRequest_RequestType_Extend { 1482 if source == nil { 1483 return nil 1484 } 1485 if fieldMask == nil { 1486 return source 1487 } 1488 result := &PlanAssignmentRequest_RequestType_Extend{} 1489 additionsMask := &common.Allowance_FieldMask{} 1490 wholeAdditionsAccepted := false 1491 regionalDistributionsMask := &common.RegionalDistribution_FieldMask{} 1492 wholeRegionalDistributionsAccepted := false 1493 1494 for _, p := range fieldMask.Paths { 1495 switch tp := p.(type) { 1496 case *PlanAssignmentRequestRequestTypeExtend_FieldTerminalPath: 1497 switch tp.selector { 1498 case PlanAssignmentRequestRequestTypeExtend_FieldPathSelectorAssignment: 1499 result.Assignment = source.Assignment 1500 case PlanAssignmentRequestRequestTypeExtend_FieldPathSelectorAdditions: 1501 result.Additions = source.Additions 1502 wholeAdditionsAccepted = true 1503 case PlanAssignmentRequestRequestTypeExtend_FieldPathSelectorRegionalDistributions: 1504 result.RegionalDistributions = source.RegionalDistributions 1505 wholeRegionalDistributionsAccepted = true 1506 } 1507 case *PlanAssignmentRequestRequestTypeExtend_FieldSubPath: 1508 switch tp.selector { 1509 case PlanAssignmentRequestRequestTypeExtend_FieldPathSelectorAdditions: 1510 additionsMask.AppendPath(tp.subPath.(common.Allowance_FieldPath)) 1511 case PlanAssignmentRequestRequestTypeExtend_FieldPathSelectorRegionalDistributions: 1512 regionalDistributionsMask.AppendPath(tp.subPath.(common.RegionalDistribution_FieldPath)) 1513 } 1514 } 1515 } 1516 if wholeAdditionsAccepted == false && len(additionsMask.Paths) > 0 { 1517 for _, sourceItem := range source.GetAdditions() { 1518 result.Additions = append(result.Additions, additionsMask.Project(sourceItem)) 1519 } 1520 } 1521 if wholeRegionalDistributionsAccepted == false && len(regionalDistributionsMask.Paths) > 0 { 1522 for _, sourceItem := range source.GetRegionalDistributions() { 1523 result.RegionalDistributions = append(result.RegionalDistributions, regionalDistributionsMask.Project(sourceItem)) 1524 } 1525 } 1526 return result 1527 } 1528 1529 func (fieldMask *PlanAssignmentRequest_RequestType_Extend_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt { 1530 return fieldMask.Project(source.(*PlanAssignmentRequest_RequestType_Extend)) 1531 } 1532 1533 func (fieldMask *PlanAssignmentRequest_RequestType_Extend_FieldMask) PathsCount() int { 1534 if fieldMask == nil { 1535 return 0 1536 } 1537 return len(fieldMask.Paths) 1538 } 1539 1540 type PlanAssignmentRequest_RequestType_Redistribute_FieldMask struct { 1541 Paths []PlanAssignmentRequestRequestTypeRedistribute_FieldPath 1542 } 1543 1544 func FullPlanAssignmentRequest_RequestType_Redistribute_FieldMask() *PlanAssignmentRequest_RequestType_Redistribute_FieldMask { 1545 res := &PlanAssignmentRequest_RequestType_Redistribute_FieldMask{} 1546 res.Paths = append(res.Paths, &PlanAssignmentRequestRequestTypeRedistribute_FieldTerminalPath{selector: PlanAssignmentRequestRequestTypeRedistribute_FieldPathSelectorAssignment}) 1547 res.Paths = append(res.Paths, &PlanAssignmentRequestRequestTypeRedistribute_FieldTerminalPath{selector: PlanAssignmentRequestRequestTypeRedistribute_FieldPathSelectorRegionalDistributions}) 1548 return res 1549 } 1550 1551 func (fieldMask *PlanAssignmentRequest_RequestType_Redistribute_FieldMask) String() string { 1552 if fieldMask == nil { 1553 return "<nil>" 1554 } 1555 pathsStr := make([]string, 0, len(fieldMask.Paths)) 1556 for _, path := range fieldMask.Paths { 1557 pathsStr = append(pathsStr, path.String()) 1558 } 1559 return strings.Join(pathsStr, ", ") 1560 } 1561 1562 func (fieldMask *PlanAssignmentRequest_RequestType_Redistribute_FieldMask) IsFull() bool { 1563 if fieldMask == nil { 1564 return false 1565 } 1566 presentSelectors := make([]bool, 2) 1567 for _, path := range fieldMask.Paths { 1568 if asFinal, ok := path.(*PlanAssignmentRequestRequestTypeRedistribute_FieldTerminalPath); ok { 1569 presentSelectors[int(asFinal.selector)] = true 1570 } 1571 } 1572 for _, flag := range presentSelectors { 1573 if !flag { 1574 return false 1575 } 1576 } 1577 return true 1578 } 1579 1580 func (fieldMask *PlanAssignmentRequest_RequestType_Redistribute_FieldMask) ProtoReflect() preflect.Message { 1581 return gotenobject.MakeFieldMaskReflection(fieldMask, func(raw string) (gotenobject.FieldPath, error) { 1582 return ParsePlanAssignmentRequestRequestTypeRedistribute_FieldPath(raw) 1583 }) 1584 } 1585 1586 func (fieldMask *PlanAssignmentRequest_RequestType_Redistribute_FieldMask) ProtoMessage() {} 1587 1588 func (fieldMask *PlanAssignmentRequest_RequestType_Redistribute_FieldMask) Reset() { 1589 if fieldMask != nil { 1590 fieldMask.Paths = nil 1591 } 1592 } 1593 1594 func (fieldMask *PlanAssignmentRequest_RequestType_Redistribute_FieldMask) Subtract(other *PlanAssignmentRequest_RequestType_Redistribute_FieldMask) *PlanAssignmentRequest_RequestType_Redistribute_FieldMask { 1595 result := &PlanAssignmentRequest_RequestType_Redistribute_FieldMask{} 1596 removedSelectors := make([]bool, 2) 1597 otherSubMasks := map[PlanAssignmentRequestRequestTypeRedistribute_FieldPathSelector]gotenobject.FieldMask{ 1598 PlanAssignmentRequestRequestTypeRedistribute_FieldPathSelectorRegionalDistributions: &common.RegionalDistribution_FieldMask{}, 1599 } 1600 mySubMasks := map[PlanAssignmentRequestRequestTypeRedistribute_FieldPathSelector]gotenobject.FieldMask{ 1601 PlanAssignmentRequestRequestTypeRedistribute_FieldPathSelectorRegionalDistributions: &common.RegionalDistribution_FieldMask{}, 1602 } 1603 1604 for _, path := range other.GetPaths() { 1605 switch tp := path.(type) { 1606 case *PlanAssignmentRequestRequestTypeRedistribute_FieldTerminalPath: 1607 removedSelectors[int(tp.selector)] = true 1608 case *PlanAssignmentRequestRequestTypeRedistribute_FieldSubPath: 1609 otherSubMasks[tp.selector].AppendRawPath(tp.subPath) 1610 } 1611 } 1612 for _, path := range fieldMask.GetPaths() { 1613 if !removedSelectors[int(path.Selector())] { 1614 if otherSubMask := otherSubMasks[path.Selector()]; otherSubMask != nil && otherSubMask.PathsCount() > 0 { 1615 if tp, ok := path.(*PlanAssignmentRequestRequestTypeRedistribute_FieldTerminalPath); ok { 1616 switch tp.selector { 1617 case PlanAssignmentRequestRequestTypeRedistribute_FieldPathSelectorRegionalDistributions: 1618 mySubMasks[PlanAssignmentRequestRequestTypeRedistribute_FieldPathSelectorRegionalDistributions] = common.FullRegionalDistribution_FieldMask() 1619 } 1620 } else if tp, ok := path.(*PlanAssignmentRequestRequestTypeRedistribute_FieldSubPath); ok { 1621 mySubMasks[tp.selector].AppendRawPath(tp.subPath) 1622 } 1623 } else { 1624 result.Paths = append(result.Paths, path) 1625 } 1626 } 1627 } 1628 for selector, mySubMask := range mySubMasks { 1629 if mySubMask.PathsCount() > 0 { 1630 for _, allowedPath := range mySubMask.SubtractRaw(otherSubMasks[selector]).GetRawPaths() { 1631 result.Paths = append(result.Paths, &PlanAssignmentRequestRequestTypeRedistribute_FieldSubPath{selector: selector, subPath: allowedPath}) 1632 } 1633 } 1634 } 1635 1636 if len(result.Paths) == 0 { 1637 return nil 1638 } 1639 return result 1640 } 1641 1642 func (fieldMask *PlanAssignmentRequest_RequestType_Redistribute_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask { 1643 return fieldMask.Subtract(other.(*PlanAssignmentRequest_RequestType_Redistribute_FieldMask)) 1644 } 1645 1646 // FilterInputFields generates copy of field paths with output_only field paths removed 1647 func (fieldMask *PlanAssignmentRequest_RequestType_Redistribute_FieldMask) FilterInputFields() *PlanAssignmentRequest_RequestType_Redistribute_FieldMask { 1648 result := &PlanAssignmentRequest_RequestType_Redistribute_FieldMask{} 1649 result.Paths = append(result.Paths, fieldMask.Paths...) 1650 return result 1651 } 1652 1653 // ToFieldMask is used for proto conversions 1654 func (fieldMask *PlanAssignmentRequest_RequestType_Redistribute_FieldMask) ToProtoFieldMask() *googlefieldmaskpb.FieldMask { 1655 protoFieldMask := &googlefieldmaskpb.FieldMask{} 1656 for _, path := range fieldMask.Paths { 1657 protoFieldMask.Paths = append(protoFieldMask.Paths, path.String()) 1658 } 1659 return protoFieldMask 1660 } 1661 1662 func (fieldMask *PlanAssignmentRequest_RequestType_Redistribute_FieldMask) FromProtoFieldMask(protoFieldMask *googlefieldmaskpb.FieldMask) error { 1663 if fieldMask == nil { 1664 return status.Error(codes.Internal, "target field mask is nil") 1665 } 1666 fieldMask.Paths = make([]PlanAssignmentRequestRequestTypeRedistribute_FieldPath, 0, len(protoFieldMask.Paths)) 1667 for _, strPath := range protoFieldMask.Paths { 1668 path, err := ParsePlanAssignmentRequestRequestTypeRedistribute_FieldPath(strPath) 1669 if err != nil { 1670 return err 1671 } 1672 fieldMask.Paths = append(fieldMask.Paths, path) 1673 } 1674 return nil 1675 } 1676 1677 // implement methods required by customType 1678 func (fieldMask PlanAssignmentRequest_RequestType_Redistribute_FieldMask) Marshal() ([]byte, error) { 1679 protoFieldMask := fieldMask.ToProtoFieldMask() 1680 return proto.Marshal(protoFieldMask) 1681 } 1682 1683 func (fieldMask *PlanAssignmentRequest_RequestType_Redistribute_FieldMask) Unmarshal(data []byte) error { 1684 protoFieldMask := &googlefieldmaskpb.FieldMask{} 1685 if err := proto.Unmarshal(data, protoFieldMask); err != nil { 1686 return err 1687 } 1688 if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil { 1689 return err 1690 } 1691 return nil 1692 } 1693 1694 func (fieldMask *PlanAssignmentRequest_RequestType_Redistribute_FieldMask) Size() int { 1695 return proto.Size(fieldMask.ToProtoFieldMask()) 1696 } 1697 1698 func (fieldMask PlanAssignmentRequest_RequestType_Redistribute_FieldMask) MarshalJSON() ([]byte, error) { 1699 return json.Marshal(fieldMask.ToProtoFieldMask()) 1700 } 1701 1702 func (fieldMask *PlanAssignmentRequest_RequestType_Redistribute_FieldMask) UnmarshalJSON(data []byte) error { 1703 protoFieldMask := &googlefieldmaskpb.FieldMask{} 1704 if err := json.Unmarshal(data, protoFieldMask); err != nil { 1705 return err 1706 } 1707 if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil { 1708 return err 1709 } 1710 return nil 1711 } 1712 1713 func (fieldMask *PlanAssignmentRequest_RequestType_Redistribute_FieldMask) AppendPath(path PlanAssignmentRequestRequestTypeRedistribute_FieldPath) { 1714 fieldMask.Paths = append(fieldMask.Paths, path) 1715 } 1716 1717 func (fieldMask *PlanAssignmentRequest_RequestType_Redistribute_FieldMask) AppendRawPath(path gotenobject.FieldPath) { 1718 fieldMask.Paths = append(fieldMask.Paths, path.(PlanAssignmentRequestRequestTypeRedistribute_FieldPath)) 1719 } 1720 1721 func (fieldMask *PlanAssignmentRequest_RequestType_Redistribute_FieldMask) GetPaths() []PlanAssignmentRequestRequestTypeRedistribute_FieldPath { 1722 if fieldMask == nil { 1723 return nil 1724 } 1725 return fieldMask.Paths 1726 } 1727 1728 func (fieldMask *PlanAssignmentRequest_RequestType_Redistribute_FieldMask) GetRawPaths() []gotenobject.FieldPath { 1729 if fieldMask == nil { 1730 return nil 1731 } 1732 rawPaths := make([]gotenobject.FieldPath, 0, len(fieldMask.Paths)) 1733 for _, path := range fieldMask.Paths { 1734 rawPaths = append(rawPaths, path) 1735 } 1736 return rawPaths 1737 } 1738 1739 func (fieldMask *PlanAssignmentRequest_RequestType_Redistribute_FieldMask) SetFromCliFlag(raw string) error { 1740 path, err := ParsePlanAssignmentRequestRequestTypeRedistribute_FieldPath(raw) 1741 if err != nil { 1742 return err 1743 } 1744 fieldMask.Paths = append(fieldMask.Paths, path) 1745 return nil 1746 } 1747 1748 func (fieldMask *PlanAssignmentRequest_RequestType_Redistribute_FieldMask) Set(target, source *PlanAssignmentRequest_RequestType_Redistribute) { 1749 for _, path := range fieldMask.Paths { 1750 val, _ := path.GetSingle(source) 1751 // if val is nil, then field does not exist in source, skip 1752 // otherwise, process (can still reflect.ValueOf(val).IsNil!) 1753 if val != nil { 1754 path.WithIValue(val).SetTo(&target) 1755 } 1756 } 1757 } 1758 1759 func (fieldMask *PlanAssignmentRequest_RequestType_Redistribute_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) { 1760 fieldMask.Set(target.(*PlanAssignmentRequest_RequestType_Redistribute), source.(*PlanAssignmentRequest_RequestType_Redistribute)) 1761 } 1762 1763 func (fieldMask *PlanAssignmentRequest_RequestType_Redistribute_FieldMask) Project(source *PlanAssignmentRequest_RequestType_Redistribute) *PlanAssignmentRequest_RequestType_Redistribute { 1764 if source == nil { 1765 return nil 1766 } 1767 if fieldMask == nil { 1768 return source 1769 } 1770 result := &PlanAssignmentRequest_RequestType_Redistribute{} 1771 regionalDistributionsMask := &common.RegionalDistribution_FieldMask{} 1772 wholeRegionalDistributionsAccepted := false 1773 1774 for _, p := range fieldMask.Paths { 1775 switch tp := p.(type) { 1776 case *PlanAssignmentRequestRequestTypeRedistribute_FieldTerminalPath: 1777 switch tp.selector { 1778 case PlanAssignmentRequestRequestTypeRedistribute_FieldPathSelectorAssignment: 1779 result.Assignment = source.Assignment 1780 case PlanAssignmentRequestRequestTypeRedistribute_FieldPathSelectorRegionalDistributions: 1781 result.RegionalDistributions = source.RegionalDistributions 1782 wholeRegionalDistributionsAccepted = true 1783 } 1784 case *PlanAssignmentRequestRequestTypeRedistribute_FieldSubPath: 1785 switch tp.selector { 1786 case PlanAssignmentRequestRequestTypeRedistribute_FieldPathSelectorRegionalDistributions: 1787 regionalDistributionsMask.AppendPath(tp.subPath.(common.RegionalDistribution_FieldPath)) 1788 } 1789 } 1790 } 1791 if wholeRegionalDistributionsAccepted == false && len(regionalDistributionsMask.Paths) > 0 { 1792 for _, sourceItem := range source.GetRegionalDistributions() { 1793 result.RegionalDistributions = append(result.RegionalDistributions, regionalDistributionsMask.Project(sourceItem)) 1794 } 1795 } 1796 return result 1797 } 1798 1799 func (fieldMask *PlanAssignmentRequest_RequestType_Redistribute_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt { 1800 return fieldMask.Project(source.(*PlanAssignmentRequest_RequestType_Redistribute)) 1801 } 1802 1803 func (fieldMask *PlanAssignmentRequest_RequestType_Redistribute_FieldMask) PathsCount() int { 1804 if fieldMask == nil { 1805 return 0 1806 } 1807 return len(fieldMask.Paths) 1808 } 1809 1810 type PlanAssignmentRequest_RequestType_Unassign_FieldMask struct { 1811 Paths []PlanAssignmentRequestRequestTypeUnassign_FieldPath 1812 } 1813 1814 func FullPlanAssignmentRequest_RequestType_Unassign_FieldMask() *PlanAssignmentRequest_RequestType_Unassign_FieldMask { 1815 res := &PlanAssignmentRequest_RequestType_Unassign_FieldMask{} 1816 res.Paths = append(res.Paths, &PlanAssignmentRequestRequestTypeUnassign_FieldTerminalPath{selector: PlanAssignmentRequestRequestTypeUnassign_FieldPathSelectorAssignment}) 1817 return res 1818 } 1819 1820 func (fieldMask *PlanAssignmentRequest_RequestType_Unassign_FieldMask) String() string { 1821 if fieldMask == nil { 1822 return "<nil>" 1823 } 1824 pathsStr := make([]string, 0, len(fieldMask.Paths)) 1825 for _, path := range fieldMask.Paths { 1826 pathsStr = append(pathsStr, path.String()) 1827 } 1828 return strings.Join(pathsStr, ", ") 1829 } 1830 1831 func (fieldMask *PlanAssignmentRequest_RequestType_Unassign_FieldMask) IsFull() bool { 1832 if fieldMask == nil { 1833 return false 1834 } 1835 presentSelectors := make([]bool, 1) 1836 for _, path := range fieldMask.Paths { 1837 if asFinal, ok := path.(*PlanAssignmentRequestRequestTypeUnassign_FieldTerminalPath); ok { 1838 presentSelectors[int(asFinal.selector)] = true 1839 } 1840 } 1841 for _, flag := range presentSelectors { 1842 if !flag { 1843 return false 1844 } 1845 } 1846 return true 1847 } 1848 1849 func (fieldMask *PlanAssignmentRequest_RequestType_Unassign_FieldMask) ProtoReflect() preflect.Message { 1850 return gotenobject.MakeFieldMaskReflection(fieldMask, func(raw string) (gotenobject.FieldPath, error) { 1851 return ParsePlanAssignmentRequestRequestTypeUnassign_FieldPath(raw) 1852 }) 1853 } 1854 1855 func (fieldMask *PlanAssignmentRequest_RequestType_Unassign_FieldMask) ProtoMessage() {} 1856 1857 func (fieldMask *PlanAssignmentRequest_RequestType_Unassign_FieldMask) Reset() { 1858 if fieldMask != nil { 1859 fieldMask.Paths = nil 1860 } 1861 } 1862 1863 func (fieldMask *PlanAssignmentRequest_RequestType_Unassign_FieldMask) Subtract(other *PlanAssignmentRequest_RequestType_Unassign_FieldMask) *PlanAssignmentRequest_RequestType_Unassign_FieldMask { 1864 result := &PlanAssignmentRequest_RequestType_Unassign_FieldMask{} 1865 removedSelectors := make([]bool, 1) 1866 1867 for _, path := range other.GetPaths() { 1868 switch tp := path.(type) { 1869 case *PlanAssignmentRequestRequestTypeUnassign_FieldTerminalPath: 1870 removedSelectors[int(tp.selector)] = true 1871 } 1872 } 1873 for _, path := range fieldMask.GetPaths() { 1874 if !removedSelectors[int(path.Selector())] { 1875 result.Paths = append(result.Paths, path) 1876 } 1877 } 1878 1879 if len(result.Paths) == 0 { 1880 return nil 1881 } 1882 return result 1883 } 1884 1885 func (fieldMask *PlanAssignmentRequest_RequestType_Unassign_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask { 1886 return fieldMask.Subtract(other.(*PlanAssignmentRequest_RequestType_Unassign_FieldMask)) 1887 } 1888 1889 // FilterInputFields generates copy of field paths with output_only field paths removed 1890 func (fieldMask *PlanAssignmentRequest_RequestType_Unassign_FieldMask) FilterInputFields() *PlanAssignmentRequest_RequestType_Unassign_FieldMask { 1891 result := &PlanAssignmentRequest_RequestType_Unassign_FieldMask{} 1892 result.Paths = append(result.Paths, fieldMask.Paths...) 1893 return result 1894 } 1895 1896 // ToFieldMask is used for proto conversions 1897 func (fieldMask *PlanAssignmentRequest_RequestType_Unassign_FieldMask) ToProtoFieldMask() *googlefieldmaskpb.FieldMask { 1898 protoFieldMask := &googlefieldmaskpb.FieldMask{} 1899 for _, path := range fieldMask.Paths { 1900 protoFieldMask.Paths = append(protoFieldMask.Paths, path.String()) 1901 } 1902 return protoFieldMask 1903 } 1904 1905 func (fieldMask *PlanAssignmentRequest_RequestType_Unassign_FieldMask) FromProtoFieldMask(protoFieldMask *googlefieldmaskpb.FieldMask) error { 1906 if fieldMask == nil { 1907 return status.Error(codes.Internal, "target field mask is nil") 1908 } 1909 fieldMask.Paths = make([]PlanAssignmentRequestRequestTypeUnassign_FieldPath, 0, len(protoFieldMask.Paths)) 1910 for _, strPath := range protoFieldMask.Paths { 1911 path, err := ParsePlanAssignmentRequestRequestTypeUnassign_FieldPath(strPath) 1912 if err != nil { 1913 return err 1914 } 1915 fieldMask.Paths = append(fieldMask.Paths, path) 1916 } 1917 return nil 1918 } 1919 1920 // implement methods required by customType 1921 func (fieldMask PlanAssignmentRequest_RequestType_Unassign_FieldMask) Marshal() ([]byte, error) { 1922 protoFieldMask := fieldMask.ToProtoFieldMask() 1923 return proto.Marshal(protoFieldMask) 1924 } 1925 1926 func (fieldMask *PlanAssignmentRequest_RequestType_Unassign_FieldMask) Unmarshal(data []byte) error { 1927 protoFieldMask := &googlefieldmaskpb.FieldMask{} 1928 if err := proto.Unmarshal(data, protoFieldMask); err != nil { 1929 return err 1930 } 1931 if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil { 1932 return err 1933 } 1934 return nil 1935 } 1936 1937 func (fieldMask *PlanAssignmentRequest_RequestType_Unassign_FieldMask) Size() int { 1938 return proto.Size(fieldMask.ToProtoFieldMask()) 1939 } 1940 1941 func (fieldMask PlanAssignmentRequest_RequestType_Unassign_FieldMask) MarshalJSON() ([]byte, error) { 1942 return json.Marshal(fieldMask.ToProtoFieldMask()) 1943 } 1944 1945 func (fieldMask *PlanAssignmentRequest_RequestType_Unassign_FieldMask) UnmarshalJSON(data []byte) error { 1946 protoFieldMask := &googlefieldmaskpb.FieldMask{} 1947 if err := json.Unmarshal(data, protoFieldMask); err != nil { 1948 return err 1949 } 1950 if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil { 1951 return err 1952 } 1953 return nil 1954 } 1955 1956 func (fieldMask *PlanAssignmentRequest_RequestType_Unassign_FieldMask) AppendPath(path PlanAssignmentRequestRequestTypeUnassign_FieldPath) { 1957 fieldMask.Paths = append(fieldMask.Paths, path) 1958 } 1959 1960 func (fieldMask *PlanAssignmentRequest_RequestType_Unassign_FieldMask) AppendRawPath(path gotenobject.FieldPath) { 1961 fieldMask.Paths = append(fieldMask.Paths, path.(PlanAssignmentRequestRequestTypeUnassign_FieldPath)) 1962 } 1963 1964 func (fieldMask *PlanAssignmentRequest_RequestType_Unassign_FieldMask) GetPaths() []PlanAssignmentRequestRequestTypeUnassign_FieldPath { 1965 if fieldMask == nil { 1966 return nil 1967 } 1968 return fieldMask.Paths 1969 } 1970 1971 func (fieldMask *PlanAssignmentRequest_RequestType_Unassign_FieldMask) GetRawPaths() []gotenobject.FieldPath { 1972 if fieldMask == nil { 1973 return nil 1974 } 1975 rawPaths := make([]gotenobject.FieldPath, 0, len(fieldMask.Paths)) 1976 for _, path := range fieldMask.Paths { 1977 rawPaths = append(rawPaths, path) 1978 } 1979 return rawPaths 1980 } 1981 1982 func (fieldMask *PlanAssignmentRequest_RequestType_Unassign_FieldMask) SetFromCliFlag(raw string) error { 1983 path, err := ParsePlanAssignmentRequestRequestTypeUnassign_FieldPath(raw) 1984 if err != nil { 1985 return err 1986 } 1987 fieldMask.Paths = append(fieldMask.Paths, path) 1988 return nil 1989 } 1990 1991 func (fieldMask *PlanAssignmentRequest_RequestType_Unassign_FieldMask) Set(target, source *PlanAssignmentRequest_RequestType_Unassign) { 1992 for _, path := range fieldMask.Paths { 1993 val, _ := path.GetSingle(source) 1994 // if val is nil, then field does not exist in source, skip 1995 // otherwise, process (can still reflect.ValueOf(val).IsNil!) 1996 if val != nil { 1997 path.WithIValue(val).SetTo(&target) 1998 } 1999 } 2000 } 2001 2002 func (fieldMask *PlanAssignmentRequest_RequestType_Unassign_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) { 2003 fieldMask.Set(target.(*PlanAssignmentRequest_RequestType_Unassign), source.(*PlanAssignmentRequest_RequestType_Unassign)) 2004 } 2005 2006 func (fieldMask *PlanAssignmentRequest_RequestType_Unassign_FieldMask) Project(source *PlanAssignmentRequest_RequestType_Unassign) *PlanAssignmentRequest_RequestType_Unassign { 2007 if source == nil { 2008 return nil 2009 } 2010 if fieldMask == nil { 2011 return source 2012 } 2013 result := &PlanAssignmentRequest_RequestType_Unassign{} 2014 2015 for _, p := range fieldMask.Paths { 2016 switch tp := p.(type) { 2017 case *PlanAssignmentRequestRequestTypeUnassign_FieldTerminalPath: 2018 switch tp.selector { 2019 case PlanAssignmentRequestRequestTypeUnassign_FieldPathSelectorAssignment: 2020 result.Assignment = source.Assignment 2021 } 2022 } 2023 } 2024 return result 2025 } 2026 2027 func (fieldMask *PlanAssignmentRequest_RequestType_Unassign_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt { 2028 return fieldMask.Project(source.(*PlanAssignmentRequest_RequestType_Unassign)) 2029 } 2030 2031 func (fieldMask *PlanAssignmentRequest_RequestType_Unassign_FieldMask) PathsCount() int { 2032 if fieldMask == nil { 2033 return 0 2034 } 2035 return len(fieldMask.Paths) 2036 }