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

     1  // Code generated by protoc-gen-goten-object
     2  // File: edgelq/monitoring/proto/v4/time_serie.proto
     3  // DO NOT EDIT!!!
     4  
     5  package time_serie
     6  
     7  import (
     8  	"encoding/json"
     9  	"strings"
    10  
    11  	"google.golang.org/grpc/codes"
    12  	"google.golang.org/grpc/status"
    13  	"google.golang.org/protobuf/proto"
    14  	preflect "google.golang.org/protobuf/reflect/protoreflect"
    15  	googlefieldmaskpb "google.golang.org/protobuf/types/known/fieldmaskpb"
    16  
    17  	gotenobject "github.com/cloudwan/goten-sdk/runtime/object"
    18  )
    19  
    20  // proto imports
    21  import (
    22  	common "github.com/cloudwan/edgelq-sdk/monitoring/resources/v4/common"
    23  	metric_descriptor "github.com/cloudwan/edgelq-sdk/monitoring/resources/v4/metric_descriptor"
    24  )
    25  
    26  // ensure the imports are used
    27  var (
    28  	_ = new(json.Marshaler)
    29  	_ = strings.Builder{}
    30  
    31  	_ = codes.NotFound
    32  	_ = status.Status{}
    33  	_ = new(proto.Message)
    34  	_ = new(preflect.Message)
    35  	_ = googlefieldmaskpb.FieldMask{}
    36  
    37  	_ = new(gotenobject.FieldMask)
    38  )
    39  
    40  // make sure we're using proto imports
    41  var (
    42  	_ = &common.LabelDescriptor{}
    43  	_ = &metric_descriptor.MetricDescriptor{}
    44  )
    45  
    46  type Point_FieldMask struct {
    47  	Paths []Point_FieldPath
    48  }
    49  
    50  func FullPoint_FieldMask() *Point_FieldMask {
    51  	res := &Point_FieldMask{}
    52  	res.Paths = append(res.Paths, &Point_FieldTerminalPath{selector: Point_FieldPathSelectorInterval})
    53  	res.Paths = append(res.Paths, &Point_FieldTerminalPath{selector: Point_FieldPathSelectorValue})
    54  	res.Paths = append(res.Paths, &Point_FieldTerminalPath{selector: Point_FieldPathSelectorAggregation})
    55  	return res
    56  }
    57  
    58  func (fieldMask *Point_FieldMask) String() string {
    59  	if fieldMask == nil {
    60  		return "<nil>"
    61  	}
    62  	pathsStr := make([]string, 0, len(fieldMask.Paths))
    63  	for _, path := range fieldMask.Paths {
    64  		pathsStr = append(pathsStr, path.String())
    65  	}
    66  	return strings.Join(pathsStr, ", ")
    67  }
    68  
    69  func (fieldMask *Point_FieldMask) IsFull() bool {
    70  	if fieldMask == nil {
    71  		return false
    72  	}
    73  	presentSelectors := make([]bool, 3)
    74  	for _, path := range fieldMask.Paths {
    75  		if asFinal, ok := path.(*Point_FieldTerminalPath); ok {
    76  			presentSelectors[int(asFinal.selector)] = true
    77  		}
    78  	}
    79  	for _, flag := range presentSelectors {
    80  		if !flag {
    81  			return false
    82  		}
    83  	}
    84  	return true
    85  }
    86  
    87  func (fieldMask *Point_FieldMask) ProtoReflect() preflect.Message {
    88  	return gotenobject.MakeFieldMaskReflection(fieldMask, func(raw string) (gotenobject.FieldPath, error) {
    89  		return ParsePoint_FieldPath(raw)
    90  	})
    91  }
    92  
    93  func (fieldMask *Point_FieldMask) ProtoMessage() {}
    94  
    95  func (fieldMask *Point_FieldMask) Reset() {
    96  	if fieldMask != nil {
    97  		fieldMask.Paths = nil
    98  	}
    99  }
   100  
   101  func (fieldMask *Point_FieldMask) Subtract(other *Point_FieldMask) *Point_FieldMask {
   102  	result := &Point_FieldMask{}
   103  	removedSelectors := make([]bool, 3)
   104  	otherSubMasks := map[Point_FieldPathSelector]gotenobject.FieldMask{
   105  		Point_FieldPathSelectorInterval:    &common.TimeInterval_FieldMask{},
   106  		Point_FieldPathSelectorValue:       &common.TypedValue_FieldMask{},
   107  		Point_FieldPathSelectorAggregation: &common.Aggregation_FieldMask{},
   108  	}
   109  	mySubMasks := map[Point_FieldPathSelector]gotenobject.FieldMask{
   110  		Point_FieldPathSelectorInterval:    &common.TimeInterval_FieldMask{},
   111  		Point_FieldPathSelectorValue:       &common.TypedValue_FieldMask{},
   112  		Point_FieldPathSelectorAggregation: &common.Aggregation_FieldMask{},
   113  	}
   114  
   115  	for _, path := range other.GetPaths() {
   116  		switch tp := path.(type) {
   117  		case *Point_FieldTerminalPath:
   118  			removedSelectors[int(tp.selector)] = true
   119  		case *Point_FieldSubPath:
   120  			otherSubMasks[tp.selector].AppendRawPath(tp.subPath)
   121  		}
   122  	}
   123  	for _, path := range fieldMask.GetPaths() {
   124  		if !removedSelectors[int(path.Selector())] {
   125  			if otherSubMask := otherSubMasks[path.Selector()]; otherSubMask != nil && otherSubMask.PathsCount() > 0 {
   126  				if tp, ok := path.(*Point_FieldTerminalPath); ok {
   127  					switch tp.selector {
   128  					case Point_FieldPathSelectorInterval:
   129  						mySubMasks[Point_FieldPathSelectorInterval] = common.FullTimeInterval_FieldMask()
   130  					case Point_FieldPathSelectorValue:
   131  						mySubMasks[Point_FieldPathSelectorValue] = common.FullTypedValue_FieldMask()
   132  					case Point_FieldPathSelectorAggregation:
   133  						mySubMasks[Point_FieldPathSelectorAggregation] = common.FullAggregation_FieldMask()
   134  					}
   135  				} else if tp, ok := path.(*Point_FieldSubPath); ok {
   136  					mySubMasks[tp.selector].AppendRawPath(tp.subPath)
   137  				}
   138  			} else {
   139  				result.Paths = append(result.Paths, path)
   140  			}
   141  		}
   142  	}
   143  	for selector, mySubMask := range mySubMasks {
   144  		if mySubMask.PathsCount() > 0 {
   145  			for _, allowedPath := range mySubMask.SubtractRaw(otherSubMasks[selector]).GetRawPaths() {
   146  				result.Paths = append(result.Paths, &Point_FieldSubPath{selector: selector, subPath: allowedPath})
   147  			}
   148  		}
   149  	}
   150  
   151  	if len(result.Paths) == 0 {
   152  		return nil
   153  	}
   154  	return result
   155  }
   156  
   157  func (fieldMask *Point_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask {
   158  	return fieldMask.Subtract(other.(*Point_FieldMask))
   159  }
   160  
   161  // FilterInputFields generates copy of field paths with output_only field paths removed
   162  func (fieldMask *Point_FieldMask) FilterInputFields() *Point_FieldMask {
   163  	result := &Point_FieldMask{}
   164  	result.Paths = append(result.Paths, fieldMask.Paths...)
   165  	return result
   166  }
   167  
   168  // ToFieldMask is used for proto conversions
   169  func (fieldMask *Point_FieldMask) ToProtoFieldMask() *googlefieldmaskpb.FieldMask {
   170  	protoFieldMask := &googlefieldmaskpb.FieldMask{}
   171  	for _, path := range fieldMask.Paths {
   172  		protoFieldMask.Paths = append(protoFieldMask.Paths, path.String())
   173  	}
   174  	return protoFieldMask
   175  }
   176  
   177  func (fieldMask *Point_FieldMask) FromProtoFieldMask(protoFieldMask *googlefieldmaskpb.FieldMask) error {
   178  	if fieldMask == nil {
   179  		return status.Error(codes.Internal, "target field mask is nil")
   180  	}
   181  	fieldMask.Paths = make([]Point_FieldPath, 0, len(protoFieldMask.Paths))
   182  	for _, strPath := range protoFieldMask.Paths {
   183  		path, err := ParsePoint_FieldPath(strPath)
   184  		if err != nil {
   185  			return err
   186  		}
   187  		fieldMask.Paths = append(fieldMask.Paths, path)
   188  	}
   189  	return nil
   190  }
   191  
   192  // implement methods required by customType
   193  func (fieldMask Point_FieldMask) Marshal() ([]byte, error) {
   194  	protoFieldMask := fieldMask.ToProtoFieldMask()
   195  	return proto.Marshal(protoFieldMask)
   196  }
   197  
   198  func (fieldMask *Point_FieldMask) Unmarshal(data []byte) error {
   199  	protoFieldMask := &googlefieldmaskpb.FieldMask{}
   200  	if err := proto.Unmarshal(data, protoFieldMask); err != nil {
   201  		return err
   202  	}
   203  	if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil {
   204  		return err
   205  	}
   206  	return nil
   207  }
   208  
   209  func (fieldMask *Point_FieldMask) Size() int {
   210  	return proto.Size(fieldMask.ToProtoFieldMask())
   211  }
   212  
   213  func (fieldMask Point_FieldMask) MarshalJSON() ([]byte, error) {
   214  	return json.Marshal(fieldMask.ToProtoFieldMask())
   215  }
   216  
   217  func (fieldMask *Point_FieldMask) UnmarshalJSON(data []byte) error {
   218  	protoFieldMask := &googlefieldmaskpb.FieldMask{}
   219  	if err := json.Unmarshal(data, protoFieldMask); err != nil {
   220  		return err
   221  	}
   222  	if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil {
   223  		return err
   224  	}
   225  	return nil
   226  }
   227  
   228  func (fieldMask *Point_FieldMask) AppendPath(path Point_FieldPath) {
   229  	fieldMask.Paths = append(fieldMask.Paths, path)
   230  }
   231  
   232  func (fieldMask *Point_FieldMask) AppendRawPath(path gotenobject.FieldPath) {
   233  	fieldMask.Paths = append(fieldMask.Paths, path.(Point_FieldPath))
   234  }
   235  
   236  func (fieldMask *Point_FieldMask) GetPaths() []Point_FieldPath {
   237  	if fieldMask == nil {
   238  		return nil
   239  	}
   240  	return fieldMask.Paths
   241  }
   242  
   243  func (fieldMask *Point_FieldMask) GetRawPaths() []gotenobject.FieldPath {
   244  	if fieldMask == nil {
   245  		return nil
   246  	}
   247  	rawPaths := make([]gotenobject.FieldPath, 0, len(fieldMask.Paths))
   248  	for _, path := range fieldMask.Paths {
   249  		rawPaths = append(rawPaths, path)
   250  	}
   251  	return rawPaths
   252  }
   253  
   254  func (fieldMask *Point_FieldMask) SetFromCliFlag(raw string) error {
   255  	path, err := ParsePoint_FieldPath(raw)
   256  	if err != nil {
   257  		return err
   258  	}
   259  	fieldMask.Paths = append(fieldMask.Paths, path)
   260  	return nil
   261  }
   262  
   263  func (fieldMask *Point_FieldMask) Set(target, source *Point) {
   264  	for _, path := range fieldMask.Paths {
   265  		val, _ := path.GetSingle(source)
   266  		// if val is nil, then field does not exist in source, skip
   267  		// otherwise, process (can still reflect.ValueOf(val).IsNil!)
   268  		if val != nil {
   269  			path.WithIValue(val).SetTo(&target)
   270  		}
   271  	}
   272  }
   273  
   274  func (fieldMask *Point_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) {
   275  	fieldMask.Set(target.(*Point), source.(*Point))
   276  }
   277  
   278  func (fieldMask *Point_FieldMask) Project(source *Point) *Point {
   279  	if source == nil {
   280  		return nil
   281  	}
   282  	if fieldMask == nil {
   283  		return source
   284  	}
   285  	result := &Point{}
   286  	intervalMask := &common.TimeInterval_FieldMask{}
   287  	wholeIntervalAccepted := false
   288  	valueMask := &common.TypedValue_FieldMask{}
   289  	wholeValueAccepted := false
   290  	aggregationMask := &common.Aggregation_FieldMask{}
   291  	wholeAggregationAccepted := false
   292  
   293  	for _, p := range fieldMask.Paths {
   294  		switch tp := p.(type) {
   295  		case *Point_FieldTerminalPath:
   296  			switch tp.selector {
   297  			case Point_FieldPathSelectorInterval:
   298  				result.Interval = source.Interval
   299  				wholeIntervalAccepted = true
   300  			case Point_FieldPathSelectorValue:
   301  				result.Value = source.Value
   302  				wholeValueAccepted = true
   303  			case Point_FieldPathSelectorAggregation:
   304  				result.Aggregation = source.Aggregation
   305  				wholeAggregationAccepted = true
   306  			}
   307  		case *Point_FieldSubPath:
   308  			switch tp.selector {
   309  			case Point_FieldPathSelectorInterval:
   310  				intervalMask.AppendPath(tp.subPath.(common.TimeInterval_FieldPath))
   311  			case Point_FieldPathSelectorValue:
   312  				valueMask.AppendPath(tp.subPath.(common.TypedValue_FieldPath))
   313  			case Point_FieldPathSelectorAggregation:
   314  				aggregationMask.AppendPath(tp.subPath.(common.Aggregation_FieldPath))
   315  			}
   316  		}
   317  	}
   318  	if wholeIntervalAccepted == false && len(intervalMask.Paths) > 0 {
   319  		result.Interval = intervalMask.Project(source.GetInterval())
   320  	}
   321  	if wholeValueAccepted == false && len(valueMask.Paths) > 0 {
   322  		result.Value = valueMask.Project(source.GetValue())
   323  	}
   324  	if wholeAggregationAccepted == false && len(aggregationMask.Paths) > 0 {
   325  		result.Aggregation = aggregationMask.Project(source.GetAggregation())
   326  	}
   327  	return result
   328  }
   329  
   330  func (fieldMask *Point_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
   331  	return fieldMask.Project(source.(*Point))
   332  }
   333  
   334  func (fieldMask *Point_FieldMask) PathsCount() int {
   335  	if fieldMask == nil {
   336  		return 0
   337  	}
   338  	return len(fieldMask.Paths)
   339  }
   340  
   341  type TimeSerie_FieldMask struct {
   342  	Paths []TimeSerie_FieldPath
   343  }
   344  
   345  func FullTimeSerie_FieldMask() *TimeSerie_FieldMask {
   346  	res := &TimeSerie_FieldMask{}
   347  	res.Paths = append(res.Paths, &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorKey})
   348  	res.Paths = append(res.Paths, &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorProject})
   349  	res.Paths = append(res.Paths, &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorRegion})
   350  	res.Paths = append(res.Paths, &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorUnit})
   351  	res.Paths = append(res.Paths, &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorMetric})
   352  	res.Paths = append(res.Paths, &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorResource})
   353  	res.Paths = append(res.Paths, &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorMetricKind})
   354  	res.Paths = append(res.Paths, &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorValueType})
   355  	res.Paths = append(res.Paths, &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorPoints})
   356  	return res
   357  }
   358  
   359  func (fieldMask *TimeSerie_FieldMask) String() string {
   360  	if fieldMask == nil {
   361  		return "<nil>"
   362  	}
   363  	pathsStr := make([]string, 0, len(fieldMask.Paths))
   364  	for _, path := range fieldMask.Paths {
   365  		pathsStr = append(pathsStr, path.String())
   366  	}
   367  	return strings.Join(pathsStr, ", ")
   368  }
   369  
   370  func (fieldMask *TimeSerie_FieldMask) IsFull() bool {
   371  	if fieldMask == nil {
   372  		return false
   373  	}
   374  	presentSelectors := make([]bool, 9)
   375  	for _, path := range fieldMask.Paths {
   376  		if asFinal, ok := path.(*TimeSerie_FieldTerminalPath); ok {
   377  			presentSelectors[int(asFinal.selector)] = true
   378  		}
   379  	}
   380  	for _, flag := range presentSelectors {
   381  		if !flag {
   382  			return false
   383  		}
   384  	}
   385  	return true
   386  }
   387  
   388  func (fieldMask *TimeSerie_FieldMask) ProtoReflect() preflect.Message {
   389  	return gotenobject.MakeFieldMaskReflection(fieldMask, func(raw string) (gotenobject.FieldPath, error) {
   390  		return ParseTimeSerie_FieldPath(raw)
   391  	})
   392  }
   393  
   394  func (fieldMask *TimeSerie_FieldMask) ProtoMessage() {}
   395  
   396  func (fieldMask *TimeSerie_FieldMask) Reset() {
   397  	if fieldMask != nil {
   398  		fieldMask.Paths = nil
   399  	}
   400  }
   401  
   402  func (fieldMask *TimeSerie_FieldMask) Subtract(other *TimeSerie_FieldMask) *TimeSerie_FieldMask {
   403  	result := &TimeSerie_FieldMask{}
   404  	removedSelectors := make([]bool, 9)
   405  	otherSubMasks := map[TimeSerie_FieldPathSelector]gotenobject.FieldMask{
   406  		TimeSerie_FieldPathSelectorMetric:   &common.Metric_FieldMask{},
   407  		TimeSerie_FieldPathSelectorResource: &common.MonitoredResource_FieldMask{},
   408  		TimeSerie_FieldPathSelectorPoints:   &Point_FieldMask{},
   409  	}
   410  	mySubMasks := map[TimeSerie_FieldPathSelector]gotenobject.FieldMask{
   411  		TimeSerie_FieldPathSelectorMetric:   &common.Metric_FieldMask{},
   412  		TimeSerie_FieldPathSelectorResource: &common.MonitoredResource_FieldMask{},
   413  		TimeSerie_FieldPathSelectorPoints:   &Point_FieldMask{},
   414  	}
   415  
   416  	for _, path := range other.GetPaths() {
   417  		switch tp := path.(type) {
   418  		case *TimeSerie_FieldTerminalPath:
   419  			removedSelectors[int(tp.selector)] = true
   420  		case *TimeSerie_FieldSubPath:
   421  			otherSubMasks[tp.selector].AppendRawPath(tp.subPath)
   422  		}
   423  	}
   424  	for _, path := range fieldMask.GetPaths() {
   425  		if !removedSelectors[int(path.Selector())] {
   426  			if otherSubMask := otherSubMasks[path.Selector()]; otherSubMask != nil && otherSubMask.PathsCount() > 0 {
   427  				if tp, ok := path.(*TimeSerie_FieldTerminalPath); ok {
   428  					switch tp.selector {
   429  					case TimeSerie_FieldPathSelectorMetric:
   430  						mySubMasks[TimeSerie_FieldPathSelectorMetric] = common.FullMetric_FieldMask()
   431  					case TimeSerie_FieldPathSelectorResource:
   432  						mySubMasks[TimeSerie_FieldPathSelectorResource] = common.FullMonitoredResource_FieldMask()
   433  					case TimeSerie_FieldPathSelectorPoints:
   434  						mySubMasks[TimeSerie_FieldPathSelectorPoints] = FullPoint_FieldMask()
   435  					}
   436  				} else if tp, ok := path.(*TimeSerie_FieldSubPath); ok {
   437  					mySubMasks[tp.selector].AppendRawPath(tp.subPath)
   438  				}
   439  			} else {
   440  				result.Paths = append(result.Paths, path)
   441  			}
   442  		}
   443  	}
   444  	for selector, mySubMask := range mySubMasks {
   445  		if mySubMask.PathsCount() > 0 {
   446  			for _, allowedPath := range mySubMask.SubtractRaw(otherSubMasks[selector]).GetRawPaths() {
   447  				result.Paths = append(result.Paths, &TimeSerie_FieldSubPath{selector: selector, subPath: allowedPath})
   448  			}
   449  		}
   450  	}
   451  
   452  	if len(result.Paths) == 0 {
   453  		return nil
   454  	}
   455  	return result
   456  }
   457  
   458  func (fieldMask *TimeSerie_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask {
   459  	return fieldMask.Subtract(other.(*TimeSerie_FieldMask))
   460  }
   461  
   462  // FilterInputFields generates copy of field paths with output_only field paths removed
   463  func (fieldMask *TimeSerie_FieldMask) FilterInputFields() *TimeSerie_FieldMask {
   464  	result := &TimeSerie_FieldMask{}
   465  	result.Paths = append(result.Paths, fieldMask.Paths...)
   466  	return result
   467  }
   468  
   469  // ToFieldMask is used for proto conversions
   470  func (fieldMask *TimeSerie_FieldMask) ToProtoFieldMask() *googlefieldmaskpb.FieldMask {
   471  	protoFieldMask := &googlefieldmaskpb.FieldMask{}
   472  	for _, path := range fieldMask.Paths {
   473  		protoFieldMask.Paths = append(protoFieldMask.Paths, path.String())
   474  	}
   475  	return protoFieldMask
   476  }
   477  
   478  func (fieldMask *TimeSerie_FieldMask) FromProtoFieldMask(protoFieldMask *googlefieldmaskpb.FieldMask) error {
   479  	if fieldMask == nil {
   480  		return status.Error(codes.Internal, "target field mask is nil")
   481  	}
   482  	fieldMask.Paths = make([]TimeSerie_FieldPath, 0, len(protoFieldMask.Paths))
   483  	for _, strPath := range protoFieldMask.Paths {
   484  		path, err := ParseTimeSerie_FieldPath(strPath)
   485  		if err != nil {
   486  			return err
   487  		}
   488  		fieldMask.Paths = append(fieldMask.Paths, path)
   489  	}
   490  	return nil
   491  }
   492  
   493  // implement methods required by customType
   494  func (fieldMask TimeSerie_FieldMask) Marshal() ([]byte, error) {
   495  	protoFieldMask := fieldMask.ToProtoFieldMask()
   496  	return proto.Marshal(protoFieldMask)
   497  }
   498  
   499  func (fieldMask *TimeSerie_FieldMask) Unmarshal(data []byte) error {
   500  	protoFieldMask := &googlefieldmaskpb.FieldMask{}
   501  	if err := proto.Unmarshal(data, protoFieldMask); err != nil {
   502  		return err
   503  	}
   504  	if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil {
   505  		return err
   506  	}
   507  	return nil
   508  }
   509  
   510  func (fieldMask *TimeSerie_FieldMask) Size() int {
   511  	return proto.Size(fieldMask.ToProtoFieldMask())
   512  }
   513  
   514  func (fieldMask TimeSerie_FieldMask) MarshalJSON() ([]byte, error) {
   515  	return json.Marshal(fieldMask.ToProtoFieldMask())
   516  }
   517  
   518  func (fieldMask *TimeSerie_FieldMask) UnmarshalJSON(data []byte) error {
   519  	protoFieldMask := &googlefieldmaskpb.FieldMask{}
   520  	if err := json.Unmarshal(data, protoFieldMask); err != nil {
   521  		return err
   522  	}
   523  	if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil {
   524  		return err
   525  	}
   526  	return nil
   527  }
   528  
   529  func (fieldMask *TimeSerie_FieldMask) AppendPath(path TimeSerie_FieldPath) {
   530  	fieldMask.Paths = append(fieldMask.Paths, path)
   531  }
   532  
   533  func (fieldMask *TimeSerie_FieldMask) AppendRawPath(path gotenobject.FieldPath) {
   534  	fieldMask.Paths = append(fieldMask.Paths, path.(TimeSerie_FieldPath))
   535  }
   536  
   537  func (fieldMask *TimeSerie_FieldMask) GetPaths() []TimeSerie_FieldPath {
   538  	if fieldMask == nil {
   539  		return nil
   540  	}
   541  	return fieldMask.Paths
   542  }
   543  
   544  func (fieldMask *TimeSerie_FieldMask) GetRawPaths() []gotenobject.FieldPath {
   545  	if fieldMask == nil {
   546  		return nil
   547  	}
   548  	rawPaths := make([]gotenobject.FieldPath, 0, len(fieldMask.Paths))
   549  	for _, path := range fieldMask.Paths {
   550  		rawPaths = append(rawPaths, path)
   551  	}
   552  	return rawPaths
   553  }
   554  
   555  func (fieldMask *TimeSerie_FieldMask) SetFromCliFlag(raw string) error {
   556  	path, err := ParseTimeSerie_FieldPath(raw)
   557  	if err != nil {
   558  		return err
   559  	}
   560  	fieldMask.Paths = append(fieldMask.Paths, path)
   561  	return nil
   562  }
   563  
   564  func (fieldMask *TimeSerie_FieldMask) Set(target, source *TimeSerie) {
   565  	for _, path := range fieldMask.Paths {
   566  		val, _ := path.GetSingle(source)
   567  		// if val is nil, then field does not exist in source, skip
   568  		// otherwise, process (can still reflect.ValueOf(val).IsNil!)
   569  		if val != nil {
   570  			path.WithIValue(val).SetTo(&target)
   571  		}
   572  	}
   573  }
   574  
   575  func (fieldMask *TimeSerie_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) {
   576  	fieldMask.Set(target.(*TimeSerie), source.(*TimeSerie))
   577  }
   578  
   579  func (fieldMask *TimeSerie_FieldMask) Project(source *TimeSerie) *TimeSerie {
   580  	if source == nil {
   581  		return nil
   582  	}
   583  	if fieldMask == nil {
   584  		return source
   585  	}
   586  	result := &TimeSerie{}
   587  	metricMask := &common.Metric_FieldMask{}
   588  	wholeMetricAccepted := false
   589  	resourceMask := &common.MonitoredResource_FieldMask{}
   590  	wholeResourceAccepted := false
   591  	pointsMask := &Point_FieldMask{}
   592  	wholePointsAccepted := false
   593  
   594  	for _, p := range fieldMask.Paths {
   595  		switch tp := p.(type) {
   596  		case *TimeSerie_FieldTerminalPath:
   597  			switch tp.selector {
   598  			case TimeSerie_FieldPathSelectorKey:
   599  				result.Key = source.Key
   600  			case TimeSerie_FieldPathSelectorProject:
   601  				result.Project = source.Project
   602  			case TimeSerie_FieldPathSelectorRegion:
   603  				result.Region = source.Region
   604  			case TimeSerie_FieldPathSelectorUnit:
   605  				result.Unit = source.Unit
   606  			case TimeSerie_FieldPathSelectorMetric:
   607  				result.Metric = source.Metric
   608  				wholeMetricAccepted = true
   609  			case TimeSerie_FieldPathSelectorResource:
   610  				result.Resource = source.Resource
   611  				wholeResourceAccepted = true
   612  			case TimeSerie_FieldPathSelectorMetricKind:
   613  				result.MetricKind = source.MetricKind
   614  			case TimeSerie_FieldPathSelectorValueType:
   615  				result.ValueType = source.ValueType
   616  			case TimeSerie_FieldPathSelectorPoints:
   617  				result.Points = source.Points
   618  				wholePointsAccepted = true
   619  			}
   620  		case *TimeSerie_FieldSubPath:
   621  			switch tp.selector {
   622  			case TimeSerie_FieldPathSelectorMetric:
   623  				metricMask.AppendPath(tp.subPath.(common.Metric_FieldPath))
   624  			case TimeSerie_FieldPathSelectorResource:
   625  				resourceMask.AppendPath(tp.subPath.(common.MonitoredResource_FieldPath))
   626  			case TimeSerie_FieldPathSelectorPoints:
   627  				pointsMask.AppendPath(tp.subPath.(Point_FieldPath))
   628  			}
   629  		}
   630  	}
   631  	if wholeMetricAccepted == false && len(metricMask.Paths) > 0 {
   632  		result.Metric = metricMask.Project(source.GetMetric())
   633  	}
   634  	if wholeResourceAccepted == false && len(resourceMask.Paths) > 0 {
   635  		result.Resource = resourceMask.Project(source.GetResource())
   636  	}
   637  	if wholePointsAccepted == false && len(pointsMask.Paths) > 0 {
   638  		for _, sourceItem := range source.GetPoints() {
   639  			result.Points = append(result.Points, pointsMask.Project(sourceItem))
   640  		}
   641  	}
   642  	return result
   643  }
   644  
   645  func (fieldMask *TimeSerie_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
   646  	return fieldMask.Project(source.(*TimeSerie))
   647  }
   648  
   649  func (fieldMask *TimeSerie_FieldMask) PathsCount() int {
   650  	if fieldMask == nil {
   651  		return 0
   652  	}
   653  	return len(fieldMask.Paths)
   654  }
   655  
   656  type BulkTimeSeries_FieldMask struct {
   657  	Paths []BulkTimeSeries_FieldPath
   658  }
   659  
   660  func FullBulkTimeSeries_FieldMask() *BulkTimeSeries_FieldMask {
   661  	res := &BulkTimeSeries_FieldMask{}
   662  	res.Paths = append(res.Paths, &BulkTimeSeries_FieldTerminalPath{selector: BulkTimeSeries_FieldPathSelectorTimeSeries})
   663  	res.Paths = append(res.Paths, &BulkTimeSeries_FieldTerminalPath{selector: BulkTimeSeries_FieldPathSelectorPhantomFlag})
   664  	return res
   665  }
   666  
   667  func (fieldMask *BulkTimeSeries_FieldMask) String() string {
   668  	if fieldMask == nil {
   669  		return "<nil>"
   670  	}
   671  	pathsStr := make([]string, 0, len(fieldMask.Paths))
   672  	for _, path := range fieldMask.Paths {
   673  		pathsStr = append(pathsStr, path.String())
   674  	}
   675  	return strings.Join(pathsStr, ", ")
   676  }
   677  
   678  func (fieldMask *BulkTimeSeries_FieldMask) IsFull() bool {
   679  	if fieldMask == nil {
   680  		return false
   681  	}
   682  	presentSelectors := make([]bool, 2)
   683  	for _, path := range fieldMask.Paths {
   684  		if asFinal, ok := path.(*BulkTimeSeries_FieldTerminalPath); ok {
   685  			presentSelectors[int(asFinal.selector)] = true
   686  		}
   687  	}
   688  	for _, flag := range presentSelectors {
   689  		if !flag {
   690  			return false
   691  		}
   692  	}
   693  	return true
   694  }
   695  
   696  func (fieldMask *BulkTimeSeries_FieldMask) ProtoReflect() preflect.Message {
   697  	return gotenobject.MakeFieldMaskReflection(fieldMask, func(raw string) (gotenobject.FieldPath, error) {
   698  		return ParseBulkTimeSeries_FieldPath(raw)
   699  	})
   700  }
   701  
   702  func (fieldMask *BulkTimeSeries_FieldMask) ProtoMessage() {}
   703  
   704  func (fieldMask *BulkTimeSeries_FieldMask) Reset() {
   705  	if fieldMask != nil {
   706  		fieldMask.Paths = nil
   707  	}
   708  }
   709  
   710  func (fieldMask *BulkTimeSeries_FieldMask) Subtract(other *BulkTimeSeries_FieldMask) *BulkTimeSeries_FieldMask {
   711  	result := &BulkTimeSeries_FieldMask{}
   712  	removedSelectors := make([]bool, 2)
   713  	otherSubMasks := map[BulkTimeSeries_FieldPathSelector]gotenobject.FieldMask{
   714  		BulkTimeSeries_FieldPathSelectorTimeSeries: &TimeSerie_FieldMask{},
   715  	}
   716  	mySubMasks := map[BulkTimeSeries_FieldPathSelector]gotenobject.FieldMask{
   717  		BulkTimeSeries_FieldPathSelectorTimeSeries: &TimeSerie_FieldMask{},
   718  	}
   719  
   720  	for _, path := range other.GetPaths() {
   721  		switch tp := path.(type) {
   722  		case *BulkTimeSeries_FieldTerminalPath:
   723  			removedSelectors[int(tp.selector)] = true
   724  		case *BulkTimeSeries_FieldSubPath:
   725  			otherSubMasks[tp.selector].AppendRawPath(tp.subPath)
   726  		}
   727  	}
   728  	for _, path := range fieldMask.GetPaths() {
   729  		if !removedSelectors[int(path.Selector())] {
   730  			if otherSubMask := otherSubMasks[path.Selector()]; otherSubMask != nil && otherSubMask.PathsCount() > 0 {
   731  				if tp, ok := path.(*BulkTimeSeries_FieldTerminalPath); ok {
   732  					switch tp.selector {
   733  					case BulkTimeSeries_FieldPathSelectorTimeSeries:
   734  						mySubMasks[BulkTimeSeries_FieldPathSelectorTimeSeries] = FullTimeSerie_FieldMask()
   735  					}
   736  				} else if tp, ok := path.(*BulkTimeSeries_FieldSubPath); ok {
   737  					mySubMasks[tp.selector].AppendRawPath(tp.subPath)
   738  				}
   739  			} else {
   740  				result.Paths = append(result.Paths, path)
   741  			}
   742  		}
   743  	}
   744  	for selector, mySubMask := range mySubMasks {
   745  		if mySubMask.PathsCount() > 0 {
   746  			for _, allowedPath := range mySubMask.SubtractRaw(otherSubMasks[selector]).GetRawPaths() {
   747  				result.Paths = append(result.Paths, &BulkTimeSeries_FieldSubPath{selector: selector, subPath: allowedPath})
   748  			}
   749  		}
   750  	}
   751  
   752  	if len(result.Paths) == 0 {
   753  		return nil
   754  	}
   755  	return result
   756  }
   757  
   758  func (fieldMask *BulkTimeSeries_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask {
   759  	return fieldMask.Subtract(other.(*BulkTimeSeries_FieldMask))
   760  }
   761  
   762  // FilterInputFields generates copy of field paths with output_only field paths removed
   763  func (fieldMask *BulkTimeSeries_FieldMask) FilterInputFields() *BulkTimeSeries_FieldMask {
   764  	result := &BulkTimeSeries_FieldMask{}
   765  	result.Paths = append(result.Paths, fieldMask.Paths...)
   766  	return result
   767  }
   768  
   769  // ToFieldMask is used for proto conversions
   770  func (fieldMask *BulkTimeSeries_FieldMask) ToProtoFieldMask() *googlefieldmaskpb.FieldMask {
   771  	protoFieldMask := &googlefieldmaskpb.FieldMask{}
   772  	for _, path := range fieldMask.Paths {
   773  		protoFieldMask.Paths = append(protoFieldMask.Paths, path.String())
   774  	}
   775  	return protoFieldMask
   776  }
   777  
   778  func (fieldMask *BulkTimeSeries_FieldMask) FromProtoFieldMask(protoFieldMask *googlefieldmaskpb.FieldMask) error {
   779  	if fieldMask == nil {
   780  		return status.Error(codes.Internal, "target field mask is nil")
   781  	}
   782  	fieldMask.Paths = make([]BulkTimeSeries_FieldPath, 0, len(protoFieldMask.Paths))
   783  	for _, strPath := range protoFieldMask.Paths {
   784  		path, err := ParseBulkTimeSeries_FieldPath(strPath)
   785  		if err != nil {
   786  			return err
   787  		}
   788  		fieldMask.Paths = append(fieldMask.Paths, path)
   789  	}
   790  	return nil
   791  }
   792  
   793  // implement methods required by customType
   794  func (fieldMask BulkTimeSeries_FieldMask) Marshal() ([]byte, error) {
   795  	protoFieldMask := fieldMask.ToProtoFieldMask()
   796  	return proto.Marshal(protoFieldMask)
   797  }
   798  
   799  func (fieldMask *BulkTimeSeries_FieldMask) Unmarshal(data []byte) error {
   800  	protoFieldMask := &googlefieldmaskpb.FieldMask{}
   801  	if err := proto.Unmarshal(data, protoFieldMask); err != nil {
   802  		return err
   803  	}
   804  	if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil {
   805  		return err
   806  	}
   807  	return nil
   808  }
   809  
   810  func (fieldMask *BulkTimeSeries_FieldMask) Size() int {
   811  	return proto.Size(fieldMask.ToProtoFieldMask())
   812  }
   813  
   814  func (fieldMask BulkTimeSeries_FieldMask) MarshalJSON() ([]byte, error) {
   815  	return json.Marshal(fieldMask.ToProtoFieldMask())
   816  }
   817  
   818  func (fieldMask *BulkTimeSeries_FieldMask) UnmarshalJSON(data []byte) error {
   819  	protoFieldMask := &googlefieldmaskpb.FieldMask{}
   820  	if err := json.Unmarshal(data, protoFieldMask); err != nil {
   821  		return err
   822  	}
   823  	if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil {
   824  		return err
   825  	}
   826  	return nil
   827  }
   828  
   829  func (fieldMask *BulkTimeSeries_FieldMask) AppendPath(path BulkTimeSeries_FieldPath) {
   830  	fieldMask.Paths = append(fieldMask.Paths, path)
   831  }
   832  
   833  func (fieldMask *BulkTimeSeries_FieldMask) AppendRawPath(path gotenobject.FieldPath) {
   834  	fieldMask.Paths = append(fieldMask.Paths, path.(BulkTimeSeries_FieldPath))
   835  }
   836  
   837  func (fieldMask *BulkTimeSeries_FieldMask) GetPaths() []BulkTimeSeries_FieldPath {
   838  	if fieldMask == nil {
   839  		return nil
   840  	}
   841  	return fieldMask.Paths
   842  }
   843  
   844  func (fieldMask *BulkTimeSeries_FieldMask) GetRawPaths() []gotenobject.FieldPath {
   845  	if fieldMask == nil {
   846  		return nil
   847  	}
   848  	rawPaths := make([]gotenobject.FieldPath, 0, len(fieldMask.Paths))
   849  	for _, path := range fieldMask.Paths {
   850  		rawPaths = append(rawPaths, path)
   851  	}
   852  	return rawPaths
   853  }
   854  
   855  func (fieldMask *BulkTimeSeries_FieldMask) SetFromCliFlag(raw string) error {
   856  	path, err := ParseBulkTimeSeries_FieldPath(raw)
   857  	if err != nil {
   858  		return err
   859  	}
   860  	fieldMask.Paths = append(fieldMask.Paths, path)
   861  	return nil
   862  }
   863  
   864  func (fieldMask *BulkTimeSeries_FieldMask) Set(target, source *BulkTimeSeries) {
   865  	for _, path := range fieldMask.Paths {
   866  		val, _ := path.GetSingle(source)
   867  		// if val is nil, then field does not exist in source, skip
   868  		// otherwise, process (can still reflect.ValueOf(val).IsNil!)
   869  		if val != nil {
   870  			path.WithIValue(val).SetTo(&target)
   871  		}
   872  	}
   873  }
   874  
   875  func (fieldMask *BulkTimeSeries_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) {
   876  	fieldMask.Set(target.(*BulkTimeSeries), source.(*BulkTimeSeries))
   877  }
   878  
   879  func (fieldMask *BulkTimeSeries_FieldMask) Project(source *BulkTimeSeries) *BulkTimeSeries {
   880  	if source == nil {
   881  		return nil
   882  	}
   883  	if fieldMask == nil {
   884  		return source
   885  	}
   886  	result := &BulkTimeSeries{}
   887  	timeSeriesMask := &TimeSerie_FieldMask{}
   888  	wholeTimeSeriesAccepted := false
   889  
   890  	for _, p := range fieldMask.Paths {
   891  		switch tp := p.(type) {
   892  		case *BulkTimeSeries_FieldTerminalPath:
   893  			switch tp.selector {
   894  			case BulkTimeSeries_FieldPathSelectorTimeSeries:
   895  				result.TimeSeries = source.TimeSeries
   896  				wholeTimeSeriesAccepted = true
   897  			case BulkTimeSeries_FieldPathSelectorPhantomFlag:
   898  				result.PhantomFlag = source.PhantomFlag
   899  			}
   900  		case *BulkTimeSeries_FieldSubPath:
   901  			switch tp.selector {
   902  			case BulkTimeSeries_FieldPathSelectorTimeSeries:
   903  				timeSeriesMask.AppendPath(tp.subPath.(TimeSerie_FieldPath))
   904  			}
   905  		}
   906  	}
   907  	if wholeTimeSeriesAccepted == false && len(timeSeriesMask.Paths) > 0 {
   908  		for _, sourceItem := range source.GetTimeSeries() {
   909  			result.TimeSeries = append(result.TimeSeries, timeSeriesMask.Project(sourceItem))
   910  		}
   911  	}
   912  	return result
   913  }
   914  
   915  func (fieldMask *BulkTimeSeries_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
   916  	return fieldMask.Project(source.(*BulkTimeSeries))
   917  }
   918  
   919  func (fieldMask *BulkTimeSeries_FieldMask) PathsCount() int {
   920  	if fieldMask == nil {
   921  		return 0
   922  	}
   923  	return len(fieldMask.Paths)
   924  }