github.com/cloudwan/edgelq-sdk@v1.15.4/monitoring/resources/v4/bucket/bucket.pb.fieldmask.go (about)

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