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

     1  // Code generated by protoc-gen-goten-object
     2  // File: edgelq/monitoring/proto/v3/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/v3/common"
    23  	metric_descriptor "github.com/cloudwan/edgelq-sdk/monitoring/resources/v3/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_FieldPathSelectorMetric})
   351  	res.Paths = append(res.Paths, &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorResource})
   352  	res.Paths = append(res.Paths, &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorMetricKind})
   353  	res.Paths = append(res.Paths, &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorValueType})
   354  	res.Paths = append(res.Paths, &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorPoints})
   355  	return res
   356  }
   357  
   358  func (fieldMask *TimeSerie_FieldMask) String() string {
   359  	if fieldMask == nil {
   360  		return "<nil>"
   361  	}
   362  	pathsStr := make([]string, 0, len(fieldMask.Paths))
   363  	for _, path := range fieldMask.Paths {
   364  		pathsStr = append(pathsStr, path.String())
   365  	}
   366  	return strings.Join(pathsStr, ", ")
   367  }
   368  
   369  func (fieldMask *TimeSerie_FieldMask) IsFull() bool {
   370  	if fieldMask == nil {
   371  		return false
   372  	}
   373  	presentSelectors := make([]bool, 8)
   374  	for _, path := range fieldMask.Paths {
   375  		if asFinal, ok := path.(*TimeSerie_FieldTerminalPath); ok {
   376  			presentSelectors[int(asFinal.selector)] = true
   377  		}
   378  	}
   379  	for _, flag := range presentSelectors {
   380  		if !flag {
   381  			return false
   382  		}
   383  	}
   384  	return true
   385  }
   386  
   387  func (fieldMask *TimeSerie_FieldMask) ProtoReflect() preflect.Message {
   388  	return gotenobject.MakeFieldMaskReflection(fieldMask, func(raw string) (gotenobject.FieldPath, error) {
   389  		return ParseTimeSerie_FieldPath(raw)
   390  	})
   391  }
   392  
   393  func (fieldMask *TimeSerie_FieldMask) ProtoMessage() {}
   394  
   395  func (fieldMask *TimeSerie_FieldMask) Reset() {
   396  	if fieldMask != nil {
   397  		fieldMask.Paths = nil
   398  	}
   399  }
   400  
   401  func (fieldMask *TimeSerie_FieldMask) Subtract(other *TimeSerie_FieldMask) *TimeSerie_FieldMask {
   402  	result := &TimeSerie_FieldMask{}
   403  	removedSelectors := make([]bool, 8)
   404  	otherSubMasks := map[TimeSerie_FieldPathSelector]gotenobject.FieldMask{
   405  		TimeSerie_FieldPathSelectorMetric:   &common.Metric_FieldMask{},
   406  		TimeSerie_FieldPathSelectorResource: &common.MonitoredResource_FieldMask{},
   407  		TimeSerie_FieldPathSelectorPoints:   &Point_FieldMask{},
   408  	}
   409  	mySubMasks := map[TimeSerie_FieldPathSelector]gotenobject.FieldMask{
   410  		TimeSerie_FieldPathSelectorMetric:   &common.Metric_FieldMask{},
   411  		TimeSerie_FieldPathSelectorResource: &common.MonitoredResource_FieldMask{},
   412  		TimeSerie_FieldPathSelectorPoints:   &Point_FieldMask{},
   413  	}
   414  
   415  	for _, path := range other.GetPaths() {
   416  		switch tp := path.(type) {
   417  		case *TimeSerie_FieldTerminalPath:
   418  			removedSelectors[int(tp.selector)] = true
   419  		case *TimeSerie_FieldSubPath:
   420  			otherSubMasks[tp.selector].AppendRawPath(tp.subPath)
   421  		}
   422  	}
   423  	for _, path := range fieldMask.GetPaths() {
   424  		if !removedSelectors[int(path.Selector())] {
   425  			if otherSubMask := otherSubMasks[path.Selector()]; otherSubMask != nil && otherSubMask.PathsCount() > 0 {
   426  				if tp, ok := path.(*TimeSerie_FieldTerminalPath); ok {
   427  					switch tp.selector {
   428  					case TimeSerie_FieldPathSelectorMetric:
   429  						mySubMasks[TimeSerie_FieldPathSelectorMetric] = common.FullMetric_FieldMask()
   430  					case TimeSerie_FieldPathSelectorResource:
   431  						mySubMasks[TimeSerie_FieldPathSelectorResource] = common.FullMonitoredResource_FieldMask()
   432  					case TimeSerie_FieldPathSelectorPoints:
   433  						mySubMasks[TimeSerie_FieldPathSelectorPoints] = FullPoint_FieldMask()
   434  					}
   435  				} else if tp, ok := path.(*TimeSerie_FieldSubPath); ok {
   436  					mySubMasks[tp.selector].AppendRawPath(tp.subPath)
   437  				}
   438  			} else {
   439  				result.Paths = append(result.Paths, path)
   440  			}
   441  		}
   442  	}
   443  	for selector, mySubMask := range mySubMasks {
   444  		if mySubMask.PathsCount() > 0 {
   445  			for _, allowedPath := range mySubMask.SubtractRaw(otherSubMasks[selector]).GetRawPaths() {
   446  				result.Paths = append(result.Paths, &TimeSerie_FieldSubPath{selector: selector, subPath: allowedPath})
   447  			}
   448  		}
   449  	}
   450  
   451  	if len(result.Paths) == 0 {
   452  		return nil
   453  	}
   454  	return result
   455  }
   456  
   457  func (fieldMask *TimeSerie_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask {
   458  	return fieldMask.Subtract(other.(*TimeSerie_FieldMask))
   459  }
   460  
   461  // FilterInputFields generates copy of field paths with output_only field paths removed
   462  func (fieldMask *TimeSerie_FieldMask) FilterInputFields() *TimeSerie_FieldMask {
   463  	result := &TimeSerie_FieldMask{}
   464  	result.Paths = append(result.Paths, fieldMask.Paths...)
   465  	return result
   466  }
   467  
   468  // ToFieldMask is used for proto conversions
   469  func (fieldMask *TimeSerie_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 *TimeSerie_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([]TimeSerie_FieldPath, 0, len(protoFieldMask.Paths))
   482  	for _, strPath := range protoFieldMask.Paths {
   483  		path, err := ParseTimeSerie_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 TimeSerie_FieldMask) Marshal() ([]byte, error) {
   494  	protoFieldMask := fieldMask.ToProtoFieldMask()
   495  	return proto.Marshal(protoFieldMask)
   496  }
   497  
   498  func (fieldMask *TimeSerie_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 *TimeSerie_FieldMask) Size() int {
   510  	return proto.Size(fieldMask.ToProtoFieldMask())
   511  }
   512  
   513  func (fieldMask TimeSerie_FieldMask) MarshalJSON() ([]byte, error) {
   514  	return json.Marshal(fieldMask.ToProtoFieldMask())
   515  }
   516  
   517  func (fieldMask *TimeSerie_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 *TimeSerie_FieldMask) AppendPath(path TimeSerie_FieldPath) {
   529  	fieldMask.Paths = append(fieldMask.Paths, path)
   530  }
   531  
   532  func (fieldMask *TimeSerie_FieldMask) AppendRawPath(path gotenobject.FieldPath) {
   533  	fieldMask.Paths = append(fieldMask.Paths, path.(TimeSerie_FieldPath))
   534  }
   535  
   536  func (fieldMask *TimeSerie_FieldMask) GetPaths() []TimeSerie_FieldPath {
   537  	if fieldMask == nil {
   538  		return nil
   539  	}
   540  	return fieldMask.Paths
   541  }
   542  
   543  func (fieldMask *TimeSerie_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 *TimeSerie_FieldMask) SetFromCliFlag(raw string) error {
   555  	path, err := ParseTimeSerie_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 *TimeSerie_FieldMask) Set(target, source *TimeSerie) {
   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 *TimeSerie_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) {
   575  	fieldMask.Set(target.(*TimeSerie), source.(*TimeSerie))
   576  }
   577  
   578  func (fieldMask *TimeSerie_FieldMask) Project(source *TimeSerie) *TimeSerie {
   579  	if source == nil {
   580  		return nil
   581  	}
   582  	if fieldMask == nil {
   583  		return source
   584  	}
   585  	result := &TimeSerie{}
   586  	metricMask := &common.Metric_FieldMask{}
   587  	wholeMetricAccepted := false
   588  	resourceMask := &common.MonitoredResource_FieldMask{}
   589  	wholeResourceAccepted := false
   590  	pointsMask := &Point_FieldMask{}
   591  	wholePointsAccepted := false
   592  
   593  	for _, p := range fieldMask.Paths {
   594  		switch tp := p.(type) {
   595  		case *TimeSerie_FieldTerminalPath:
   596  			switch tp.selector {
   597  			case TimeSerie_FieldPathSelectorKey:
   598  				result.Key = source.Key
   599  			case TimeSerie_FieldPathSelectorProject:
   600  				result.Project = source.Project
   601  			case TimeSerie_FieldPathSelectorRegion:
   602  				result.Region = source.Region
   603  			case TimeSerie_FieldPathSelectorMetric:
   604  				result.Metric = source.Metric
   605  				wholeMetricAccepted = true
   606  			case TimeSerie_FieldPathSelectorResource:
   607  				result.Resource = source.Resource
   608  				wholeResourceAccepted = true
   609  			case TimeSerie_FieldPathSelectorMetricKind:
   610  				result.MetricKind = source.MetricKind
   611  			case TimeSerie_FieldPathSelectorValueType:
   612  				result.ValueType = source.ValueType
   613  			case TimeSerie_FieldPathSelectorPoints:
   614  				result.Points = source.Points
   615  				wholePointsAccepted = true
   616  			}
   617  		case *TimeSerie_FieldSubPath:
   618  			switch tp.selector {
   619  			case TimeSerie_FieldPathSelectorMetric:
   620  				metricMask.AppendPath(tp.subPath.(common.Metric_FieldPath))
   621  			case TimeSerie_FieldPathSelectorResource:
   622  				resourceMask.AppendPath(tp.subPath.(common.MonitoredResource_FieldPath))
   623  			case TimeSerie_FieldPathSelectorPoints:
   624  				pointsMask.AppendPath(tp.subPath.(Point_FieldPath))
   625  			}
   626  		}
   627  	}
   628  	if wholeMetricAccepted == false && len(metricMask.Paths) > 0 {
   629  		result.Metric = metricMask.Project(source.GetMetric())
   630  	}
   631  	if wholeResourceAccepted == false && len(resourceMask.Paths) > 0 {
   632  		result.Resource = resourceMask.Project(source.GetResource())
   633  	}
   634  	if wholePointsAccepted == false && len(pointsMask.Paths) > 0 {
   635  		for _, sourceItem := range source.GetPoints() {
   636  			result.Points = append(result.Points, pointsMask.Project(sourceItem))
   637  		}
   638  	}
   639  	return result
   640  }
   641  
   642  func (fieldMask *TimeSerie_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
   643  	return fieldMask.Project(source.(*TimeSerie))
   644  }
   645  
   646  func (fieldMask *TimeSerie_FieldMask) PathsCount() int {
   647  	if fieldMask == nil {
   648  		return 0
   649  	}
   650  	return len(fieldMask.Paths)
   651  }
   652  
   653  type BulkTimeSeries_FieldMask struct {
   654  	Paths []BulkTimeSeries_FieldPath
   655  }
   656  
   657  func FullBulkTimeSeries_FieldMask() *BulkTimeSeries_FieldMask {
   658  	res := &BulkTimeSeries_FieldMask{}
   659  	res.Paths = append(res.Paths, &BulkTimeSeries_FieldTerminalPath{selector: BulkTimeSeries_FieldPathSelectorTimeSeries})
   660  	res.Paths = append(res.Paths, &BulkTimeSeries_FieldTerminalPath{selector: BulkTimeSeries_FieldPathSelectorPhantomFlag})
   661  	return res
   662  }
   663  
   664  func (fieldMask *BulkTimeSeries_FieldMask) String() string {
   665  	if fieldMask == nil {
   666  		return "<nil>"
   667  	}
   668  	pathsStr := make([]string, 0, len(fieldMask.Paths))
   669  	for _, path := range fieldMask.Paths {
   670  		pathsStr = append(pathsStr, path.String())
   671  	}
   672  	return strings.Join(pathsStr, ", ")
   673  }
   674  
   675  func (fieldMask *BulkTimeSeries_FieldMask) IsFull() bool {
   676  	if fieldMask == nil {
   677  		return false
   678  	}
   679  	presentSelectors := make([]bool, 2)
   680  	for _, path := range fieldMask.Paths {
   681  		if asFinal, ok := path.(*BulkTimeSeries_FieldTerminalPath); ok {
   682  			presentSelectors[int(asFinal.selector)] = true
   683  		}
   684  	}
   685  	for _, flag := range presentSelectors {
   686  		if !flag {
   687  			return false
   688  		}
   689  	}
   690  	return true
   691  }
   692  
   693  func (fieldMask *BulkTimeSeries_FieldMask) ProtoReflect() preflect.Message {
   694  	return gotenobject.MakeFieldMaskReflection(fieldMask, func(raw string) (gotenobject.FieldPath, error) {
   695  		return ParseBulkTimeSeries_FieldPath(raw)
   696  	})
   697  }
   698  
   699  func (fieldMask *BulkTimeSeries_FieldMask) ProtoMessage() {}
   700  
   701  func (fieldMask *BulkTimeSeries_FieldMask) Reset() {
   702  	if fieldMask != nil {
   703  		fieldMask.Paths = nil
   704  	}
   705  }
   706  
   707  func (fieldMask *BulkTimeSeries_FieldMask) Subtract(other *BulkTimeSeries_FieldMask) *BulkTimeSeries_FieldMask {
   708  	result := &BulkTimeSeries_FieldMask{}
   709  	removedSelectors := make([]bool, 2)
   710  	otherSubMasks := map[BulkTimeSeries_FieldPathSelector]gotenobject.FieldMask{
   711  		BulkTimeSeries_FieldPathSelectorTimeSeries: &TimeSerie_FieldMask{},
   712  	}
   713  	mySubMasks := map[BulkTimeSeries_FieldPathSelector]gotenobject.FieldMask{
   714  		BulkTimeSeries_FieldPathSelectorTimeSeries: &TimeSerie_FieldMask{},
   715  	}
   716  
   717  	for _, path := range other.GetPaths() {
   718  		switch tp := path.(type) {
   719  		case *BulkTimeSeries_FieldTerminalPath:
   720  			removedSelectors[int(tp.selector)] = true
   721  		case *BulkTimeSeries_FieldSubPath:
   722  			otherSubMasks[tp.selector].AppendRawPath(tp.subPath)
   723  		}
   724  	}
   725  	for _, path := range fieldMask.GetPaths() {
   726  		if !removedSelectors[int(path.Selector())] {
   727  			if otherSubMask := otherSubMasks[path.Selector()]; otherSubMask != nil && otherSubMask.PathsCount() > 0 {
   728  				if tp, ok := path.(*BulkTimeSeries_FieldTerminalPath); ok {
   729  					switch tp.selector {
   730  					case BulkTimeSeries_FieldPathSelectorTimeSeries:
   731  						mySubMasks[BulkTimeSeries_FieldPathSelectorTimeSeries] = FullTimeSerie_FieldMask()
   732  					}
   733  				} else if tp, ok := path.(*BulkTimeSeries_FieldSubPath); ok {
   734  					mySubMasks[tp.selector].AppendRawPath(tp.subPath)
   735  				}
   736  			} else {
   737  				result.Paths = append(result.Paths, path)
   738  			}
   739  		}
   740  	}
   741  	for selector, mySubMask := range mySubMasks {
   742  		if mySubMask.PathsCount() > 0 {
   743  			for _, allowedPath := range mySubMask.SubtractRaw(otherSubMasks[selector]).GetRawPaths() {
   744  				result.Paths = append(result.Paths, &BulkTimeSeries_FieldSubPath{selector: selector, subPath: allowedPath})
   745  			}
   746  		}
   747  	}
   748  
   749  	if len(result.Paths) == 0 {
   750  		return nil
   751  	}
   752  	return result
   753  }
   754  
   755  func (fieldMask *BulkTimeSeries_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask {
   756  	return fieldMask.Subtract(other.(*BulkTimeSeries_FieldMask))
   757  }
   758  
   759  // FilterInputFields generates copy of field paths with output_only field paths removed
   760  func (fieldMask *BulkTimeSeries_FieldMask) FilterInputFields() *BulkTimeSeries_FieldMask {
   761  	result := &BulkTimeSeries_FieldMask{}
   762  	result.Paths = append(result.Paths, fieldMask.Paths...)
   763  	return result
   764  }
   765  
   766  // ToFieldMask is used for proto conversions
   767  func (fieldMask *BulkTimeSeries_FieldMask) ToProtoFieldMask() *googlefieldmaskpb.FieldMask {
   768  	protoFieldMask := &googlefieldmaskpb.FieldMask{}
   769  	for _, path := range fieldMask.Paths {
   770  		protoFieldMask.Paths = append(protoFieldMask.Paths, path.String())
   771  	}
   772  	return protoFieldMask
   773  }
   774  
   775  func (fieldMask *BulkTimeSeries_FieldMask) FromProtoFieldMask(protoFieldMask *googlefieldmaskpb.FieldMask) error {
   776  	if fieldMask == nil {
   777  		return status.Error(codes.Internal, "target field mask is nil")
   778  	}
   779  	fieldMask.Paths = make([]BulkTimeSeries_FieldPath, 0, len(protoFieldMask.Paths))
   780  	for _, strPath := range protoFieldMask.Paths {
   781  		path, err := ParseBulkTimeSeries_FieldPath(strPath)
   782  		if err != nil {
   783  			return err
   784  		}
   785  		fieldMask.Paths = append(fieldMask.Paths, path)
   786  	}
   787  	return nil
   788  }
   789  
   790  // implement methods required by customType
   791  func (fieldMask BulkTimeSeries_FieldMask) Marshal() ([]byte, error) {
   792  	protoFieldMask := fieldMask.ToProtoFieldMask()
   793  	return proto.Marshal(protoFieldMask)
   794  }
   795  
   796  func (fieldMask *BulkTimeSeries_FieldMask) Unmarshal(data []byte) error {
   797  	protoFieldMask := &googlefieldmaskpb.FieldMask{}
   798  	if err := proto.Unmarshal(data, protoFieldMask); err != nil {
   799  		return err
   800  	}
   801  	if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil {
   802  		return err
   803  	}
   804  	return nil
   805  }
   806  
   807  func (fieldMask *BulkTimeSeries_FieldMask) Size() int {
   808  	return proto.Size(fieldMask.ToProtoFieldMask())
   809  }
   810  
   811  func (fieldMask BulkTimeSeries_FieldMask) MarshalJSON() ([]byte, error) {
   812  	return json.Marshal(fieldMask.ToProtoFieldMask())
   813  }
   814  
   815  func (fieldMask *BulkTimeSeries_FieldMask) UnmarshalJSON(data []byte) error {
   816  	protoFieldMask := &googlefieldmaskpb.FieldMask{}
   817  	if err := json.Unmarshal(data, protoFieldMask); err != nil {
   818  		return err
   819  	}
   820  	if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil {
   821  		return err
   822  	}
   823  	return nil
   824  }
   825  
   826  func (fieldMask *BulkTimeSeries_FieldMask) AppendPath(path BulkTimeSeries_FieldPath) {
   827  	fieldMask.Paths = append(fieldMask.Paths, path)
   828  }
   829  
   830  func (fieldMask *BulkTimeSeries_FieldMask) AppendRawPath(path gotenobject.FieldPath) {
   831  	fieldMask.Paths = append(fieldMask.Paths, path.(BulkTimeSeries_FieldPath))
   832  }
   833  
   834  func (fieldMask *BulkTimeSeries_FieldMask) GetPaths() []BulkTimeSeries_FieldPath {
   835  	if fieldMask == nil {
   836  		return nil
   837  	}
   838  	return fieldMask.Paths
   839  }
   840  
   841  func (fieldMask *BulkTimeSeries_FieldMask) GetRawPaths() []gotenobject.FieldPath {
   842  	if fieldMask == nil {
   843  		return nil
   844  	}
   845  	rawPaths := make([]gotenobject.FieldPath, 0, len(fieldMask.Paths))
   846  	for _, path := range fieldMask.Paths {
   847  		rawPaths = append(rawPaths, path)
   848  	}
   849  	return rawPaths
   850  }
   851  
   852  func (fieldMask *BulkTimeSeries_FieldMask) SetFromCliFlag(raw string) error {
   853  	path, err := ParseBulkTimeSeries_FieldPath(raw)
   854  	if err != nil {
   855  		return err
   856  	}
   857  	fieldMask.Paths = append(fieldMask.Paths, path)
   858  	return nil
   859  }
   860  
   861  func (fieldMask *BulkTimeSeries_FieldMask) Set(target, source *BulkTimeSeries) {
   862  	for _, path := range fieldMask.Paths {
   863  		val, _ := path.GetSingle(source)
   864  		// if val is nil, then field does not exist in source, skip
   865  		// otherwise, process (can still reflect.ValueOf(val).IsNil!)
   866  		if val != nil {
   867  			path.WithIValue(val).SetTo(&target)
   868  		}
   869  	}
   870  }
   871  
   872  func (fieldMask *BulkTimeSeries_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) {
   873  	fieldMask.Set(target.(*BulkTimeSeries), source.(*BulkTimeSeries))
   874  }
   875  
   876  func (fieldMask *BulkTimeSeries_FieldMask) Project(source *BulkTimeSeries) *BulkTimeSeries {
   877  	if source == nil {
   878  		return nil
   879  	}
   880  	if fieldMask == nil {
   881  		return source
   882  	}
   883  	result := &BulkTimeSeries{}
   884  	timeSeriesMask := &TimeSerie_FieldMask{}
   885  	wholeTimeSeriesAccepted := false
   886  
   887  	for _, p := range fieldMask.Paths {
   888  		switch tp := p.(type) {
   889  		case *BulkTimeSeries_FieldTerminalPath:
   890  			switch tp.selector {
   891  			case BulkTimeSeries_FieldPathSelectorTimeSeries:
   892  				result.TimeSeries = source.TimeSeries
   893  				wholeTimeSeriesAccepted = true
   894  			case BulkTimeSeries_FieldPathSelectorPhantomFlag:
   895  				result.PhantomFlag = source.PhantomFlag
   896  			}
   897  		case *BulkTimeSeries_FieldSubPath:
   898  			switch tp.selector {
   899  			case BulkTimeSeries_FieldPathSelectorTimeSeries:
   900  				timeSeriesMask.AppendPath(tp.subPath.(TimeSerie_FieldPath))
   901  			}
   902  		}
   903  	}
   904  	if wholeTimeSeriesAccepted == false && len(timeSeriesMask.Paths) > 0 {
   905  		for _, sourceItem := range source.GetTimeSeries() {
   906  			result.TimeSeries = append(result.TimeSeries, timeSeriesMask.Project(sourceItem))
   907  		}
   908  	}
   909  	return result
   910  }
   911  
   912  func (fieldMask *BulkTimeSeries_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
   913  	return fieldMask.Project(source.(*BulkTimeSeries))
   914  }
   915  
   916  func (fieldMask *BulkTimeSeries_FieldMask) PathsCount() int {
   917  	if fieldMask == nil {
   918  		return 0
   919  	}
   920  	return len(fieldMask.Paths)
   921  }