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  }