github.com/cloudwan/edgelq-sdk@v1.15.4/monitoring/resources/v3/time_serie/time_serie.pb.fieldpath.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  	"fmt"
    10  	"reflect"
    11  	"strings"
    12  	"time"
    13  
    14  	"google.golang.org/grpc/codes"
    15  	"google.golang.org/grpc/status"
    16  	"google.golang.org/protobuf/encoding/protojson"
    17  	"google.golang.org/protobuf/proto"
    18  	"google.golang.org/protobuf/reflect/protoregistry"
    19  
    20  	gotenobject "github.com/cloudwan/goten-sdk/runtime/object"
    21  	"github.com/cloudwan/goten-sdk/runtime/strcase"
    22  )
    23  
    24  // proto imports
    25  import (
    26  	common "github.com/cloudwan/edgelq-sdk/monitoring/resources/v3/common"
    27  	metric_descriptor "github.com/cloudwan/edgelq-sdk/monitoring/resources/v3/metric_descriptor"
    28  )
    29  
    30  // ensure the imports are used
    31  var (
    32  	_ = new(json.Marshaler)
    33  	_ = new(fmt.Stringer)
    34  	_ = reflect.DeepEqual
    35  	_ = strings.Builder{}
    36  	_ = time.Second
    37  
    38  	_ = strcase.ToLowerCamel
    39  	_ = codes.NotFound
    40  	_ = status.Status{}
    41  	_ = protojson.UnmarshalOptions{}
    42  	_ = new(proto.Message)
    43  	_ = protoregistry.GlobalTypes
    44  
    45  	_ = new(gotenobject.FieldPath)
    46  )
    47  
    48  // make sure we're using proto imports
    49  var (
    50  	_ = &common.LabelDescriptor{}
    51  	_ = &metric_descriptor.MetricDescriptor{}
    52  )
    53  
    54  // FieldPath provides implementation to handle
    55  // https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
    56  type Point_FieldPath interface {
    57  	gotenobject.FieldPath
    58  	Selector() Point_FieldPathSelector
    59  	Get(source *Point) []interface{}
    60  	GetSingle(source *Point) (interface{}, bool)
    61  	ClearValue(item *Point)
    62  
    63  	// Those methods build corresponding Point_FieldPathValue
    64  	// (or array of values) and holds passed value. Panics if injected type is incorrect.
    65  	WithIValue(value interface{}) Point_FieldPathValue
    66  	WithIArrayOfValues(values interface{}) Point_FieldPathArrayOfValues
    67  	WithIArrayItemValue(value interface{}) Point_FieldPathArrayItemValue
    68  }
    69  
    70  type Point_FieldPathSelector int32
    71  
    72  const (
    73  	Point_FieldPathSelectorInterval    Point_FieldPathSelector = 0
    74  	Point_FieldPathSelectorValue       Point_FieldPathSelector = 1
    75  	Point_FieldPathSelectorAggregation Point_FieldPathSelector = 2
    76  )
    77  
    78  func (s Point_FieldPathSelector) String() string {
    79  	switch s {
    80  	case Point_FieldPathSelectorInterval:
    81  		return "interval"
    82  	case Point_FieldPathSelectorValue:
    83  		return "value"
    84  	case Point_FieldPathSelectorAggregation:
    85  		return "aggregation"
    86  	default:
    87  		panic(fmt.Sprintf("Invalid selector for Point: %d", s))
    88  	}
    89  }
    90  
    91  func BuildPoint_FieldPath(fp gotenobject.RawFieldPath) (Point_FieldPath, error) {
    92  	if len(fp) == 0 {
    93  		return nil, status.Error(codes.InvalidArgument, "empty field path for object Point")
    94  	}
    95  	if len(fp) == 1 {
    96  		switch fp[0] {
    97  		case "interval":
    98  			return &Point_FieldTerminalPath{selector: Point_FieldPathSelectorInterval}, nil
    99  		case "value":
   100  			return &Point_FieldTerminalPath{selector: Point_FieldPathSelectorValue}, nil
   101  		case "aggregation":
   102  			return &Point_FieldTerminalPath{selector: Point_FieldPathSelectorAggregation}, nil
   103  		}
   104  	} else {
   105  		switch fp[0] {
   106  		case "interval":
   107  			if subpath, err := common.BuildTimeInterval_FieldPath(fp[1:]); err != nil {
   108  				return nil, err
   109  			} else {
   110  				return &Point_FieldSubPath{selector: Point_FieldPathSelectorInterval, subPath: subpath}, nil
   111  			}
   112  		case "value":
   113  			if subpath, err := common.BuildTypedValue_FieldPath(fp[1:]); err != nil {
   114  				return nil, err
   115  			} else {
   116  				return &Point_FieldSubPath{selector: Point_FieldPathSelectorValue, subPath: subpath}, nil
   117  			}
   118  		case "aggregation":
   119  			if subpath, err := common.BuildAggregation_FieldPath(fp[1:]); err != nil {
   120  				return nil, err
   121  			} else {
   122  				return &Point_FieldSubPath{selector: Point_FieldPathSelectorAggregation, subPath: subpath}, nil
   123  			}
   124  		}
   125  	}
   126  	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object Point", fp)
   127  }
   128  
   129  func ParsePoint_FieldPath(rawField string) (Point_FieldPath, error) {
   130  	fp, err := gotenobject.ParseRawFieldPath(rawField)
   131  	if err != nil {
   132  		return nil, err
   133  	}
   134  	return BuildPoint_FieldPath(fp)
   135  }
   136  
   137  func MustParsePoint_FieldPath(rawField string) Point_FieldPath {
   138  	fp, err := ParsePoint_FieldPath(rawField)
   139  	if err != nil {
   140  		panic(err)
   141  	}
   142  	return fp
   143  }
   144  
   145  type Point_FieldTerminalPath struct {
   146  	selector Point_FieldPathSelector
   147  }
   148  
   149  var _ Point_FieldPath = (*Point_FieldTerminalPath)(nil)
   150  
   151  func (fp *Point_FieldTerminalPath) Selector() Point_FieldPathSelector {
   152  	return fp.selector
   153  }
   154  
   155  // String returns path representation in proto convention
   156  func (fp *Point_FieldTerminalPath) String() string {
   157  	return fp.selector.String()
   158  }
   159  
   160  // JSONString returns path representation is JSON convention
   161  func (fp *Point_FieldTerminalPath) JSONString() string {
   162  	return strcase.ToLowerCamel(fp.String())
   163  }
   164  
   165  // Get returns all values pointed by specific field from source Point
   166  func (fp *Point_FieldTerminalPath) Get(source *Point) (values []interface{}) {
   167  	if source != nil {
   168  		switch fp.selector {
   169  		case Point_FieldPathSelectorInterval:
   170  			if source.Interval != nil {
   171  				values = append(values, source.Interval)
   172  			}
   173  		case Point_FieldPathSelectorValue:
   174  			if source.Value != nil {
   175  				values = append(values, source.Value)
   176  			}
   177  		case Point_FieldPathSelectorAggregation:
   178  			if source.Aggregation != nil {
   179  				values = append(values, source.Aggregation)
   180  			}
   181  		default:
   182  			panic(fmt.Sprintf("Invalid selector for Point: %d", fp.selector))
   183  		}
   184  	}
   185  	return
   186  }
   187  
   188  func (fp *Point_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
   189  	return fp.Get(source.(*Point))
   190  }
   191  
   192  // GetSingle returns value pointed by specific field of from source Point
   193  func (fp *Point_FieldTerminalPath) GetSingle(source *Point) (interface{}, bool) {
   194  	switch fp.selector {
   195  	case Point_FieldPathSelectorInterval:
   196  		res := source.GetInterval()
   197  		return res, res != nil
   198  	case Point_FieldPathSelectorValue:
   199  		res := source.GetValue()
   200  		return res, res != nil
   201  	case Point_FieldPathSelectorAggregation:
   202  		res := source.GetAggregation()
   203  		return res, res != nil
   204  	default:
   205  		panic(fmt.Sprintf("Invalid selector for Point: %d", fp.selector))
   206  	}
   207  }
   208  
   209  func (fp *Point_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
   210  	return fp.GetSingle(source.(*Point))
   211  }
   212  
   213  // GetDefault returns a default value of the field type
   214  func (fp *Point_FieldTerminalPath) GetDefault() interface{} {
   215  	switch fp.selector {
   216  	case Point_FieldPathSelectorInterval:
   217  		return (*common.TimeInterval)(nil)
   218  	case Point_FieldPathSelectorValue:
   219  		return (*common.TypedValue)(nil)
   220  	case Point_FieldPathSelectorAggregation:
   221  		return (*common.Aggregation)(nil)
   222  	default:
   223  		panic(fmt.Sprintf("Invalid selector for Point: %d", fp.selector))
   224  	}
   225  }
   226  
   227  func (fp *Point_FieldTerminalPath) ClearValue(item *Point) {
   228  	if item != nil {
   229  		switch fp.selector {
   230  		case Point_FieldPathSelectorInterval:
   231  			item.Interval = nil
   232  		case Point_FieldPathSelectorValue:
   233  			item.Value = nil
   234  		case Point_FieldPathSelectorAggregation:
   235  			item.Aggregation = nil
   236  		default:
   237  			panic(fmt.Sprintf("Invalid selector for Point: %d", fp.selector))
   238  		}
   239  	}
   240  }
   241  
   242  func (fp *Point_FieldTerminalPath) ClearValueRaw(item proto.Message) {
   243  	fp.ClearValue(item.(*Point))
   244  }
   245  
   246  // IsLeaf - whether field path is holds simple value
   247  func (fp *Point_FieldTerminalPath) IsLeaf() bool {
   248  	return false
   249  }
   250  
   251  func (fp *Point_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
   252  	return []gotenobject.FieldPath{fp}
   253  }
   254  
   255  func (fp *Point_FieldTerminalPath) WithIValue(value interface{}) Point_FieldPathValue {
   256  	switch fp.selector {
   257  	case Point_FieldPathSelectorInterval:
   258  		return &Point_FieldTerminalPathValue{Point_FieldTerminalPath: *fp, value: value.(*common.TimeInterval)}
   259  	case Point_FieldPathSelectorValue:
   260  		return &Point_FieldTerminalPathValue{Point_FieldTerminalPath: *fp, value: value.(*common.TypedValue)}
   261  	case Point_FieldPathSelectorAggregation:
   262  		return &Point_FieldTerminalPathValue{Point_FieldTerminalPath: *fp, value: value.(*common.Aggregation)}
   263  	default:
   264  		panic(fmt.Sprintf("Invalid selector for Point: %d", fp.selector))
   265  	}
   266  }
   267  
   268  func (fp *Point_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
   269  	return fp.WithIValue(value)
   270  }
   271  
   272  func (fp *Point_FieldTerminalPath) WithIArrayOfValues(values interface{}) Point_FieldPathArrayOfValues {
   273  	fpaov := &Point_FieldTerminalPathArrayOfValues{Point_FieldTerminalPath: *fp}
   274  	switch fp.selector {
   275  	case Point_FieldPathSelectorInterval:
   276  		return &Point_FieldTerminalPathArrayOfValues{Point_FieldTerminalPath: *fp, values: values.([]*common.TimeInterval)}
   277  	case Point_FieldPathSelectorValue:
   278  		return &Point_FieldTerminalPathArrayOfValues{Point_FieldTerminalPath: *fp, values: values.([]*common.TypedValue)}
   279  	case Point_FieldPathSelectorAggregation:
   280  		return &Point_FieldTerminalPathArrayOfValues{Point_FieldTerminalPath: *fp, values: values.([]*common.Aggregation)}
   281  	default:
   282  		panic(fmt.Sprintf("Invalid selector for Point: %d", fp.selector))
   283  	}
   284  	return fpaov
   285  }
   286  
   287  func (fp *Point_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
   288  	return fp.WithIArrayOfValues(values)
   289  }
   290  
   291  func (fp *Point_FieldTerminalPath) WithIArrayItemValue(value interface{}) Point_FieldPathArrayItemValue {
   292  	switch fp.selector {
   293  	default:
   294  		panic(fmt.Sprintf("Invalid selector for Point: %d", fp.selector))
   295  	}
   296  }
   297  
   298  func (fp *Point_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
   299  	return fp.WithIArrayItemValue(value)
   300  }
   301  
   302  type Point_FieldSubPath struct {
   303  	selector Point_FieldPathSelector
   304  	subPath  gotenobject.FieldPath
   305  }
   306  
   307  var _ Point_FieldPath = (*Point_FieldSubPath)(nil)
   308  
   309  func (fps *Point_FieldSubPath) Selector() Point_FieldPathSelector {
   310  	return fps.selector
   311  }
   312  func (fps *Point_FieldSubPath) AsIntervalSubPath() (common.TimeInterval_FieldPath, bool) {
   313  	res, ok := fps.subPath.(common.TimeInterval_FieldPath)
   314  	return res, ok
   315  }
   316  func (fps *Point_FieldSubPath) AsValueSubPath() (common.TypedValue_FieldPath, bool) {
   317  	res, ok := fps.subPath.(common.TypedValue_FieldPath)
   318  	return res, ok
   319  }
   320  func (fps *Point_FieldSubPath) AsAggregationSubPath() (common.Aggregation_FieldPath, bool) {
   321  	res, ok := fps.subPath.(common.Aggregation_FieldPath)
   322  	return res, ok
   323  }
   324  
   325  // String returns path representation in proto convention
   326  func (fps *Point_FieldSubPath) String() string {
   327  	return fps.selector.String() + "." + fps.subPath.String()
   328  }
   329  
   330  // JSONString returns path representation is JSON convention
   331  func (fps *Point_FieldSubPath) JSONString() string {
   332  	return strcase.ToLowerCamel(fps.selector.String()) + "." + fps.subPath.JSONString()
   333  }
   334  
   335  // Get returns all values pointed by selected field from source Point
   336  func (fps *Point_FieldSubPath) Get(source *Point) (values []interface{}) {
   337  	switch fps.selector {
   338  	case Point_FieldPathSelectorInterval:
   339  		values = append(values, fps.subPath.GetRaw(source.GetInterval())...)
   340  	case Point_FieldPathSelectorValue:
   341  		values = append(values, fps.subPath.GetRaw(source.GetValue())...)
   342  	case Point_FieldPathSelectorAggregation:
   343  		values = append(values, fps.subPath.GetRaw(source.GetAggregation())...)
   344  	default:
   345  		panic(fmt.Sprintf("Invalid selector for Point: %d", fps.selector))
   346  	}
   347  	return
   348  }
   349  
   350  func (fps *Point_FieldSubPath) GetRaw(source proto.Message) []interface{} {
   351  	return fps.Get(source.(*Point))
   352  }
   353  
   354  // GetSingle returns value of selected field from source Point
   355  func (fps *Point_FieldSubPath) GetSingle(source *Point) (interface{}, bool) {
   356  	switch fps.selector {
   357  	case Point_FieldPathSelectorInterval:
   358  		if source.GetInterval() == nil {
   359  			return nil, false
   360  		}
   361  		return fps.subPath.GetSingleRaw(source.GetInterval())
   362  	case Point_FieldPathSelectorValue:
   363  		if source.GetValue() == nil {
   364  			return nil, false
   365  		}
   366  		return fps.subPath.GetSingleRaw(source.GetValue())
   367  	case Point_FieldPathSelectorAggregation:
   368  		if source.GetAggregation() == nil {
   369  			return nil, false
   370  		}
   371  		return fps.subPath.GetSingleRaw(source.GetAggregation())
   372  	default:
   373  		panic(fmt.Sprintf("Invalid selector for Point: %d", fps.selector))
   374  	}
   375  }
   376  
   377  func (fps *Point_FieldSubPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
   378  	return fps.GetSingle(source.(*Point))
   379  }
   380  
   381  // GetDefault returns a default value of the field type
   382  func (fps *Point_FieldSubPath) GetDefault() interface{} {
   383  	return fps.subPath.GetDefault()
   384  }
   385  
   386  func (fps *Point_FieldSubPath) ClearValue(item *Point) {
   387  	if item != nil {
   388  		switch fps.selector {
   389  		case Point_FieldPathSelectorInterval:
   390  			fps.subPath.ClearValueRaw(item.Interval)
   391  		case Point_FieldPathSelectorValue:
   392  			fps.subPath.ClearValueRaw(item.Value)
   393  		case Point_FieldPathSelectorAggregation:
   394  			fps.subPath.ClearValueRaw(item.Aggregation)
   395  		default:
   396  			panic(fmt.Sprintf("Invalid selector for Point: %d", fps.selector))
   397  		}
   398  	}
   399  }
   400  
   401  func (fps *Point_FieldSubPath) ClearValueRaw(item proto.Message) {
   402  	fps.ClearValue(item.(*Point))
   403  }
   404  
   405  // IsLeaf - whether field path is holds simple value
   406  func (fps *Point_FieldSubPath) IsLeaf() bool {
   407  	return fps.subPath.IsLeaf()
   408  }
   409  
   410  func (fps *Point_FieldSubPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
   411  	iPaths := []gotenobject.FieldPath{&Point_FieldTerminalPath{selector: fps.selector}}
   412  	iPaths = append(iPaths, fps.subPath.SplitIntoTerminalIPaths()...)
   413  	return iPaths
   414  }
   415  
   416  func (fps *Point_FieldSubPath) WithIValue(value interface{}) Point_FieldPathValue {
   417  	return &Point_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
   418  }
   419  
   420  func (fps *Point_FieldSubPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
   421  	return fps.WithIValue(value)
   422  }
   423  
   424  func (fps *Point_FieldSubPath) WithIArrayOfValues(values interface{}) Point_FieldPathArrayOfValues {
   425  	return &Point_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
   426  }
   427  
   428  func (fps *Point_FieldSubPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
   429  	return fps.WithIArrayOfValues(values)
   430  }
   431  
   432  func (fps *Point_FieldSubPath) WithIArrayItemValue(value interface{}) Point_FieldPathArrayItemValue {
   433  	return &Point_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
   434  }
   435  
   436  func (fps *Point_FieldSubPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
   437  	return fps.WithIArrayItemValue(value)
   438  }
   439  
   440  // Point_FieldPathValue allows storing values for Point fields according to their type
   441  type Point_FieldPathValue interface {
   442  	Point_FieldPath
   443  	gotenobject.FieldPathValue
   444  	SetTo(target **Point)
   445  	CompareWith(*Point) (cmp int, comparable bool)
   446  }
   447  
   448  func ParsePoint_FieldPathValue(pathStr, valueStr string) (Point_FieldPathValue, error) {
   449  	fp, err := ParsePoint_FieldPath(pathStr)
   450  	if err != nil {
   451  		return nil, err
   452  	}
   453  	fpv, err := gotenobject.ParseFieldPathValue(fp, valueStr)
   454  	if err != nil {
   455  		return nil, status.Errorf(codes.InvalidArgument, "error parsing Point field path value from %s: %v", valueStr, err)
   456  	}
   457  	return fpv.(Point_FieldPathValue), nil
   458  }
   459  
   460  func MustParsePoint_FieldPathValue(pathStr, valueStr string) Point_FieldPathValue {
   461  	fpv, err := ParsePoint_FieldPathValue(pathStr, valueStr)
   462  	if err != nil {
   463  		panic(err)
   464  	}
   465  	return fpv
   466  }
   467  
   468  type Point_FieldTerminalPathValue struct {
   469  	Point_FieldTerminalPath
   470  	value interface{}
   471  }
   472  
   473  var _ Point_FieldPathValue = (*Point_FieldTerminalPathValue)(nil)
   474  
   475  // GetRawValue returns raw value stored under selected path for 'Point' as interface{}
   476  func (fpv *Point_FieldTerminalPathValue) GetRawValue() interface{} {
   477  	return fpv.value
   478  }
   479  func (fpv *Point_FieldTerminalPathValue) AsIntervalValue() (*common.TimeInterval, bool) {
   480  	res, ok := fpv.value.(*common.TimeInterval)
   481  	return res, ok
   482  }
   483  func (fpv *Point_FieldTerminalPathValue) AsValueValue() (*common.TypedValue, bool) {
   484  	res, ok := fpv.value.(*common.TypedValue)
   485  	return res, ok
   486  }
   487  func (fpv *Point_FieldTerminalPathValue) AsAggregationValue() (*common.Aggregation, bool) {
   488  	res, ok := fpv.value.(*common.Aggregation)
   489  	return res, ok
   490  }
   491  
   492  // SetTo stores value for selected field for object Point
   493  func (fpv *Point_FieldTerminalPathValue) SetTo(target **Point) {
   494  	if *target == nil {
   495  		*target = new(Point)
   496  	}
   497  	switch fpv.selector {
   498  	case Point_FieldPathSelectorInterval:
   499  		(*target).Interval = fpv.value.(*common.TimeInterval)
   500  	case Point_FieldPathSelectorValue:
   501  		(*target).Value = fpv.value.(*common.TypedValue)
   502  	case Point_FieldPathSelectorAggregation:
   503  		(*target).Aggregation = fpv.value.(*common.Aggregation)
   504  	default:
   505  		panic(fmt.Sprintf("Invalid selector for Point: %d", fpv.selector))
   506  	}
   507  }
   508  
   509  func (fpv *Point_FieldTerminalPathValue) SetToRaw(target proto.Message) {
   510  	typedObject := target.(*Point)
   511  	fpv.SetTo(&typedObject)
   512  }
   513  
   514  // CompareWith compares value in the 'Point_FieldTerminalPathValue' with the value under path in 'Point'.
   515  func (fpv *Point_FieldTerminalPathValue) CompareWith(source *Point) (int, bool) {
   516  	switch fpv.selector {
   517  	case Point_FieldPathSelectorInterval:
   518  		return 0, false
   519  	case Point_FieldPathSelectorValue:
   520  		return 0, false
   521  	case Point_FieldPathSelectorAggregation:
   522  		return 0, false
   523  	default:
   524  		panic(fmt.Sprintf("Invalid selector for Point: %d", fpv.selector))
   525  	}
   526  }
   527  
   528  func (fpv *Point_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
   529  	return fpv.CompareWith(source.(*Point))
   530  }
   531  
   532  type Point_FieldSubPathValue struct {
   533  	Point_FieldPath
   534  	subPathValue gotenobject.FieldPathValue
   535  }
   536  
   537  var _ Point_FieldPathValue = (*Point_FieldSubPathValue)(nil)
   538  
   539  func (fpvs *Point_FieldSubPathValue) AsIntervalPathValue() (common.TimeInterval_FieldPathValue, bool) {
   540  	res, ok := fpvs.subPathValue.(common.TimeInterval_FieldPathValue)
   541  	return res, ok
   542  }
   543  func (fpvs *Point_FieldSubPathValue) AsValuePathValue() (common.TypedValue_FieldPathValue, bool) {
   544  	res, ok := fpvs.subPathValue.(common.TypedValue_FieldPathValue)
   545  	return res, ok
   546  }
   547  func (fpvs *Point_FieldSubPathValue) AsAggregationPathValue() (common.Aggregation_FieldPathValue, bool) {
   548  	res, ok := fpvs.subPathValue.(common.Aggregation_FieldPathValue)
   549  	return res, ok
   550  }
   551  
   552  func (fpvs *Point_FieldSubPathValue) SetTo(target **Point) {
   553  	if *target == nil {
   554  		*target = new(Point)
   555  	}
   556  	switch fpvs.Selector() {
   557  	case Point_FieldPathSelectorInterval:
   558  		fpvs.subPathValue.(common.TimeInterval_FieldPathValue).SetTo(&(*target).Interval)
   559  	case Point_FieldPathSelectorValue:
   560  		fpvs.subPathValue.(common.TypedValue_FieldPathValue).SetTo(&(*target).Value)
   561  	case Point_FieldPathSelectorAggregation:
   562  		fpvs.subPathValue.(common.Aggregation_FieldPathValue).SetTo(&(*target).Aggregation)
   563  	default:
   564  		panic(fmt.Sprintf("Invalid selector for Point: %d", fpvs.Selector()))
   565  	}
   566  }
   567  
   568  func (fpvs *Point_FieldSubPathValue) SetToRaw(target proto.Message) {
   569  	typedObject := target.(*Point)
   570  	fpvs.SetTo(&typedObject)
   571  }
   572  
   573  func (fpvs *Point_FieldSubPathValue) GetRawValue() interface{} {
   574  	return fpvs.subPathValue.GetRawValue()
   575  }
   576  
   577  func (fpvs *Point_FieldSubPathValue) CompareWith(source *Point) (int, bool) {
   578  	switch fpvs.Selector() {
   579  	case Point_FieldPathSelectorInterval:
   580  		return fpvs.subPathValue.(common.TimeInterval_FieldPathValue).CompareWith(source.GetInterval())
   581  	case Point_FieldPathSelectorValue:
   582  		return fpvs.subPathValue.(common.TypedValue_FieldPathValue).CompareWith(source.GetValue())
   583  	case Point_FieldPathSelectorAggregation:
   584  		return fpvs.subPathValue.(common.Aggregation_FieldPathValue).CompareWith(source.GetAggregation())
   585  	default:
   586  		panic(fmt.Sprintf("Invalid selector for Point: %d", fpvs.Selector()))
   587  	}
   588  }
   589  
   590  func (fpvs *Point_FieldSubPathValue) CompareWithRaw(source proto.Message) (int, bool) {
   591  	return fpvs.CompareWith(source.(*Point))
   592  }
   593  
   594  // Point_FieldPathArrayItemValue allows storing single item in Path-specific values for Point according to their type
   595  // Present only for array (repeated) types.
   596  type Point_FieldPathArrayItemValue interface {
   597  	gotenobject.FieldPathArrayItemValue
   598  	Point_FieldPath
   599  	ContainsValue(*Point) bool
   600  }
   601  
   602  // ParsePoint_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
   603  func ParsePoint_FieldPathArrayItemValue(pathStr, valueStr string) (Point_FieldPathArrayItemValue, error) {
   604  	fp, err := ParsePoint_FieldPath(pathStr)
   605  	if err != nil {
   606  		return nil, err
   607  	}
   608  	fpaiv, err := gotenobject.ParseFieldPathArrayItemValue(fp, valueStr)
   609  	if err != nil {
   610  		return nil, status.Errorf(codes.InvalidArgument, "error parsing Point field path array item value from %s: %v", valueStr, err)
   611  	}
   612  	return fpaiv.(Point_FieldPathArrayItemValue), nil
   613  }
   614  
   615  func MustParsePoint_FieldPathArrayItemValue(pathStr, valueStr string) Point_FieldPathArrayItemValue {
   616  	fpaiv, err := ParsePoint_FieldPathArrayItemValue(pathStr, valueStr)
   617  	if err != nil {
   618  		panic(err)
   619  	}
   620  	return fpaiv
   621  }
   622  
   623  type Point_FieldTerminalPathArrayItemValue struct {
   624  	Point_FieldTerminalPath
   625  	value interface{}
   626  }
   627  
   628  var _ Point_FieldPathArrayItemValue = (*Point_FieldTerminalPathArrayItemValue)(nil)
   629  
   630  // GetRawValue returns stored element value for array in object Point as interface{}
   631  func (fpaiv *Point_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
   632  	return fpaiv.value
   633  }
   634  
   635  func (fpaiv *Point_FieldTerminalPathArrayItemValue) GetSingle(source *Point) (interface{}, bool) {
   636  	return nil, false
   637  }
   638  
   639  func (fpaiv *Point_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
   640  	return fpaiv.GetSingle(source.(*Point))
   641  }
   642  
   643  // Contains returns a boolean indicating if value that is being held is present in given 'Point'
   644  func (fpaiv *Point_FieldTerminalPathArrayItemValue) ContainsValue(source *Point) bool {
   645  	slice := fpaiv.Point_FieldTerminalPath.Get(source)
   646  	for _, v := range slice {
   647  		if asProtoMsg, ok := fpaiv.value.(proto.Message); ok {
   648  			if proto.Equal(asProtoMsg, v.(proto.Message)) {
   649  				return true
   650  			}
   651  		} else if reflect.DeepEqual(v, fpaiv.value) {
   652  			return true
   653  		}
   654  	}
   655  	return false
   656  }
   657  
   658  type Point_FieldSubPathArrayItemValue struct {
   659  	Point_FieldPath
   660  	subPathItemValue gotenobject.FieldPathArrayItemValue
   661  }
   662  
   663  // GetRawValue returns stored array item value
   664  func (fpaivs *Point_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
   665  	return fpaivs.subPathItemValue.GetRawItemValue()
   666  }
   667  func (fpaivs *Point_FieldSubPathArrayItemValue) AsIntervalPathItemValue() (common.TimeInterval_FieldPathArrayItemValue, bool) {
   668  	res, ok := fpaivs.subPathItemValue.(common.TimeInterval_FieldPathArrayItemValue)
   669  	return res, ok
   670  }
   671  func (fpaivs *Point_FieldSubPathArrayItemValue) AsValuePathItemValue() (common.TypedValue_FieldPathArrayItemValue, bool) {
   672  	res, ok := fpaivs.subPathItemValue.(common.TypedValue_FieldPathArrayItemValue)
   673  	return res, ok
   674  }
   675  func (fpaivs *Point_FieldSubPathArrayItemValue) AsAggregationPathItemValue() (common.Aggregation_FieldPathArrayItemValue, bool) {
   676  	res, ok := fpaivs.subPathItemValue.(common.Aggregation_FieldPathArrayItemValue)
   677  	return res, ok
   678  }
   679  
   680  // Contains returns a boolean indicating if value that is being held is present in given 'Point'
   681  func (fpaivs *Point_FieldSubPathArrayItemValue) ContainsValue(source *Point) bool {
   682  	switch fpaivs.Selector() {
   683  	case Point_FieldPathSelectorInterval:
   684  		return fpaivs.subPathItemValue.(common.TimeInterval_FieldPathArrayItemValue).ContainsValue(source.GetInterval())
   685  	case Point_FieldPathSelectorValue:
   686  		return fpaivs.subPathItemValue.(common.TypedValue_FieldPathArrayItemValue).ContainsValue(source.GetValue())
   687  	case Point_FieldPathSelectorAggregation:
   688  		return fpaivs.subPathItemValue.(common.Aggregation_FieldPathArrayItemValue).ContainsValue(source.GetAggregation())
   689  	default:
   690  		panic(fmt.Sprintf("Invalid selector for Point: %d", fpaivs.Selector()))
   691  	}
   692  }
   693  
   694  // Point_FieldPathArrayOfValues allows storing slice of values for Point fields according to their type
   695  type Point_FieldPathArrayOfValues interface {
   696  	gotenobject.FieldPathArrayOfValues
   697  	Point_FieldPath
   698  }
   699  
   700  func ParsePoint_FieldPathArrayOfValues(pathStr, valuesStr string) (Point_FieldPathArrayOfValues, error) {
   701  	fp, err := ParsePoint_FieldPath(pathStr)
   702  	if err != nil {
   703  		return nil, err
   704  	}
   705  	fpaov, err := gotenobject.ParseFieldPathArrayOfValues(fp, valuesStr)
   706  	if err != nil {
   707  		return nil, status.Errorf(codes.InvalidArgument, "error parsing Point field path array of values from %s: %v", valuesStr, err)
   708  	}
   709  	return fpaov.(Point_FieldPathArrayOfValues), nil
   710  }
   711  
   712  func MustParsePoint_FieldPathArrayOfValues(pathStr, valuesStr string) Point_FieldPathArrayOfValues {
   713  	fpaov, err := ParsePoint_FieldPathArrayOfValues(pathStr, valuesStr)
   714  	if err != nil {
   715  		panic(err)
   716  	}
   717  	return fpaov
   718  }
   719  
   720  type Point_FieldTerminalPathArrayOfValues struct {
   721  	Point_FieldTerminalPath
   722  	values interface{}
   723  }
   724  
   725  var _ Point_FieldPathArrayOfValues = (*Point_FieldTerminalPathArrayOfValues)(nil)
   726  
   727  func (fpaov *Point_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
   728  	switch fpaov.selector {
   729  	case Point_FieldPathSelectorInterval:
   730  		for _, v := range fpaov.values.([]*common.TimeInterval) {
   731  			values = append(values, v)
   732  		}
   733  	case Point_FieldPathSelectorValue:
   734  		for _, v := range fpaov.values.([]*common.TypedValue) {
   735  			values = append(values, v)
   736  		}
   737  	case Point_FieldPathSelectorAggregation:
   738  		for _, v := range fpaov.values.([]*common.Aggregation) {
   739  			values = append(values, v)
   740  		}
   741  	}
   742  	return
   743  }
   744  func (fpaov *Point_FieldTerminalPathArrayOfValues) AsIntervalArrayOfValues() ([]*common.TimeInterval, bool) {
   745  	res, ok := fpaov.values.([]*common.TimeInterval)
   746  	return res, ok
   747  }
   748  func (fpaov *Point_FieldTerminalPathArrayOfValues) AsValueArrayOfValues() ([]*common.TypedValue, bool) {
   749  	res, ok := fpaov.values.([]*common.TypedValue)
   750  	return res, ok
   751  }
   752  func (fpaov *Point_FieldTerminalPathArrayOfValues) AsAggregationArrayOfValues() ([]*common.Aggregation, bool) {
   753  	res, ok := fpaov.values.([]*common.Aggregation)
   754  	return res, ok
   755  }
   756  
   757  type Point_FieldSubPathArrayOfValues struct {
   758  	Point_FieldPath
   759  	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
   760  }
   761  
   762  var _ Point_FieldPathArrayOfValues = (*Point_FieldSubPathArrayOfValues)(nil)
   763  
   764  func (fpsaov *Point_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
   765  	return fpsaov.subPathArrayOfValues.GetRawValues()
   766  }
   767  func (fpsaov *Point_FieldSubPathArrayOfValues) AsIntervalPathArrayOfValues() (common.TimeInterval_FieldPathArrayOfValues, bool) {
   768  	res, ok := fpsaov.subPathArrayOfValues.(common.TimeInterval_FieldPathArrayOfValues)
   769  	return res, ok
   770  }
   771  func (fpsaov *Point_FieldSubPathArrayOfValues) AsValuePathArrayOfValues() (common.TypedValue_FieldPathArrayOfValues, bool) {
   772  	res, ok := fpsaov.subPathArrayOfValues.(common.TypedValue_FieldPathArrayOfValues)
   773  	return res, ok
   774  }
   775  func (fpsaov *Point_FieldSubPathArrayOfValues) AsAggregationPathArrayOfValues() (common.Aggregation_FieldPathArrayOfValues, bool) {
   776  	res, ok := fpsaov.subPathArrayOfValues.(common.Aggregation_FieldPathArrayOfValues)
   777  	return res, ok
   778  }
   779  
   780  // FieldPath provides implementation to handle
   781  // https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
   782  type TimeSerie_FieldPath interface {
   783  	gotenobject.FieldPath
   784  	Selector() TimeSerie_FieldPathSelector
   785  	Get(source *TimeSerie) []interface{}
   786  	GetSingle(source *TimeSerie) (interface{}, bool)
   787  	ClearValue(item *TimeSerie)
   788  
   789  	// Those methods build corresponding TimeSerie_FieldPathValue
   790  	// (or array of values) and holds passed value. Panics if injected type is incorrect.
   791  	WithIValue(value interface{}) TimeSerie_FieldPathValue
   792  	WithIArrayOfValues(values interface{}) TimeSerie_FieldPathArrayOfValues
   793  	WithIArrayItemValue(value interface{}) TimeSerie_FieldPathArrayItemValue
   794  }
   795  
   796  type TimeSerie_FieldPathSelector int32
   797  
   798  const (
   799  	TimeSerie_FieldPathSelectorKey        TimeSerie_FieldPathSelector = 0
   800  	TimeSerie_FieldPathSelectorProject    TimeSerie_FieldPathSelector = 1
   801  	TimeSerie_FieldPathSelectorRegion     TimeSerie_FieldPathSelector = 2
   802  	TimeSerie_FieldPathSelectorMetric     TimeSerie_FieldPathSelector = 3
   803  	TimeSerie_FieldPathSelectorResource   TimeSerie_FieldPathSelector = 4
   804  	TimeSerie_FieldPathSelectorMetricKind TimeSerie_FieldPathSelector = 5
   805  	TimeSerie_FieldPathSelectorValueType  TimeSerie_FieldPathSelector = 6
   806  	TimeSerie_FieldPathSelectorPoints     TimeSerie_FieldPathSelector = 7
   807  )
   808  
   809  func (s TimeSerie_FieldPathSelector) String() string {
   810  	switch s {
   811  	case TimeSerie_FieldPathSelectorKey:
   812  		return "key"
   813  	case TimeSerie_FieldPathSelectorProject:
   814  		return "project"
   815  	case TimeSerie_FieldPathSelectorRegion:
   816  		return "region"
   817  	case TimeSerie_FieldPathSelectorMetric:
   818  		return "metric"
   819  	case TimeSerie_FieldPathSelectorResource:
   820  		return "resource"
   821  	case TimeSerie_FieldPathSelectorMetricKind:
   822  		return "metric_kind"
   823  	case TimeSerie_FieldPathSelectorValueType:
   824  		return "value_type"
   825  	case TimeSerie_FieldPathSelectorPoints:
   826  		return "points"
   827  	default:
   828  		panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", s))
   829  	}
   830  }
   831  
   832  func BuildTimeSerie_FieldPath(fp gotenobject.RawFieldPath) (TimeSerie_FieldPath, error) {
   833  	if len(fp) == 0 {
   834  		return nil, status.Error(codes.InvalidArgument, "empty field path for object TimeSerie")
   835  	}
   836  	if len(fp) == 1 {
   837  		switch fp[0] {
   838  		case "key":
   839  			return &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorKey}, nil
   840  		case "project":
   841  			return &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorProject}, nil
   842  		case "region":
   843  			return &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorRegion}, nil
   844  		case "metric":
   845  			return &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorMetric}, nil
   846  		case "resource":
   847  			return &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorResource}, nil
   848  		case "metric_kind", "metricKind", "metric-kind":
   849  			return &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorMetricKind}, nil
   850  		case "value_type", "valueType", "value-type":
   851  			return &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorValueType}, nil
   852  		case "points":
   853  			return &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorPoints}, nil
   854  		}
   855  	} else {
   856  		switch fp[0] {
   857  		case "metric":
   858  			if subpath, err := common.BuildMetric_FieldPath(fp[1:]); err != nil {
   859  				return nil, err
   860  			} else {
   861  				return &TimeSerie_FieldSubPath{selector: TimeSerie_FieldPathSelectorMetric, subPath: subpath}, nil
   862  			}
   863  		case "resource":
   864  			if subpath, err := common.BuildMonitoredResource_FieldPath(fp[1:]); err != nil {
   865  				return nil, err
   866  			} else {
   867  				return &TimeSerie_FieldSubPath{selector: TimeSerie_FieldPathSelectorResource, subPath: subpath}, nil
   868  			}
   869  		case "points":
   870  			if subpath, err := BuildPoint_FieldPath(fp[1:]); err != nil {
   871  				return nil, err
   872  			} else {
   873  				return &TimeSerie_FieldSubPath{selector: TimeSerie_FieldPathSelectorPoints, subPath: subpath}, nil
   874  			}
   875  		}
   876  	}
   877  	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object TimeSerie", fp)
   878  }
   879  
   880  func ParseTimeSerie_FieldPath(rawField string) (TimeSerie_FieldPath, error) {
   881  	fp, err := gotenobject.ParseRawFieldPath(rawField)
   882  	if err != nil {
   883  		return nil, err
   884  	}
   885  	return BuildTimeSerie_FieldPath(fp)
   886  }
   887  
   888  func MustParseTimeSerie_FieldPath(rawField string) TimeSerie_FieldPath {
   889  	fp, err := ParseTimeSerie_FieldPath(rawField)
   890  	if err != nil {
   891  		panic(err)
   892  	}
   893  	return fp
   894  }
   895  
   896  type TimeSerie_FieldTerminalPath struct {
   897  	selector TimeSerie_FieldPathSelector
   898  }
   899  
   900  var _ TimeSerie_FieldPath = (*TimeSerie_FieldTerminalPath)(nil)
   901  
   902  func (fp *TimeSerie_FieldTerminalPath) Selector() TimeSerie_FieldPathSelector {
   903  	return fp.selector
   904  }
   905  
   906  // String returns path representation in proto convention
   907  func (fp *TimeSerie_FieldTerminalPath) String() string {
   908  	return fp.selector.String()
   909  }
   910  
   911  // JSONString returns path representation is JSON convention
   912  func (fp *TimeSerie_FieldTerminalPath) JSONString() string {
   913  	return strcase.ToLowerCamel(fp.String())
   914  }
   915  
   916  // Get returns all values pointed by specific field from source TimeSerie
   917  func (fp *TimeSerie_FieldTerminalPath) Get(source *TimeSerie) (values []interface{}) {
   918  	if source != nil {
   919  		switch fp.selector {
   920  		case TimeSerie_FieldPathSelectorKey:
   921  			values = append(values, source.Key)
   922  		case TimeSerie_FieldPathSelectorProject:
   923  			values = append(values, source.Project)
   924  		case TimeSerie_FieldPathSelectorRegion:
   925  			values = append(values, source.Region)
   926  		case TimeSerie_FieldPathSelectorMetric:
   927  			if source.Metric != nil {
   928  				values = append(values, source.Metric)
   929  			}
   930  		case TimeSerie_FieldPathSelectorResource:
   931  			if source.Resource != nil {
   932  				values = append(values, source.Resource)
   933  			}
   934  		case TimeSerie_FieldPathSelectorMetricKind:
   935  			values = append(values, source.MetricKind)
   936  		case TimeSerie_FieldPathSelectorValueType:
   937  			values = append(values, source.ValueType)
   938  		case TimeSerie_FieldPathSelectorPoints:
   939  			for _, value := range source.GetPoints() {
   940  				values = append(values, value)
   941  			}
   942  		default:
   943  			panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fp.selector))
   944  		}
   945  	}
   946  	return
   947  }
   948  
   949  func (fp *TimeSerie_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
   950  	return fp.Get(source.(*TimeSerie))
   951  }
   952  
   953  // GetSingle returns value pointed by specific field of from source TimeSerie
   954  func (fp *TimeSerie_FieldTerminalPath) GetSingle(source *TimeSerie) (interface{}, bool) {
   955  	switch fp.selector {
   956  	case TimeSerie_FieldPathSelectorKey:
   957  		res := source.GetKey()
   958  		return res, res != nil
   959  	case TimeSerie_FieldPathSelectorProject:
   960  		return source.GetProject(), source != nil
   961  	case TimeSerie_FieldPathSelectorRegion:
   962  		return source.GetRegion(), source != nil
   963  	case TimeSerie_FieldPathSelectorMetric:
   964  		res := source.GetMetric()
   965  		return res, res != nil
   966  	case TimeSerie_FieldPathSelectorResource:
   967  		res := source.GetResource()
   968  		return res, res != nil
   969  	case TimeSerie_FieldPathSelectorMetricKind:
   970  		return source.GetMetricKind(), source != nil
   971  	case TimeSerie_FieldPathSelectorValueType:
   972  		return source.GetValueType(), source != nil
   973  	case TimeSerie_FieldPathSelectorPoints:
   974  		res := source.GetPoints()
   975  		return res, res != nil
   976  	default:
   977  		panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fp.selector))
   978  	}
   979  }
   980  
   981  func (fp *TimeSerie_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
   982  	return fp.GetSingle(source.(*TimeSerie))
   983  }
   984  
   985  // GetDefault returns a default value of the field type
   986  func (fp *TimeSerie_FieldTerminalPath) GetDefault() interface{} {
   987  	switch fp.selector {
   988  	case TimeSerie_FieldPathSelectorKey:
   989  		return ([]byte)(nil)
   990  	case TimeSerie_FieldPathSelectorProject:
   991  		return ""
   992  	case TimeSerie_FieldPathSelectorRegion:
   993  		return ""
   994  	case TimeSerie_FieldPathSelectorMetric:
   995  		return (*common.Metric)(nil)
   996  	case TimeSerie_FieldPathSelectorResource:
   997  		return (*common.MonitoredResource)(nil)
   998  	case TimeSerie_FieldPathSelectorMetricKind:
   999  		return metric_descriptor.MetricDescriptor_METRIC_KIND_UNSPECIFIED
  1000  	case TimeSerie_FieldPathSelectorValueType:
  1001  		return metric_descriptor.MetricDescriptor_VALUE_TYPE_UNSPECIFIED
  1002  	case TimeSerie_FieldPathSelectorPoints:
  1003  		return ([]*Point)(nil)
  1004  	default:
  1005  		panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fp.selector))
  1006  	}
  1007  }
  1008  
  1009  func (fp *TimeSerie_FieldTerminalPath) ClearValue(item *TimeSerie) {
  1010  	if item != nil {
  1011  		switch fp.selector {
  1012  		case TimeSerie_FieldPathSelectorKey:
  1013  			item.Key = nil
  1014  		case TimeSerie_FieldPathSelectorProject:
  1015  			item.Project = ""
  1016  		case TimeSerie_FieldPathSelectorRegion:
  1017  			item.Region = ""
  1018  		case TimeSerie_FieldPathSelectorMetric:
  1019  			item.Metric = nil
  1020  		case TimeSerie_FieldPathSelectorResource:
  1021  			item.Resource = nil
  1022  		case TimeSerie_FieldPathSelectorMetricKind:
  1023  			item.MetricKind = metric_descriptor.MetricDescriptor_METRIC_KIND_UNSPECIFIED
  1024  		case TimeSerie_FieldPathSelectorValueType:
  1025  			item.ValueType = metric_descriptor.MetricDescriptor_VALUE_TYPE_UNSPECIFIED
  1026  		case TimeSerie_FieldPathSelectorPoints:
  1027  			item.Points = nil
  1028  		default:
  1029  			panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fp.selector))
  1030  		}
  1031  	}
  1032  }
  1033  
  1034  func (fp *TimeSerie_FieldTerminalPath) ClearValueRaw(item proto.Message) {
  1035  	fp.ClearValue(item.(*TimeSerie))
  1036  }
  1037  
  1038  // IsLeaf - whether field path is holds simple value
  1039  func (fp *TimeSerie_FieldTerminalPath) IsLeaf() bool {
  1040  	return fp.selector == TimeSerie_FieldPathSelectorKey ||
  1041  		fp.selector == TimeSerie_FieldPathSelectorProject ||
  1042  		fp.selector == TimeSerie_FieldPathSelectorRegion ||
  1043  		fp.selector == TimeSerie_FieldPathSelectorMetricKind ||
  1044  		fp.selector == TimeSerie_FieldPathSelectorValueType
  1045  }
  1046  
  1047  func (fp *TimeSerie_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
  1048  	return []gotenobject.FieldPath{fp}
  1049  }
  1050  
  1051  func (fp *TimeSerie_FieldTerminalPath) WithIValue(value interface{}) TimeSerie_FieldPathValue {
  1052  	switch fp.selector {
  1053  	case TimeSerie_FieldPathSelectorKey:
  1054  		return &TimeSerie_FieldTerminalPathValue{TimeSerie_FieldTerminalPath: *fp, value: value.([]byte)}
  1055  	case TimeSerie_FieldPathSelectorProject:
  1056  		return &TimeSerie_FieldTerminalPathValue{TimeSerie_FieldTerminalPath: *fp, value: value.(string)}
  1057  	case TimeSerie_FieldPathSelectorRegion:
  1058  		return &TimeSerie_FieldTerminalPathValue{TimeSerie_FieldTerminalPath: *fp, value: value.(string)}
  1059  	case TimeSerie_FieldPathSelectorMetric:
  1060  		return &TimeSerie_FieldTerminalPathValue{TimeSerie_FieldTerminalPath: *fp, value: value.(*common.Metric)}
  1061  	case TimeSerie_FieldPathSelectorResource:
  1062  		return &TimeSerie_FieldTerminalPathValue{TimeSerie_FieldTerminalPath: *fp, value: value.(*common.MonitoredResource)}
  1063  	case TimeSerie_FieldPathSelectorMetricKind:
  1064  		return &TimeSerie_FieldTerminalPathValue{TimeSerie_FieldTerminalPath: *fp, value: value.(metric_descriptor.MetricDescriptor_MetricKind)}
  1065  	case TimeSerie_FieldPathSelectorValueType:
  1066  		return &TimeSerie_FieldTerminalPathValue{TimeSerie_FieldTerminalPath: *fp, value: value.(metric_descriptor.MetricDescriptor_ValueType)}
  1067  	case TimeSerie_FieldPathSelectorPoints:
  1068  		return &TimeSerie_FieldTerminalPathValue{TimeSerie_FieldTerminalPath: *fp, value: value.([]*Point)}
  1069  	default:
  1070  		panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fp.selector))
  1071  	}
  1072  }
  1073  
  1074  func (fp *TimeSerie_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
  1075  	return fp.WithIValue(value)
  1076  }
  1077  
  1078  func (fp *TimeSerie_FieldTerminalPath) WithIArrayOfValues(values interface{}) TimeSerie_FieldPathArrayOfValues {
  1079  	fpaov := &TimeSerie_FieldTerminalPathArrayOfValues{TimeSerie_FieldTerminalPath: *fp}
  1080  	switch fp.selector {
  1081  	case TimeSerie_FieldPathSelectorKey:
  1082  		return &TimeSerie_FieldTerminalPathArrayOfValues{TimeSerie_FieldTerminalPath: *fp, values: values.([][]byte)}
  1083  	case TimeSerie_FieldPathSelectorProject:
  1084  		return &TimeSerie_FieldTerminalPathArrayOfValues{TimeSerie_FieldTerminalPath: *fp, values: values.([]string)}
  1085  	case TimeSerie_FieldPathSelectorRegion:
  1086  		return &TimeSerie_FieldTerminalPathArrayOfValues{TimeSerie_FieldTerminalPath: *fp, values: values.([]string)}
  1087  	case TimeSerie_FieldPathSelectorMetric:
  1088  		return &TimeSerie_FieldTerminalPathArrayOfValues{TimeSerie_FieldTerminalPath: *fp, values: values.([]*common.Metric)}
  1089  	case TimeSerie_FieldPathSelectorResource:
  1090  		return &TimeSerie_FieldTerminalPathArrayOfValues{TimeSerie_FieldTerminalPath: *fp, values: values.([]*common.MonitoredResource)}
  1091  	case TimeSerie_FieldPathSelectorMetricKind:
  1092  		return &TimeSerie_FieldTerminalPathArrayOfValues{TimeSerie_FieldTerminalPath: *fp, values: values.([]metric_descriptor.MetricDescriptor_MetricKind)}
  1093  	case TimeSerie_FieldPathSelectorValueType:
  1094  		return &TimeSerie_FieldTerminalPathArrayOfValues{TimeSerie_FieldTerminalPath: *fp, values: values.([]metric_descriptor.MetricDescriptor_ValueType)}
  1095  	case TimeSerie_FieldPathSelectorPoints:
  1096  		return &TimeSerie_FieldTerminalPathArrayOfValues{TimeSerie_FieldTerminalPath: *fp, values: values.([][]*Point)}
  1097  	default:
  1098  		panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fp.selector))
  1099  	}
  1100  	return fpaov
  1101  }
  1102  
  1103  func (fp *TimeSerie_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
  1104  	return fp.WithIArrayOfValues(values)
  1105  }
  1106  
  1107  func (fp *TimeSerie_FieldTerminalPath) WithIArrayItemValue(value interface{}) TimeSerie_FieldPathArrayItemValue {
  1108  	switch fp.selector {
  1109  	case TimeSerie_FieldPathSelectorPoints:
  1110  		return &TimeSerie_FieldTerminalPathArrayItemValue{TimeSerie_FieldTerminalPath: *fp, value: value.(*Point)}
  1111  	default:
  1112  		panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fp.selector))
  1113  	}
  1114  }
  1115  
  1116  func (fp *TimeSerie_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
  1117  	return fp.WithIArrayItemValue(value)
  1118  }
  1119  
  1120  type TimeSerie_FieldSubPath struct {
  1121  	selector TimeSerie_FieldPathSelector
  1122  	subPath  gotenobject.FieldPath
  1123  }
  1124  
  1125  var _ TimeSerie_FieldPath = (*TimeSerie_FieldSubPath)(nil)
  1126  
  1127  func (fps *TimeSerie_FieldSubPath) Selector() TimeSerie_FieldPathSelector {
  1128  	return fps.selector
  1129  }
  1130  func (fps *TimeSerie_FieldSubPath) AsMetricSubPath() (common.Metric_FieldPath, bool) {
  1131  	res, ok := fps.subPath.(common.Metric_FieldPath)
  1132  	return res, ok
  1133  }
  1134  func (fps *TimeSerie_FieldSubPath) AsResourceSubPath() (common.MonitoredResource_FieldPath, bool) {
  1135  	res, ok := fps.subPath.(common.MonitoredResource_FieldPath)
  1136  	return res, ok
  1137  }
  1138  func (fps *TimeSerie_FieldSubPath) AsPointsSubPath() (Point_FieldPath, bool) {
  1139  	res, ok := fps.subPath.(Point_FieldPath)
  1140  	return res, ok
  1141  }
  1142  
  1143  // String returns path representation in proto convention
  1144  func (fps *TimeSerie_FieldSubPath) String() string {
  1145  	return fps.selector.String() + "." + fps.subPath.String()
  1146  }
  1147  
  1148  // JSONString returns path representation is JSON convention
  1149  func (fps *TimeSerie_FieldSubPath) JSONString() string {
  1150  	return strcase.ToLowerCamel(fps.selector.String()) + "." + fps.subPath.JSONString()
  1151  }
  1152  
  1153  // Get returns all values pointed by selected field from source TimeSerie
  1154  func (fps *TimeSerie_FieldSubPath) Get(source *TimeSerie) (values []interface{}) {
  1155  	switch fps.selector {
  1156  	case TimeSerie_FieldPathSelectorMetric:
  1157  		values = append(values, fps.subPath.GetRaw(source.GetMetric())...)
  1158  	case TimeSerie_FieldPathSelectorResource:
  1159  		values = append(values, fps.subPath.GetRaw(source.GetResource())...)
  1160  	case TimeSerie_FieldPathSelectorPoints:
  1161  		for _, item := range source.GetPoints() {
  1162  			values = append(values, fps.subPath.GetRaw(item)...)
  1163  		}
  1164  	default:
  1165  		panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fps.selector))
  1166  	}
  1167  	return
  1168  }
  1169  
  1170  func (fps *TimeSerie_FieldSubPath) GetRaw(source proto.Message) []interface{} {
  1171  	return fps.Get(source.(*TimeSerie))
  1172  }
  1173  
  1174  // GetSingle returns value of selected field from source TimeSerie
  1175  func (fps *TimeSerie_FieldSubPath) GetSingle(source *TimeSerie) (interface{}, bool) {
  1176  	switch fps.selector {
  1177  	case TimeSerie_FieldPathSelectorMetric:
  1178  		if source.GetMetric() == nil {
  1179  			return nil, false
  1180  		}
  1181  		return fps.subPath.GetSingleRaw(source.GetMetric())
  1182  	case TimeSerie_FieldPathSelectorResource:
  1183  		if source.GetResource() == nil {
  1184  			return nil, false
  1185  		}
  1186  		return fps.subPath.GetSingleRaw(source.GetResource())
  1187  	case TimeSerie_FieldPathSelectorPoints:
  1188  		if len(source.GetPoints()) == 0 {
  1189  			return nil, false
  1190  		}
  1191  		return fps.subPath.GetSingleRaw(source.GetPoints()[0])
  1192  	default:
  1193  		panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fps.selector))
  1194  	}
  1195  }
  1196  
  1197  func (fps *TimeSerie_FieldSubPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
  1198  	return fps.GetSingle(source.(*TimeSerie))
  1199  }
  1200  
  1201  // GetDefault returns a default value of the field type
  1202  func (fps *TimeSerie_FieldSubPath) GetDefault() interface{} {
  1203  	return fps.subPath.GetDefault()
  1204  }
  1205  
  1206  func (fps *TimeSerie_FieldSubPath) ClearValue(item *TimeSerie) {
  1207  	if item != nil {
  1208  		switch fps.selector {
  1209  		case TimeSerie_FieldPathSelectorMetric:
  1210  			fps.subPath.ClearValueRaw(item.Metric)
  1211  		case TimeSerie_FieldPathSelectorResource:
  1212  			fps.subPath.ClearValueRaw(item.Resource)
  1213  		case TimeSerie_FieldPathSelectorPoints:
  1214  			for _, subItem := range item.Points {
  1215  				fps.subPath.ClearValueRaw(subItem)
  1216  			}
  1217  		default:
  1218  			panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fps.selector))
  1219  		}
  1220  	}
  1221  }
  1222  
  1223  func (fps *TimeSerie_FieldSubPath) ClearValueRaw(item proto.Message) {
  1224  	fps.ClearValue(item.(*TimeSerie))
  1225  }
  1226  
  1227  // IsLeaf - whether field path is holds simple value
  1228  func (fps *TimeSerie_FieldSubPath) IsLeaf() bool {
  1229  	return fps.subPath.IsLeaf()
  1230  }
  1231  
  1232  func (fps *TimeSerie_FieldSubPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
  1233  	iPaths := []gotenobject.FieldPath{&TimeSerie_FieldTerminalPath{selector: fps.selector}}
  1234  	iPaths = append(iPaths, fps.subPath.SplitIntoTerminalIPaths()...)
  1235  	return iPaths
  1236  }
  1237  
  1238  func (fps *TimeSerie_FieldSubPath) WithIValue(value interface{}) TimeSerie_FieldPathValue {
  1239  	return &TimeSerie_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
  1240  }
  1241  
  1242  func (fps *TimeSerie_FieldSubPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
  1243  	return fps.WithIValue(value)
  1244  }
  1245  
  1246  func (fps *TimeSerie_FieldSubPath) WithIArrayOfValues(values interface{}) TimeSerie_FieldPathArrayOfValues {
  1247  	return &TimeSerie_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
  1248  }
  1249  
  1250  func (fps *TimeSerie_FieldSubPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
  1251  	return fps.WithIArrayOfValues(values)
  1252  }
  1253  
  1254  func (fps *TimeSerie_FieldSubPath) WithIArrayItemValue(value interface{}) TimeSerie_FieldPathArrayItemValue {
  1255  	return &TimeSerie_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
  1256  }
  1257  
  1258  func (fps *TimeSerie_FieldSubPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
  1259  	return fps.WithIArrayItemValue(value)
  1260  }
  1261  
  1262  // TimeSerie_FieldPathValue allows storing values for TimeSerie fields according to their type
  1263  type TimeSerie_FieldPathValue interface {
  1264  	TimeSerie_FieldPath
  1265  	gotenobject.FieldPathValue
  1266  	SetTo(target **TimeSerie)
  1267  	CompareWith(*TimeSerie) (cmp int, comparable bool)
  1268  }
  1269  
  1270  func ParseTimeSerie_FieldPathValue(pathStr, valueStr string) (TimeSerie_FieldPathValue, error) {
  1271  	fp, err := ParseTimeSerie_FieldPath(pathStr)
  1272  	if err != nil {
  1273  		return nil, err
  1274  	}
  1275  	fpv, err := gotenobject.ParseFieldPathValue(fp, valueStr)
  1276  	if err != nil {
  1277  		return nil, status.Errorf(codes.InvalidArgument, "error parsing TimeSerie field path value from %s: %v", valueStr, err)
  1278  	}
  1279  	return fpv.(TimeSerie_FieldPathValue), nil
  1280  }
  1281  
  1282  func MustParseTimeSerie_FieldPathValue(pathStr, valueStr string) TimeSerie_FieldPathValue {
  1283  	fpv, err := ParseTimeSerie_FieldPathValue(pathStr, valueStr)
  1284  	if err != nil {
  1285  		panic(err)
  1286  	}
  1287  	return fpv
  1288  }
  1289  
  1290  type TimeSerie_FieldTerminalPathValue struct {
  1291  	TimeSerie_FieldTerminalPath
  1292  	value interface{}
  1293  }
  1294  
  1295  var _ TimeSerie_FieldPathValue = (*TimeSerie_FieldTerminalPathValue)(nil)
  1296  
  1297  // GetRawValue returns raw value stored under selected path for 'TimeSerie' as interface{}
  1298  func (fpv *TimeSerie_FieldTerminalPathValue) GetRawValue() interface{} {
  1299  	return fpv.value
  1300  }
  1301  func (fpv *TimeSerie_FieldTerminalPathValue) AsKeyValue() ([]byte, bool) {
  1302  	res, ok := fpv.value.([]byte)
  1303  	return res, ok
  1304  }
  1305  func (fpv *TimeSerie_FieldTerminalPathValue) AsProjectValue() (string, bool) {
  1306  	res, ok := fpv.value.(string)
  1307  	return res, ok
  1308  }
  1309  func (fpv *TimeSerie_FieldTerminalPathValue) AsRegionValue() (string, bool) {
  1310  	res, ok := fpv.value.(string)
  1311  	return res, ok
  1312  }
  1313  func (fpv *TimeSerie_FieldTerminalPathValue) AsMetricValue() (*common.Metric, bool) {
  1314  	res, ok := fpv.value.(*common.Metric)
  1315  	return res, ok
  1316  }
  1317  func (fpv *TimeSerie_FieldTerminalPathValue) AsResourceValue() (*common.MonitoredResource, bool) {
  1318  	res, ok := fpv.value.(*common.MonitoredResource)
  1319  	return res, ok
  1320  }
  1321  func (fpv *TimeSerie_FieldTerminalPathValue) AsMetricKindValue() (metric_descriptor.MetricDescriptor_MetricKind, bool) {
  1322  	res, ok := fpv.value.(metric_descriptor.MetricDescriptor_MetricKind)
  1323  	return res, ok
  1324  }
  1325  func (fpv *TimeSerie_FieldTerminalPathValue) AsValueTypeValue() (metric_descriptor.MetricDescriptor_ValueType, bool) {
  1326  	res, ok := fpv.value.(metric_descriptor.MetricDescriptor_ValueType)
  1327  	return res, ok
  1328  }
  1329  func (fpv *TimeSerie_FieldTerminalPathValue) AsPointsValue() ([]*Point, bool) {
  1330  	res, ok := fpv.value.([]*Point)
  1331  	return res, ok
  1332  }
  1333  
  1334  // SetTo stores value for selected field for object TimeSerie
  1335  func (fpv *TimeSerie_FieldTerminalPathValue) SetTo(target **TimeSerie) {
  1336  	if *target == nil {
  1337  		*target = new(TimeSerie)
  1338  	}
  1339  	switch fpv.selector {
  1340  	case TimeSerie_FieldPathSelectorKey:
  1341  		(*target).Key = fpv.value.([]byte)
  1342  	case TimeSerie_FieldPathSelectorProject:
  1343  		(*target).Project = fpv.value.(string)
  1344  	case TimeSerie_FieldPathSelectorRegion:
  1345  		(*target).Region = fpv.value.(string)
  1346  	case TimeSerie_FieldPathSelectorMetric:
  1347  		(*target).Metric = fpv.value.(*common.Metric)
  1348  	case TimeSerie_FieldPathSelectorResource:
  1349  		(*target).Resource = fpv.value.(*common.MonitoredResource)
  1350  	case TimeSerie_FieldPathSelectorMetricKind:
  1351  		(*target).MetricKind = fpv.value.(metric_descriptor.MetricDescriptor_MetricKind)
  1352  	case TimeSerie_FieldPathSelectorValueType:
  1353  		(*target).ValueType = fpv.value.(metric_descriptor.MetricDescriptor_ValueType)
  1354  	case TimeSerie_FieldPathSelectorPoints:
  1355  		(*target).Points = fpv.value.([]*Point)
  1356  	default:
  1357  		panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fpv.selector))
  1358  	}
  1359  }
  1360  
  1361  func (fpv *TimeSerie_FieldTerminalPathValue) SetToRaw(target proto.Message) {
  1362  	typedObject := target.(*TimeSerie)
  1363  	fpv.SetTo(&typedObject)
  1364  }
  1365  
  1366  // CompareWith compares value in the 'TimeSerie_FieldTerminalPathValue' with the value under path in 'TimeSerie'.
  1367  func (fpv *TimeSerie_FieldTerminalPathValue) CompareWith(source *TimeSerie) (int, bool) {
  1368  	switch fpv.selector {
  1369  	case TimeSerie_FieldPathSelectorKey:
  1370  		return 0, false
  1371  	case TimeSerie_FieldPathSelectorProject:
  1372  		leftValue := fpv.value.(string)
  1373  		rightValue := source.GetProject()
  1374  		if (leftValue) == (rightValue) {
  1375  			return 0, true
  1376  		} else if (leftValue) < (rightValue) {
  1377  			return -1, true
  1378  		} else {
  1379  			return 1, true
  1380  		}
  1381  	case TimeSerie_FieldPathSelectorRegion:
  1382  		leftValue := fpv.value.(string)
  1383  		rightValue := source.GetRegion()
  1384  		if (leftValue) == (rightValue) {
  1385  			return 0, true
  1386  		} else if (leftValue) < (rightValue) {
  1387  			return -1, true
  1388  		} else {
  1389  			return 1, true
  1390  		}
  1391  	case TimeSerie_FieldPathSelectorMetric:
  1392  		return 0, false
  1393  	case TimeSerie_FieldPathSelectorResource:
  1394  		return 0, false
  1395  	case TimeSerie_FieldPathSelectorMetricKind:
  1396  		leftValue := fpv.value.(metric_descriptor.MetricDescriptor_MetricKind)
  1397  		rightValue := source.GetMetricKind()
  1398  		if (leftValue) == (rightValue) {
  1399  			return 0, true
  1400  		} else if (leftValue) < (rightValue) {
  1401  			return -1, true
  1402  		} else {
  1403  			return 1, true
  1404  		}
  1405  	case TimeSerie_FieldPathSelectorValueType:
  1406  		leftValue := fpv.value.(metric_descriptor.MetricDescriptor_ValueType)
  1407  		rightValue := source.GetValueType()
  1408  		if (leftValue) == (rightValue) {
  1409  			return 0, true
  1410  		} else if (leftValue) < (rightValue) {
  1411  			return -1, true
  1412  		} else {
  1413  			return 1, true
  1414  		}
  1415  	case TimeSerie_FieldPathSelectorPoints:
  1416  		return 0, false
  1417  	default:
  1418  		panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fpv.selector))
  1419  	}
  1420  }
  1421  
  1422  func (fpv *TimeSerie_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
  1423  	return fpv.CompareWith(source.(*TimeSerie))
  1424  }
  1425  
  1426  type TimeSerie_FieldSubPathValue struct {
  1427  	TimeSerie_FieldPath
  1428  	subPathValue gotenobject.FieldPathValue
  1429  }
  1430  
  1431  var _ TimeSerie_FieldPathValue = (*TimeSerie_FieldSubPathValue)(nil)
  1432  
  1433  func (fpvs *TimeSerie_FieldSubPathValue) AsMetricPathValue() (common.Metric_FieldPathValue, bool) {
  1434  	res, ok := fpvs.subPathValue.(common.Metric_FieldPathValue)
  1435  	return res, ok
  1436  }
  1437  func (fpvs *TimeSerie_FieldSubPathValue) AsResourcePathValue() (common.MonitoredResource_FieldPathValue, bool) {
  1438  	res, ok := fpvs.subPathValue.(common.MonitoredResource_FieldPathValue)
  1439  	return res, ok
  1440  }
  1441  func (fpvs *TimeSerie_FieldSubPathValue) AsPointsPathValue() (Point_FieldPathValue, bool) {
  1442  	res, ok := fpvs.subPathValue.(Point_FieldPathValue)
  1443  	return res, ok
  1444  }
  1445  
  1446  func (fpvs *TimeSerie_FieldSubPathValue) SetTo(target **TimeSerie) {
  1447  	if *target == nil {
  1448  		*target = new(TimeSerie)
  1449  	}
  1450  	switch fpvs.Selector() {
  1451  	case TimeSerie_FieldPathSelectorMetric:
  1452  		fpvs.subPathValue.(common.Metric_FieldPathValue).SetTo(&(*target).Metric)
  1453  	case TimeSerie_FieldPathSelectorResource:
  1454  		fpvs.subPathValue.(common.MonitoredResource_FieldPathValue).SetTo(&(*target).Resource)
  1455  	case TimeSerie_FieldPathSelectorPoints:
  1456  		panic("FieldPath setter is unsupported for array subpaths")
  1457  	default:
  1458  		panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fpvs.Selector()))
  1459  	}
  1460  }
  1461  
  1462  func (fpvs *TimeSerie_FieldSubPathValue) SetToRaw(target proto.Message) {
  1463  	typedObject := target.(*TimeSerie)
  1464  	fpvs.SetTo(&typedObject)
  1465  }
  1466  
  1467  func (fpvs *TimeSerie_FieldSubPathValue) GetRawValue() interface{} {
  1468  	return fpvs.subPathValue.GetRawValue()
  1469  }
  1470  
  1471  func (fpvs *TimeSerie_FieldSubPathValue) CompareWith(source *TimeSerie) (int, bool) {
  1472  	switch fpvs.Selector() {
  1473  	case TimeSerie_FieldPathSelectorMetric:
  1474  		return fpvs.subPathValue.(common.Metric_FieldPathValue).CompareWith(source.GetMetric())
  1475  	case TimeSerie_FieldPathSelectorResource:
  1476  		return fpvs.subPathValue.(common.MonitoredResource_FieldPathValue).CompareWith(source.GetResource())
  1477  	case TimeSerie_FieldPathSelectorPoints:
  1478  		return 0, false // repeated field
  1479  	default:
  1480  		panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fpvs.Selector()))
  1481  	}
  1482  }
  1483  
  1484  func (fpvs *TimeSerie_FieldSubPathValue) CompareWithRaw(source proto.Message) (int, bool) {
  1485  	return fpvs.CompareWith(source.(*TimeSerie))
  1486  }
  1487  
  1488  // TimeSerie_FieldPathArrayItemValue allows storing single item in Path-specific values for TimeSerie according to their type
  1489  // Present only for array (repeated) types.
  1490  type TimeSerie_FieldPathArrayItemValue interface {
  1491  	gotenobject.FieldPathArrayItemValue
  1492  	TimeSerie_FieldPath
  1493  	ContainsValue(*TimeSerie) bool
  1494  }
  1495  
  1496  // ParseTimeSerie_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
  1497  func ParseTimeSerie_FieldPathArrayItemValue(pathStr, valueStr string) (TimeSerie_FieldPathArrayItemValue, error) {
  1498  	fp, err := ParseTimeSerie_FieldPath(pathStr)
  1499  	if err != nil {
  1500  		return nil, err
  1501  	}
  1502  	fpaiv, err := gotenobject.ParseFieldPathArrayItemValue(fp, valueStr)
  1503  	if err != nil {
  1504  		return nil, status.Errorf(codes.InvalidArgument, "error parsing TimeSerie field path array item value from %s: %v", valueStr, err)
  1505  	}
  1506  	return fpaiv.(TimeSerie_FieldPathArrayItemValue), nil
  1507  }
  1508  
  1509  func MustParseTimeSerie_FieldPathArrayItemValue(pathStr, valueStr string) TimeSerie_FieldPathArrayItemValue {
  1510  	fpaiv, err := ParseTimeSerie_FieldPathArrayItemValue(pathStr, valueStr)
  1511  	if err != nil {
  1512  		panic(err)
  1513  	}
  1514  	return fpaiv
  1515  }
  1516  
  1517  type TimeSerie_FieldTerminalPathArrayItemValue struct {
  1518  	TimeSerie_FieldTerminalPath
  1519  	value interface{}
  1520  }
  1521  
  1522  var _ TimeSerie_FieldPathArrayItemValue = (*TimeSerie_FieldTerminalPathArrayItemValue)(nil)
  1523  
  1524  // GetRawValue returns stored element value for array in object TimeSerie as interface{}
  1525  func (fpaiv *TimeSerie_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
  1526  	return fpaiv.value
  1527  }
  1528  func (fpaiv *TimeSerie_FieldTerminalPathArrayItemValue) AsPointsItemValue() (*Point, bool) {
  1529  	res, ok := fpaiv.value.(*Point)
  1530  	return res, ok
  1531  }
  1532  
  1533  func (fpaiv *TimeSerie_FieldTerminalPathArrayItemValue) GetSingle(source *TimeSerie) (interface{}, bool) {
  1534  	return nil, false
  1535  }
  1536  
  1537  func (fpaiv *TimeSerie_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
  1538  	return fpaiv.GetSingle(source.(*TimeSerie))
  1539  }
  1540  
  1541  // Contains returns a boolean indicating if value that is being held is present in given 'TimeSerie'
  1542  func (fpaiv *TimeSerie_FieldTerminalPathArrayItemValue) ContainsValue(source *TimeSerie) bool {
  1543  	slice := fpaiv.TimeSerie_FieldTerminalPath.Get(source)
  1544  	for _, v := range slice {
  1545  		if asProtoMsg, ok := fpaiv.value.(proto.Message); ok {
  1546  			if proto.Equal(asProtoMsg, v.(proto.Message)) {
  1547  				return true
  1548  			}
  1549  		} else if reflect.DeepEqual(v, fpaiv.value) {
  1550  			return true
  1551  		}
  1552  	}
  1553  	return false
  1554  }
  1555  
  1556  type TimeSerie_FieldSubPathArrayItemValue struct {
  1557  	TimeSerie_FieldPath
  1558  	subPathItemValue gotenobject.FieldPathArrayItemValue
  1559  }
  1560  
  1561  // GetRawValue returns stored array item value
  1562  func (fpaivs *TimeSerie_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
  1563  	return fpaivs.subPathItemValue.GetRawItemValue()
  1564  }
  1565  func (fpaivs *TimeSerie_FieldSubPathArrayItemValue) AsMetricPathItemValue() (common.Metric_FieldPathArrayItemValue, bool) {
  1566  	res, ok := fpaivs.subPathItemValue.(common.Metric_FieldPathArrayItemValue)
  1567  	return res, ok
  1568  }
  1569  func (fpaivs *TimeSerie_FieldSubPathArrayItemValue) AsResourcePathItemValue() (common.MonitoredResource_FieldPathArrayItemValue, bool) {
  1570  	res, ok := fpaivs.subPathItemValue.(common.MonitoredResource_FieldPathArrayItemValue)
  1571  	return res, ok
  1572  }
  1573  func (fpaivs *TimeSerie_FieldSubPathArrayItemValue) AsPointsPathItemValue() (Point_FieldPathArrayItemValue, bool) {
  1574  	res, ok := fpaivs.subPathItemValue.(Point_FieldPathArrayItemValue)
  1575  	return res, ok
  1576  }
  1577  
  1578  // Contains returns a boolean indicating if value that is being held is present in given 'TimeSerie'
  1579  func (fpaivs *TimeSerie_FieldSubPathArrayItemValue) ContainsValue(source *TimeSerie) bool {
  1580  	switch fpaivs.Selector() {
  1581  	case TimeSerie_FieldPathSelectorMetric:
  1582  		return fpaivs.subPathItemValue.(common.Metric_FieldPathArrayItemValue).ContainsValue(source.GetMetric())
  1583  	case TimeSerie_FieldPathSelectorResource:
  1584  		return fpaivs.subPathItemValue.(common.MonitoredResource_FieldPathArrayItemValue).ContainsValue(source.GetResource())
  1585  	case TimeSerie_FieldPathSelectorPoints:
  1586  		return false // repeated/map field
  1587  	default:
  1588  		panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fpaivs.Selector()))
  1589  	}
  1590  }
  1591  
  1592  // TimeSerie_FieldPathArrayOfValues allows storing slice of values for TimeSerie fields according to their type
  1593  type TimeSerie_FieldPathArrayOfValues interface {
  1594  	gotenobject.FieldPathArrayOfValues
  1595  	TimeSerie_FieldPath
  1596  }
  1597  
  1598  func ParseTimeSerie_FieldPathArrayOfValues(pathStr, valuesStr string) (TimeSerie_FieldPathArrayOfValues, error) {
  1599  	fp, err := ParseTimeSerie_FieldPath(pathStr)
  1600  	if err != nil {
  1601  		return nil, err
  1602  	}
  1603  	fpaov, err := gotenobject.ParseFieldPathArrayOfValues(fp, valuesStr)
  1604  	if err != nil {
  1605  		return nil, status.Errorf(codes.InvalidArgument, "error parsing TimeSerie field path array of values from %s: %v", valuesStr, err)
  1606  	}
  1607  	return fpaov.(TimeSerie_FieldPathArrayOfValues), nil
  1608  }
  1609  
  1610  func MustParseTimeSerie_FieldPathArrayOfValues(pathStr, valuesStr string) TimeSerie_FieldPathArrayOfValues {
  1611  	fpaov, err := ParseTimeSerie_FieldPathArrayOfValues(pathStr, valuesStr)
  1612  	if err != nil {
  1613  		panic(err)
  1614  	}
  1615  	return fpaov
  1616  }
  1617  
  1618  type TimeSerie_FieldTerminalPathArrayOfValues struct {
  1619  	TimeSerie_FieldTerminalPath
  1620  	values interface{}
  1621  }
  1622  
  1623  var _ TimeSerie_FieldPathArrayOfValues = (*TimeSerie_FieldTerminalPathArrayOfValues)(nil)
  1624  
  1625  func (fpaov *TimeSerie_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
  1626  	switch fpaov.selector {
  1627  	case TimeSerie_FieldPathSelectorKey:
  1628  		for _, v := range fpaov.values.([][]byte) {
  1629  			values = append(values, v)
  1630  		}
  1631  	case TimeSerie_FieldPathSelectorProject:
  1632  		for _, v := range fpaov.values.([]string) {
  1633  			values = append(values, v)
  1634  		}
  1635  	case TimeSerie_FieldPathSelectorRegion:
  1636  		for _, v := range fpaov.values.([]string) {
  1637  			values = append(values, v)
  1638  		}
  1639  	case TimeSerie_FieldPathSelectorMetric:
  1640  		for _, v := range fpaov.values.([]*common.Metric) {
  1641  			values = append(values, v)
  1642  		}
  1643  	case TimeSerie_FieldPathSelectorResource:
  1644  		for _, v := range fpaov.values.([]*common.MonitoredResource) {
  1645  			values = append(values, v)
  1646  		}
  1647  	case TimeSerie_FieldPathSelectorMetricKind:
  1648  		for _, v := range fpaov.values.([]metric_descriptor.MetricDescriptor_MetricKind) {
  1649  			values = append(values, v)
  1650  		}
  1651  	case TimeSerie_FieldPathSelectorValueType:
  1652  		for _, v := range fpaov.values.([]metric_descriptor.MetricDescriptor_ValueType) {
  1653  			values = append(values, v)
  1654  		}
  1655  	case TimeSerie_FieldPathSelectorPoints:
  1656  		for _, v := range fpaov.values.([][]*Point) {
  1657  			values = append(values, v)
  1658  		}
  1659  	}
  1660  	return
  1661  }
  1662  func (fpaov *TimeSerie_FieldTerminalPathArrayOfValues) AsKeyArrayOfValues() ([][]byte, bool) {
  1663  	res, ok := fpaov.values.([][]byte)
  1664  	return res, ok
  1665  }
  1666  func (fpaov *TimeSerie_FieldTerminalPathArrayOfValues) AsProjectArrayOfValues() ([]string, bool) {
  1667  	res, ok := fpaov.values.([]string)
  1668  	return res, ok
  1669  }
  1670  func (fpaov *TimeSerie_FieldTerminalPathArrayOfValues) AsRegionArrayOfValues() ([]string, bool) {
  1671  	res, ok := fpaov.values.([]string)
  1672  	return res, ok
  1673  }
  1674  func (fpaov *TimeSerie_FieldTerminalPathArrayOfValues) AsMetricArrayOfValues() ([]*common.Metric, bool) {
  1675  	res, ok := fpaov.values.([]*common.Metric)
  1676  	return res, ok
  1677  }
  1678  func (fpaov *TimeSerie_FieldTerminalPathArrayOfValues) AsResourceArrayOfValues() ([]*common.MonitoredResource, bool) {
  1679  	res, ok := fpaov.values.([]*common.MonitoredResource)
  1680  	return res, ok
  1681  }
  1682  func (fpaov *TimeSerie_FieldTerminalPathArrayOfValues) AsMetricKindArrayOfValues() ([]metric_descriptor.MetricDescriptor_MetricKind, bool) {
  1683  	res, ok := fpaov.values.([]metric_descriptor.MetricDescriptor_MetricKind)
  1684  	return res, ok
  1685  }
  1686  func (fpaov *TimeSerie_FieldTerminalPathArrayOfValues) AsValueTypeArrayOfValues() ([]metric_descriptor.MetricDescriptor_ValueType, bool) {
  1687  	res, ok := fpaov.values.([]metric_descriptor.MetricDescriptor_ValueType)
  1688  	return res, ok
  1689  }
  1690  func (fpaov *TimeSerie_FieldTerminalPathArrayOfValues) AsPointsArrayOfValues() ([][]*Point, bool) {
  1691  	res, ok := fpaov.values.([][]*Point)
  1692  	return res, ok
  1693  }
  1694  
  1695  type TimeSerie_FieldSubPathArrayOfValues struct {
  1696  	TimeSerie_FieldPath
  1697  	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
  1698  }
  1699  
  1700  var _ TimeSerie_FieldPathArrayOfValues = (*TimeSerie_FieldSubPathArrayOfValues)(nil)
  1701  
  1702  func (fpsaov *TimeSerie_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
  1703  	return fpsaov.subPathArrayOfValues.GetRawValues()
  1704  }
  1705  func (fpsaov *TimeSerie_FieldSubPathArrayOfValues) AsMetricPathArrayOfValues() (common.Metric_FieldPathArrayOfValues, bool) {
  1706  	res, ok := fpsaov.subPathArrayOfValues.(common.Metric_FieldPathArrayOfValues)
  1707  	return res, ok
  1708  }
  1709  func (fpsaov *TimeSerie_FieldSubPathArrayOfValues) AsResourcePathArrayOfValues() (common.MonitoredResource_FieldPathArrayOfValues, bool) {
  1710  	res, ok := fpsaov.subPathArrayOfValues.(common.MonitoredResource_FieldPathArrayOfValues)
  1711  	return res, ok
  1712  }
  1713  func (fpsaov *TimeSerie_FieldSubPathArrayOfValues) AsPointsPathArrayOfValues() (Point_FieldPathArrayOfValues, bool) {
  1714  	res, ok := fpsaov.subPathArrayOfValues.(Point_FieldPathArrayOfValues)
  1715  	return res, ok
  1716  }
  1717  
  1718  // FieldPath provides implementation to handle
  1719  // https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
  1720  type BulkTimeSeries_FieldPath interface {
  1721  	gotenobject.FieldPath
  1722  	Selector() BulkTimeSeries_FieldPathSelector
  1723  	Get(source *BulkTimeSeries) []interface{}
  1724  	GetSingle(source *BulkTimeSeries) (interface{}, bool)
  1725  	ClearValue(item *BulkTimeSeries)
  1726  
  1727  	// Those methods build corresponding BulkTimeSeries_FieldPathValue
  1728  	// (or array of values) and holds passed value. Panics if injected type is incorrect.
  1729  	WithIValue(value interface{}) BulkTimeSeries_FieldPathValue
  1730  	WithIArrayOfValues(values interface{}) BulkTimeSeries_FieldPathArrayOfValues
  1731  	WithIArrayItemValue(value interface{}) BulkTimeSeries_FieldPathArrayItemValue
  1732  }
  1733  
  1734  type BulkTimeSeries_FieldPathSelector int32
  1735  
  1736  const (
  1737  	BulkTimeSeries_FieldPathSelectorTimeSeries  BulkTimeSeries_FieldPathSelector = 0
  1738  	BulkTimeSeries_FieldPathSelectorPhantomFlag BulkTimeSeries_FieldPathSelector = 1
  1739  )
  1740  
  1741  func (s BulkTimeSeries_FieldPathSelector) String() string {
  1742  	switch s {
  1743  	case BulkTimeSeries_FieldPathSelectorTimeSeries:
  1744  		return "time_series"
  1745  	case BulkTimeSeries_FieldPathSelectorPhantomFlag:
  1746  		return "phantom_flag"
  1747  	default:
  1748  		panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", s))
  1749  	}
  1750  }
  1751  
  1752  func BuildBulkTimeSeries_FieldPath(fp gotenobject.RawFieldPath) (BulkTimeSeries_FieldPath, error) {
  1753  	if len(fp) == 0 {
  1754  		return nil, status.Error(codes.InvalidArgument, "empty field path for object BulkTimeSeries")
  1755  	}
  1756  	if len(fp) == 1 {
  1757  		switch fp[0] {
  1758  		case "time_series", "timeSeries", "time-series":
  1759  			return &BulkTimeSeries_FieldTerminalPath{selector: BulkTimeSeries_FieldPathSelectorTimeSeries}, nil
  1760  		case "phantom_flag", "phantomFlag", "phantom-flag":
  1761  			return &BulkTimeSeries_FieldTerminalPath{selector: BulkTimeSeries_FieldPathSelectorPhantomFlag}, nil
  1762  		}
  1763  	} else {
  1764  		switch fp[0] {
  1765  		case "time_series", "timeSeries", "time-series":
  1766  			if subpath, err := BuildTimeSerie_FieldPath(fp[1:]); err != nil {
  1767  				return nil, err
  1768  			} else {
  1769  				return &BulkTimeSeries_FieldSubPath{selector: BulkTimeSeries_FieldPathSelectorTimeSeries, subPath: subpath}, nil
  1770  			}
  1771  		}
  1772  	}
  1773  	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object BulkTimeSeries", fp)
  1774  }
  1775  
  1776  func ParseBulkTimeSeries_FieldPath(rawField string) (BulkTimeSeries_FieldPath, error) {
  1777  	fp, err := gotenobject.ParseRawFieldPath(rawField)
  1778  	if err != nil {
  1779  		return nil, err
  1780  	}
  1781  	return BuildBulkTimeSeries_FieldPath(fp)
  1782  }
  1783  
  1784  func MustParseBulkTimeSeries_FieldPath(rawField string) BulkTimeSeries_FieldPath {
  1785  	fp, err := ParseBulkTimeSeries_FieldPath(rawField)
  1786  	if err != nil {
  1787  		panic(err)
  1788  	}
  1789  	return fp
  1790  }
  1791  
  1792  type BulkTimeSeries_FieldTerminalPath struct {
  1793  	selector BulkTimeSeries_FieldPathSelector
  1794  }
  1795  
  1796  var _ BulkTimeSeries_FieldPath = (*BulkTimeSeries_FieldTerminalPath)(nil)
  1797  
  1798  func (fp *BulkTimeSeries_FieldTerminalPath) Selector() BulkTimeSeries_FieldPathSelector {
  1799  	return fp.selector
  1800  }
  1801  
  1802  // String returns path representation in proto convention
  1803  func (fp *BulkTimeSeries_FieldTerminalPath) String() string {
  1804  	return fp.selector.String()
  1805  }
  1806  
  1807  // JSONString returns path representation is JSON convention
  1808  func (fp *BulkTimeSeries_FieldTerminalPath) JSONString() string {
  1809  	return strcase.ToLowerCamel(fp.String())
  1810  }
  1811  
  1812  // Get returns all values pointed by specific field from source BulkTimeSeries
  1813  func (fp *BulkTimeSeries_FieldTerminalPath) Get(source *BulkTimeSeries) (values []interface{}) {
  1814  	if source != nil {
  1815  		switch fp.selector {
  1816  		case BulkTimeSeries_FieldPathSelectorTimeSeries:
  1817  			for _, value := range source.GetTimeSeries() {
  1818  				values = append(values, value)
  1819  			}
  1820  		case BulkTimeSeries_FieldPathSelectorPhantomFlag:
  1821  			values = append(values, source.PhantomFlag)
  1822  		default:
  1823  			panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fp.selector))
  1824  		}
  1825  	}
  1826  	return
  1827  }
  1828  
  1829  func (fp *BulkTimeSeries_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
  1830  	return fp.Get(source.(*BulkTimeSeries))
  1831  }
  1832  
  1833  // GetSingle returns value pointed by specific field of from source BulkTimeSeries
  1834  func (fp *BulkTimeSeries_FieldTerminalPath) GetSingle(source *BulkTimeSeries) (interface{}, bool) {
  1835  	switch fp.selector {
  1836  	case BulkTimeSeries_FieldPathSelectorTimeSeries:
  1837  		res := source.GetTimeSeries()
  1838  		return res, res != nil
  1839  	case BulkTimeSeries_FieldPathSelectorPhantomFlag:
  1840  		return source.GetPhantomFlag(), source != nil
  1841  	default:
  1842  		panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fp.selector))
  1843  	}
  1844  }
  1845  
  1846  func (fp *BulkTimeSeries_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
  1847  	return fp.GetSingle(source.(*BulkTimeSeries))
  1848  }
  1849  
  1850  // GetDefault returns a default value of the field type
  1851  func (fp *BulkTimeSeries_FieldTerminalPath) GetDefault() interface{} {
  1852  	switch fp.selector {
  1853  	case BulkTimeSeries_FieldPathSelectorTimeSeries:
  1854  		return ([]*TimeSerie)(nil)
  1855  	case BulkTimeSeries_FieldPathSelectorPhantomFlag:
  1856  		return false
  1857  	default:
  1858  		panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fp.selector))
  1859  	}
  1860  }
  1861  
  1862  func (fp *BulkTimeSeries_FieldTerminalPath) ClearValue(item *BulkTimeSeries) {
  1863  	if item != nil {
  1864  		switch fp.selector {
  1865  		case BulkTimeSeries_FieldPathSelectorTimeSeries:
  1866  			item.TimeSeries = nil
  1867  		case BulkTimeSeries_FieldPathSelectorPhantomFlag:
  1868  			item.PhantomFlag = false
  1869  		default:
  1870  			panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fp.selector))
  1871  		}
  1872  	}
  1873  }
  1874  
  1875  func (fp *BulkTimeSeries_FieldTerminalPath) ClearValueRaw(item proto.Message) {
  1876  	fp.ClearValue(item.(*BulkTimeSeries))
  1877  }
  1878  
  1879  // IsLeaf - whether field path is holds simple value
  1880  func (fp *BulkTimeSeries_FieldTerminalPath) IsLeaf() bool {
  1881  	return fp.selector == BulkTimeSeries_FieldPathSelectorPhantomFlag
  1882  }
  1883  
  1884  func (fp *BulkTimeSeries_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
  1885  	return []gotenobject.FieldPath{fp}
  1886  }
  1887  
  1888  func (fp *BulkTimeSeries_FieldTerminalPath) WithIValue(value interface{}) BulkTimeSeries_FieldPathValue {
  1889  	switch fp.selector {
  1890  	case BulkTimeSeries_FieldPathSelectorTimeSeries:
  1891  		return &BulkTimeSeries_FieldTerminalPathValue{BulkTimeSeries_FieldTerminalPath: *fp, value: value.([]*TimeSerie)}
  1892  	case BulkTimeSeries_FieldPathSelectorPhantomFlag:
  1893  		return &BulkTimeSeries_FieldTerminalPathValue{BulkTimeSeries_FieldTerminalPath: *fp, value: value.(bool)}
  1894  	default:
  1895  		panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fp.selector))
  1896  	}
  1897  }
  1898  
  1899  func (fp *BulkTimeSeries_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
  1900  	return fp.WithIValue(value)
  1901  }
  1902  
  1903  func (fp *BulkTimeSeries_FieldTerminalPath) WithIArrayOfValues(values interface{}) BulkTimeSeries_FieldPathArrayOfValues {
  1904  	fpaov := &BulkTimeSeries_FieldTerminalPathArrayOfValues{BulkTimeSeries_FieldTerminalPath: *fp}
  1905  	switch fp.selector {
  1906  	case BulkTimeSeries_FieldPathSelectorTimeSeries:
  1907  		return &BulkTimeSeries_FieldTerminalPathArrayOfValues{BulkTimeSeries_FieldTerminalPath: *fp, values: values.([][]*TimeSerie)}
  1908  	case BulkTimeSeries_FieldPathSelectorPhantomFlag:
  1909  		return &BulkTimeSeries_FieldTerminalPathArrayOfValues{BulkTimeSeries_FieldTerminalPath: *fp, values: values.([]bool)}
  1910  	default:
  1911  		panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fp.selector))
  1912  	}
  1913  	return fpaov
  1914  }
  1915  
  1916  func (fp *BulkTimeSeries_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
  1917  	return fp.WithIArrayOfValues(values)
  1918  }
  1919  
  1920  func (fp *BulkTimeSeries_FieldTerminalPath) WithIArrayItemValue(value interface{}) BulkTimeSeries_FieldPathArrayItemValue {
  1921  	switch fp.selector {
  1922  	case BulkTimeSeries_FieldPathSelectorTimeSeries:
  1923  		return &BulkTimeSeries_FieldTerminalPathArrayItemValue{BulkTimeSeries_FieldTerminalPath: *fp, value: value.(*TimeSerie)}
  1924  	default:
  1925  		panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fp.selector))
  1926  	}
  1927  }
  1928  
  1929  func (fp *BulkTimeSeries_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
  1930  	return fp.WithIArrayItemValue(value)
  1931  }
  1932  
  1933  type BulkTimeSeries_FieldSubPath struct {
  1934  	selector BulkTimeSeries_FieldPathSelector
  1935  	subPath  gotenobject.FieldPath
  1936  }
  1937  
  1938  var _ BulkTimeSeries_FieldPath = (*BulkTimeSeries_FieldSubPath)(nil)
  1939  
  1940  func (fps *BulkTimeSeries_FieldSubPath) Selector() BulkTimeSeries_FieldPathSelector {
  1941  	return fps.selector
  1942  }
  1943  func (fps *BulkTimeSeries_FieldSubPath) AsTimeSeriesSubPath() (TimeSerie_FieldPath, bool) {
  1944  	res, ok := fps.subPath.(TimeSerie_FieldPath)
  1945  	return res, ok
  1946  }
  1947  
  1948  // String returns path representation in proto convention
  1949  func (fps *BulkTimeSeries_FieldSubPath) String() string {
  1950  	return fps.selector.String() + "." + fps.subPath.String()
  1951  }
  1952  
  1953  // JSONString returns path representation is JSON convention
  1954  func (fps *BulkTimeSeries_FieldSubPath) JSONString() string {
  1955  	return strcase.ToLowerCamel(fps.selector.String()) + "." + fps.subPath.JSONString()
  1956  }
  1957  
  1958  // Get returns all values pointed by selected field from source BulkTimeSeries
  1959  func (fps *BulkTimeSeries_FieldSubPath) Get(source *BulkTimeSeries) (values []interface{}) {
  1960  	switch fps.selector {
  1961  	case BulkTimeSeries_FieldPathSelectorTimeSeries:
  1962  		for _, item := range source.GetTimeSeries() {
  1963  			values = append(values, fps.subPath.GetRaw(item)...)
  1964  		}
  1965  	default:
  1966  		panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fps.selector))
  1967  	}
  1968  	return
  1969  }
  1970  
  1971  func (fps *BulkTimeSeries_FieldSubPath) GetRaw(source proto.Message) []interface{} {
  1972  	return fps.Get(source.(*BulkTimeSeries))
  1973  }
  1974  
  1975  // GetSingle returns value of selected field from source BulkTimeSeries
  1976  func (fps *BulkTimeSeries_FieldSubPath) GetSingle(source *BulkTimeSeries) (interface{}, bool) {
  1977  	switch fps.selector {
  1978  	case BulkTimeSeries_FieldPathSelectorTimeSeries:
  1979  		if len(source.GetTimeSeries()) == 0 {
  1980  			return nil, false
  1981  		}
  1982  		return fps.subPath.GetSingleRaw(source.GetTimeSeries()[0])
  1983  	default:
  1984  		panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fps.selector))
  1985  	}
  1986  }
  1987  
  1988  func (fps *BulkTimeSeries_FieldSubPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
  1989  	return fps.GetSingle(source.(*BulkTimeSeries))
  1990  }
  1991  
  1992  // GetDefault returns a default value of the field type
  1993  func (fps *BulkTimeSeries_FieldSubPath) GetDefault() interface{} {
  1994  	return fps.subPath.GetDefault()
  1995  }
  1996  
  1997  func (fps *BulkTimeSeries_FieldSubPath) ClearValue(item *BulkTimeSeries) {
  1998  	if item != nil {
  1999  		switch fps.selector {
  2000  		case BulkTimeSeries_FieldPathSelectorTimeSeries:
  2001  			for _, subItem := range item.TimeSeries {
  2002  				fps.subPath.ClearValueRaw(subItem)
  2003  			}
  2004  		default:
  2005  			panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fps.selector))
  2006  		}
  2007  	}
  2008  }
  2009  
  2010  func (fps *BulkTimeSeries_FieldSubPath) ClearValueRaw(item proto.Message) {
  2011  	fps.ClearValue(item.(*BulkTimeSeries))
  2012  }
  2013  
  2014  // IsLeaf - whether field path is holds simple value
  2015  func (fps *BulkTimeSeries_FieldSubPath) IsLeaf() bool {
  2016  	return fps.subPath.IsLeaf()
  2017  }
  2018  
  2019  func (fps *BulkTimeSeries_FieldSubPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
  2020  	iPaths := []gotenobject.FieldPath{&BulkTimeSeries_FieldTerminalPath{selector: fps.selector}}
  2021  	iPaths = append(iPaths, fps.subPath.SplitIntoTerminalIPaths()...)
  2022  	return iPaths
  2023  }
  2024  
  2025  func (fps *BulkTimeSeries_FieldSubPath) WithIValue(value interface{}) BulkTimeSeries_FieldPathValue {
  2026  	return &BulkTimeSeries_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
  2027  }
  2028  
  2029  func (fps *BulkTimeSeries_FieldSubPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
  2030  	return fps.WithIValue(value)
  2031  }
  2032  
  2033  func (fps *BulkTimeSeries_FieldSubPath) WithIArrayOfValues(values interface{}) BulkTimeSeries_FieldPathArrayOfValues {
  2034  	return &BulkTimeSeries_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
  2035  }
  2036  
  2037  func (fps *BulkTimeSeries_FieldSubPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
  2038  	return fps.WithIArrayOfValues(values)
  2039  }
  2040  
  2041  func (fps *BulkTimeSeries_FieldSubPath) WithIArrayItemValue(value interface{}) BulkTimeSeries_FieldPathArrayItemValue {
  2042  	return &BulkTimeSeries_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
  2043  }
  2044  
  2045  func (fps *BulkTimeSeries_FieldSubPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
  2046  	return fps.WithIArrayItemValue(value)
  2047  }
  2048  
  2049  // BulkTimeSeries_FieldPathValue allows storing values for BulkTimeSeries fields according to their type
  2050  type BulkTimeSeries_FieldPathValue interface {
  2051  	BulkTimeSeries_FieldPath
  2052  	gotenobject.FieldPathValue
  2053  	SetTo(target **BulkTimeSeries)
  2054  	CompareWith(*BulkTimeSeries) (cmp int, comparable bool)
  2055  }
  2056  
  2057  func ParseBulkTimeSeries_FieldPathValue(pathStr, valueStr string) (BulkTimeSeries_FieldPathValue, error) {
  2058  	fp, err := ParseBulkTimeSeries_FieldPath(pathStr)
  2059  	if err != nil {
  2060  		return nil, err
  2061  	}
  2062  	fpv, err := gotenobject.ParseFieldPathValue(fp, valueStr)
  2063  	if err != nil {
  2064  		return nil, status.Errorf(codes.InvalidArgument, "error parsing BulkTimeSeries field path value from %s: %v", valueStr, err)
  2065  	}
  2066  	return fpv.(BulkTimeSeries_FieldPathValue), nil
  2067  }
  2068  
  2069  func MustParseBulkTimeSeries_FieldPathValue(pathStr, valueStr string) BulkTimeSeries_FieldPathValue {
  2070  	fpv, err := ParseBulkTimeSeries_FieldPathValue(pathStr, valueStr)
  2071  	if err != nil {
  2072  		panic(err)
  2073  	}
  2074  	return fpv
  2075  }
  2076  
  2077  type BulkTimeSeries_FieldTerminalPathValue struct {
  2078  	BulkTimeSeries_FieldTerminalPath
  2079  	value interface{}
  2080  }
  2081  
  2082  var _ BulkTimeSeries_FieldPathValue = (*BulkTimeSeries_FieldTerminalPathValue)(nil)
  2083  
  2084  // GetRawValue returns raw value stored under selected path for 'BulkTimeSeries' as interface{}
  2085  func (fpv *BulkTimeSeries_FieldTerminalPathValue) GetRawValue() interface{} {
  2086  	return fpv.value
  2087  }
  2088  func (fpv *BulkTimeSeries_FieldTerminalPathValue) AsTimeSeriesValue() ([]*TimeSerie, bool) {
  2089  	res, ok := fpv.value.([]*TimeSerie)
  2090  	return res, ok
  2091  }
  2092  func (fpv *BulkTimeSeries_FieldTerminalPathValue) AsPhantomFlagValue() (bool, bool) {
  2093  	res, ok := fpv.value.(bool)
  2094  	return res, ok
  2095  }
  2096  
  2097  // SetTo stores value for selected field for object BulkTimeSeries
  2098  func (fpv *BulkTimeSeries_FieldTerminalPathValue) SetTo(target **BulkTimeSeries) {
  2099  	if *target == nil {
  2100  		*target = new(BulkTimeSeries)
  2101  	}
  2102  	switch fpv.selector {
  2103  	case BulkTimeSeries_FieldPathSelectorTimeSeries:
  2104  		(*target).TimeSeries = fpv.value.([]*TimeSerie)
  2105  	case BulkTimeSeries_FieldPathSelectorPhantomFlag:
  2106  		(*target).PhantomFlag = fpv.value.(bool)
  2107  	default:
  2108  		panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fpv.selector))
  2109  	}
  2110  }
  2111  
  2112  func (fpv *BulkTimeSeries_FieldTerminalPathValue) SetToRaw(target proto.Message) {
  2113  	typedObject := target.(*BulkTimeSeries)
  2114  	fpv.SetTo(&typedObject)
  2115  }
  2116  
  2117  // CompareWith compares value in the 'BulkTimeSeries_FieldTerminalPathValue' with the value under path in 'BulkTimeSeries'.
  2118  func (fpv *BulkTimeSeries_FieldTerminalPathValue) CompareWith(source *BulkTimeSeries) (int, bool) {
  2119  	switch fpv.selector {
  2120  	case BulkTimeSeries_FieldPathSelectorTimeSeries:
  2121  		return 0, false
  2122  	case BulkTimeSeries_FieldPathSelectorPhantomFlag:
  2123  		leftValue := fpv.value.(bool)
  2124  		rightValue := source.GetPhantomFlag()
  2125  		if (leftValue) == (rightValue) {
  2126  			return 0, true
  2127  		} else if !(leftValue) && (rightValue) {
  2128  			return -1, true
  2129  		} else {
  2130  			return 1, true
  2131  		}
  2132  	default:
  2133  		panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fpv.selector))
  2134  	}
  2135  }
  2136  
  2137  func (fpv *BulkTimeSeries_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
  2138  	return fpv.CompareWith(source.(*BulkTimeSeries))
  2139  }
  2140  
  2141  type BulkTimeSeries_FieldSubPathValue struct {
  2142  	BulkTimeSeries_FieldPath
  2143  	subPathValue gotenobject.FieldPathValue
  2144  }
  2145  
  2146  var _ BulkTimeSeries_FieldPathValue = (*BulkTimeSeries_FieldSubPathValue)(nil)
  2147  
  2148  func (fpvs *BulkTimeSeries_FieldSubPathValue) AsTimeSeriesPathValue() (TimeSerie_FieldPathValue, bool) {
  2149  	res, ok := fpvs.subPathValue.(TimeSerie_FieldPathValue)
  2150  	return res, ok
  2151  }
  2152  
  2153  func (fpvs *BulkTimeSeries_FieldSubPathValue) SetTo(target **BulkTimeSeries) {
  2154  	if *target == nil {
  2155  		*target = new(BulkTimeSeries)
  2156  	}
  2157  	switch fpvs.Selector() {
  2158  	case BulkTimeSeries_FieldPathSelectorTimeSeries:
  2159  		panic("FieldPath setter is unsupported for array subpaths")
  2160  	default:
  2161  		panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fpvs.Selector()))
  2162  	}
  2163  }
  2164  
  2165  func (fpvs *BulkTimeSeries_FieldSubPathValue) SetToRaw(target proto.Message) {
  2166  	typedObject := target.(*BulkTimeSeries)
  2167  	fpvs.SetTo(&typedObject)
  2168  }
  2169  
  2170  func (fpvs *BulkTimeSeries_FieldSubPathValue) GetRawValue() interface{} {
  2171  	return fpvs.subPathValue.GetRawValue()
  2172  }
  2173  
  2174  func (fpvs *BulkTimeSeries_FieldSubPathValue) CompareWith(source *BulkTimeSeries) (int, bool) {
  2175  	switch fpvs.Selector() {
  2176  	case BulkTimeSeries_FieldPathSelectorTimeSeries:
  2177  		return 0, false // repeated field
  2178  	default:
  2179  		panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fpvs.Selector()))
  2180  	}
  2181  }
  2182  
  2183  func (fpvs *BulkTimeSeries_FieldSubPathValue) CompareWithRaw(source proto.Message) (int, bool) {
  2184  	return fpvs.CompareWith(source.(*BulkTimeSeries))
  2185  }
  2186  
  2187  // BulkTimeSeries_FieldPathArrayItemValue allows storing single item in Path-specific values for BulkTimeSeries according to their type
  2188  // Present only for array (repeated) types.
  2189  type BulkTimeSeries_FieldPathArrayItemValue interface {
  2190  	gotenobject.FieldPathArrayItemValue
  2191  	BulkTimeSeries_FieldPath
  2192  	ContainsValue(*BulkTimeSeries) bool
  2193  }
  2194  
  2195  // ParseBulkTimeSeries_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
  2196  func ParseBulkTimeSeries_FieldPathArrayItemValue(pathStr, valueStr string) (BulkTimeSeries_FieldPathArrayItemValue, error) {
  2197  	fp, err := ParseBulkTimeSeries_FieldPath(pathStr)
  2198  	if err != nil {
  2199  		return nil, err
  2200  	}
  2201  	fpaiv, err := gotenobject.ParseFieldPathArrayItemValue(fp, valueStr)
  2202  	if err != nil {
  2203  		return nil, status.Errorf(codes.InvalidArgument, "error parsing BulkTimeSeries field path array item value from %s: %v", valueStr, err)
  2204  	}
  2205  	return fpaiv.(BulkTimeSeries_FieldPathArrayItemValue), nil
  2206  }
  2207  
  2208  func MustParseBulkTimeSeries_FieldPathArrayItemValue(pathStr, valueStr string) BulkTimeSeries_FieldPathArrayItemValue {
  2209  	fpaiv, err := ParseBulkTimeSeries_FieldPathArrayItemValue(pathStr, valueStr)
  2210  	if err != nil {
  2211  		panic(err)
  2212  	}
  2213  	return fpaiv
  2214  }
  2215  
  2216  type BulkTimeSeries_FieldTerminalPathArrayItemValue struct {
  2217  	BulkTimeSeries_FieldTerminalPath
  2218  	value interface{}
  2219  }
  2220  
  2221  var _ BulkTimeSeries_FieldPathArrayItemValue = (*BulkTimeSeries_FieldTerminalPathArrayItemValue)(nil)
  2222  
  2223  // GetRawValue returns stored element value for array in object BulkTimeSeries as interface{}
  2224  func (fpaiv *BulkTimeSeries_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
  2225  	return fpaiv.value
  2226  }
  2227  func (fpaiv *BulkTimeSeries_FieldTerminalPathArrayItemValue) AsTimeSeriesItemValue() (*TimeSerie, bool) {
  2228  	res, ok := fpaiv.value.(*TimeSerie)
  2229  	return res, ok
  2230  }
  2231  
  2232  func (fpaiv *BulkTimeSeries_FieldTerminalPathArrayItemValue) GetSingle(source *BulkTimeSeries) (interface{}, bool) {
  2233  	return nil, false
  2234  }
  2235  
  2236  func (fpaiv *BulkTimeSeries_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
  2237  	return fpaiv.GetSingle(source.(*BulkTimeSeries))
  2238  }
  2239  
  2240  // Contains returns a boolean indicating if value that is being held is present in given 'BulkTimeSeries'
  2241  func (fpaiv *BulkTimeSeries_FieldTerminalPathArrayItemValue) ContainsValue(source *BulkTimeSeries) bool {
  2242  	slice := fpaiv.BulkTimeSeries_FieldTerminalPath.Get(source)
  2243  	for _, v := range slice {
  2244  		if asProtoMsg, ok := fpaiv.value.(proto.Message); ok {
  2245  			if proto.Equal(asProtoMsg, v.(proto.Message)) {
  2246  				return true
  2247  			}
  2248  		} else if reflect.DeepEqual(v, fpaiv.value) {
  2249  			return true
  2250  		}
  2251  	}
  2252  	return false
  2253  }
  2254  
  2255  type BulkTimeSeries_FieldSubPathArrayItemValue struct {
  2256  	BulkTimeSeries_FieldPath
  2257  	subPathItemValue gotenobject.FieldPathArrayItemValue
  2258  }
  2259  
  2260  // GetRawValue returns stored array item value
  2261  func (fpaivs *BulkTimeSeries_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
  2262  	return fpaivs.subPathItemValue.GetRawItemValue()
  2263  }
  2264  func (fpaivs *BulkTimeSeries_FieldSubPathArrayItemValue) AsTimeSeriesPathItemValue() (TimeSerie_FieldPathArrayItemValue, bool) {
  2265  	res, ok := fpaivs.subPathItemValue.(TimeSerie_FieldPathArrayItemValue)
  2266  	return res, ok
  2267  }
  2268  
  2269  // Contains returns a boolean indicating if value that is being held is present in given 'BulkTimeSeries'
  2270  func (fpaivs *BulkTimeSeries_FieldSubPathArrayItemValue) ContainsValue(source *BulkTimeSeries) bool {
  2271  	switch fpaivs.Selector() {
  2272  	case BulkTimeSeries_FieldPathSelectorTimeSeries:
  2273  		return false // repeated/map field
  2274  	default:
  2275  		panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fpaivs.Selector()))
  2276  	}
  2277  }
  2278  
  2279  // BulkTimeSeries_FieldPathArrayOfValues allows storing slice of values for BulkTimeSeries fields according to their type
  2280  type BulkTimeSeries_FieldPathArrayOfValues interface {
  2281  	gotenobject.FieldPathArrayOfValues
  2282  	BulkTimeSeries_FieldPath
  2283  }
  2284  
  2285  func ParseBulkTimeSeries_FieldPathArrayOfValues(pathStr, valuesStr string) (BulkTimeSeries_FieldPathArrayOfValues, error) {
  2286  	fp, err := ParseBulkTimeSeries_FieldPath(pathStr)
  2287  	if err != nil {
  2288  		return nil, err
  2289  	}
  2290  	fpaov, err := gotenobject.ParseFieldPathArrayOfValues(fp, valuesStr)
  2291  	if err != nil {
  2292  		return nil, status.Errorf(codes.InvalidArgument, "error parsing BulkTimeSeries field path array of values from %s: %v", valuesStr, err)
  2293  	}
  2294  	return fpaov.(BulkTimeSeries_FieldPathArrayOfValues), nil
  2295  }
  2296  
  2297  func MustParseBulkTimeSeries_FieldPathArrayOfValues(pathStr, valuesStr string) BulkTimeSeries_FieldPathArrayOfValues {
  2298  	fpaov, err := ParseBulkTimeSeries_FieldPathArrayOfValues(pathStr, valuesStr)
  2299  	if err != nil {
  2300  		panic(err)
  2301  	}
  2302  	return fpaov
  2303  }
  2304  
  2305  type BulkTimeSeries_FieldTerminalPathArrayOfValues struct {
  2306  	BulkTimeSeries_FieldTerminalPath
  2307  	values interface{}
  2308  }
  2309  
  2310  var _ BulkTimeSeries_FieldPathArrayOfValues = (*BulkTimeSeries_FieldTerminalPathArrayOfValues)(nil)
  2311  
  2312  func (fpaov *BulkTimeSeries_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
  2313  	switch fpaov.selector {
  2314  	case BulkTimeSeries_FieldPathSelectorTimeSeries:
  2315  		for _, v := range fpaov.values.([][]*TimeSerie) {
  2316  			values = append(values, v)
  2317  		}
  2318  	case BulkTimeSeries_FieldPathSelectorPhantomFlag:
  2319  		for _, v := range fpaov.values.([]bool) {
  2320  			values = append(values, v)
  2321  		}
  2322  	}
  2323  	return
  2324  }
  2325  func (fpaov *BulkTimeSeries_FieldTerminalPathArrayOfValues) AsTimeSeriesArrayOfValues() ([][]*TimeSerie, bool) {
  2326  	res, ok := fpaov.values.([][]*TimeSerie)
  2327  	return res, ok
  2328  }
  2329  func (fpaov *BulkTimeSeries_FieldTerminalPathArrayOfValues) AsPhantomFlagArrayOfValues() ([]bool, bool) {
  2330  	res, ok := fpaov.values.([]bool)
  2331  	return res, ok
  2332  }
  2333  
  2334  type BulkTimeSeries_FieldSubPathArrayOfValues struct {
  2335  	BulkTimeSeries_FieldPath
  2336  	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
  2337  }
  2338  
  2339  var _ BulkTimeSeries_FieldPathArrayOfValues = (*BulkTimeSeries_FieldSubPathArrayOfValues)(nil)
  2340  
  2341  func (fpsaov *BulkTimeSeries_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
  2342  	return fpsaov.subPathArrayOfValues.GetRawValues()
  2343  }
  2344  func (fpsaov *BulkTimeSeries_FieldSubPathArrayOfValues) AsTimeSeriesPathArrayOfValues() (TimeSerie_FieldPathArrayOfValues, bool) {
  2345  	res, ok := fpsaov.subPathArrayOfValues.(TimeSerie_FieldPathArrayOfValues)
  2346  	return res, ok
  2347  }