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

     1  // Code generated by protoc-gen-goten-object
     2  // File: edgelq/monitoring/proto/v4/time_serie.proto
     3  // DO NOT EDIT!!!
     4  
     5  package time_serie
     6  
     7  import (
     8  	"encoding/json"
     9  	"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/v4/common"
    27  	metric_descriptor "github.com/cloudwan/edgelq-sdk/monitoring/resources/v4/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_FieldPathSelectorUnit       TimeSerie_FieldPathSelector = 3
   803  	TimeSerie_FieldPathSelectorMetric     TimeSerie_FieldPathSelector = 4
   804  	TimeSerie_FieldPathSelectorResource   TimeSerie_FieldPathSelector = 5
   805  	TimeSerie_FieldPathSelectorMetricKind TimeSerie_FieldPathSelector = 6
   806  	TimeSerie_FieldPathSelectorValueType  TimeSerie_FieldPathSelector = 7
   807  	TimeSerie_FieldPathSelectorPoints     TimeSerie_FieldPathSelector = 8
   808  )
   809  
   810  func (s TimeSerie_FieldPathSelector) String() string {
   811  	switch s {
   812  	case TimeSerie_FieldPathSelectorKey:
   813  		return "key"
   814  	case TimeSerie_FieldPathSelectorProject:
   815  		return "project"
   816  	case TimeSerie_FieldPathSelectorRegion:
   817  		return "region"
   818  	case TimeSerie_FieldPathSelectorUnit:
   819  		return "unit"
   820  	case TimeSerie_FieldPathSelectorMetric:
   821  		return "metric"
   822  	case TimeSerie_FieldPathSelectorResource:
   823  		return "resource"
   824  	case TimeSerie_FieldPathSelectorMetricKind:
   825  		return "metric_kind"
   826  	case TimeSerie_FieldPathSelectorValueType:
   827  		return "value_type"
   828  	case TimeSerie_FieldPathSelectorPoints:
   829  		return "points"
   830  	default:
   831  		panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", s))
   832  	}
   833  }
   834  
   835  func BuildTimeSerie_FieldPath(fp gotenobject.RawFieldPath) (TimeSerie_FieldPath, error) {
   836  	if len(fp) == 0 {
   837  		return nil, status.Error(codes.InvalidArgument, "empty field path for object TimeSerie")
   838  	}
   839  	if len(fp) == 1 {
   840  		switch fp[0] {
   841  		case "key":
   842  			return &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorKey}, nil
   843  		case "project":
   844  			return &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorProject}, nil
   845  		case "region":
   846  			return &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorRegion}, nil
   847  		case "unit":
   848  			return &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorUnit}, nil
   849  		case "metric":
   850  			return &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorMetric}, nil
   851  		case "resource":
   852  			return &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorResource}, nil
   853  		case "metric_kind", "metricKind", "metric-kind":
   854  			return &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorMetricKind}, nil
   855  		case "value_type", "valueType", "value-type":
   856  			return &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorValueType}, nil
   857  		case "points":
   858  			return &TimeSerie_FieldTerminalPath{selector: TimeSerie_FieldPathSelectorPoints}, nil
   859  		}
   860  	} else {
   861  		switch fp[0] {
   862  		case "metric":
   863  			if subpath, err := common.BuildMetric_FieldPath(fp[1:]); err != nil {
   864  				return nil, err
   865  			} else {
   866  				return &TimeSerie_FieldSubPath{selector: TimeSerie_FieldPathSelectorMetric, subPath: subpath}, nil
   867  			}
   868  		case "resource":
   869  			if subpath, err := common.BuildMonitoredResource_FieldPath(fp[1:]); err != nil {
   870  				return nil, err
   871  			} else {
   872  				return &TimeSerie_FieldSubPath{selector: TimeSerie_FieldPathSelectorResource, subPath: subpath}, nil
   873  			}
   874  		case "points":
   875  			if subpath, err := BuildPoint_FieldPath(fp[1:]); err != nil {
   876  				return nil, err
   877  			} else {
   878  				return &TimeSerie_FieldSubPath{selector: TimeSerie_FieldPathSelectorPoints, subPath: subpath}, nil
   879  			}
   880  		}
   881  	}
   882  	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object TimeSerie", fp)
   883  }
   884  
   885  func ParseTimeSerie_FieldPath(rawField string) (TimeSerie_FieldPath, error) {
   886  	fp, err := gotenobject.ParseRawFieldPath(rawField)
   887  	if err != nil {
   888  		return nil, err
   889  	}
   890  	return BuildTimeSerie_FieldPath(fp)
   891  }
   892  
   893  func MustParseTimeSerie_FieldPath(rawField string) TimeSerie_FieldPath {
   894  	fp, err := ParseTimeSerie_FieldPath(rawField)
   895  	if err != nil {
   896  		panic(err)
   897  	}
   898  	return fp
   899  }
   900  
   901  type TimeSerie_FieldTerminalPath struct {
   902  	selector TimeSerie_FieldPathSelector
   903  }
   904  
   905  var _ TimeSerie_FieldPath = (*TimeSerie_FieldTerminalPath)(nil)
   906  
   907  func (fp *TimeSerie_FieldTerminalPath) Selector() TimeSerie_FieldPathSelector {
   908  	return fp.selector
   909  }
   910  
   911  // String returns path representation in proto convention
   912  func (fp *TimeSerie_FieldTerminalPath) String() string {
   913  	return fp.selector.String()
   914  }
   915  
   916  // JSONString returns path representation is JSON convention
   917  func (fp *TimeSerie_FieldTerminalPath) JSONString() string {
   918  	return strcase.ToLowerCamel(fp.String())
   919  }
   920  
   921  // Get returns all values pointed by specific field from source TimeSerie
   922  func (fp *TimeSerie_FieldTerminalPath) Get(source *TimeSerie) (values []interface{}) {
   923  	if source != nil {
   924  		switch fp.selector {
   925  		case TimeSerie_FieldPathSelectorKey:
   926  			values = append(values, source.Key)
   927  		case TimeSerie_FieldPathSelectorProject:
   928  			values = append(values, source.Project)
   929  		case TimeSerie_FieldPathSelectorRegion:
   930  			values = append(values, source.Region)
   931  		case TimeSerie_FieldPathSelectorUnit:
   932  			values = append(values, source.Unit)
   933  		case TimeSerie_FieldPathSelectorMetric:
   934  			if source.Metric != nil {
   935  				values = append(values, source.Metric)
   936  			}
   937  		case TimeSerie_FieldPathSelectorResource:
   938  			if source.Resource != nil {
   939  				values = append(values, source.Resource)
   940  			}
   941  		case TimeSerie_FieldPathSelectorMetricKind:
   942  			values = append(values, source.MetricKind)
   943  		case TimeSerie_FieldPathSelectorValueType:
   944  			values = append(values, source.ValueType)
   945  		case TimeSerie_FieldPathSelectorPoints:
   946  			for _, value := range source.GetPoints() {
   947  				values = append(values, value)
   948  			}
   949  		default:
   950  			panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fp.selector))
   951  		}
   952  	}
   953  	return
   954  }
   955  
   956  func (fp *TimeSerie_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
   957  	return fp.Get(source.(*TimeSerie))
   958  }
   959  
   960  // GetSingle returns value pointed by specific field of from source TimeSerie
   961  func (fp *TimeSerie_FieldTerminalPath) GetSingle(source *TimeSerie) (interface{}, bool) {
   962  	switch fp.selector {
   963  	case TimeSerie_FieldPathSelectorKey:
   964  		res := source.GetKey()
   965  		return res, res != nil
   966  	case TimeSerie_FieldPathSelectorProject:
   967  		return source.GetProject(), source != nil
   968  	case TimeSerie_FieldPathSelectorRegion:
   969  		return source.GetRegion(), source != nil
   970  	case TimeSerie_FieldPathSelectorUnit:
   971  		return source.GetUnit(), source != nil
   972  	case TimeSerie_FieldPathSelectorMetric:
   973  		res := source.GetMetric()
   974  		return res, res != nil
   975  	case TimeSerie_FieldPathSelectorResource:
   976  		res := source.GetResource()
   977  		return res, res != nil
   978  	case TimeSerie_FieldPathSelectorMetricKind:
   979  		return source.GetMetricKind(), source != nil
   980  	case TimeSerie_FieldPathSelectorValueType:
   981  		return source.GetValueType(), source != nil
   982  	case TimeSerie_FieldPathSelectorPoints:
   983  		res := source.GetPoints()
   984  		return res, res != nil
   985  	default:
   986  		panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fp.selector))
   987  	}
   988  }
   989  
   990  func (fp *TimeSerie_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
   991  	return fp.GetSingle(source.(*TimeSerie))
   992  }
   993  
   994  // GetDefault returns a default value of the field type
   995  func (fp *TimeSerie_FieldTerminalPath) GetDefault() interface{} {
   996  	switch fp.selector {
   997  	case TimeSerie_FieldPathSelectorKey:
   998  		return ([]byte)(nil)
   999  	case TimeSerie_FieldPathSelectorProject:
  1000  		return ""
  1001  	case TimeSerie_FieldPathSelectorRegion:
  1002  		return ""
  1003  	case TimeSerie_FieldPathSelectorUnit:
  1004  		return ""
  1005  	case TimeSerie_FieldPathSelectorMetric:
  1006  		return (*common.Metric)(nil)
  1007  	case TimeSerie_FieldPathSelectorResource:
  1008  		return (*common.MonitoredResource)(nil)
  1009  	case TimeSerie_FieldPathSelectorMetricKind:
  1010  		return metric_descriptor.MetricDescriptor_METRIC_KIND_UNSPECIFIED
  1011  	case TimeSerie_FieldPathSelectorValueType:
  1012  		return metric_descriptor.MetricDescriptor_VALUE_TYPE_UNSPECIFIED
  1013  	case TimeSerie_FieldPathSelectorPoints:
  1014  		return ([]*Point)(nil)
  1015  	default:
  1016  		panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fp.selector))
  1017  	}
  1018  }
  1019  
  1020  func (fp *TimeSerie_FieldTerminalPath) ClearValue(item *TimeSerie) {
  1021  	if item != nil {
  1022  		switch fp.selector {
  1023  		case TimeSerie_FieldPathSelectorKey:
  1024  			item.Key = nil
  1025  		case TimeSerie_FieldPathSelectorProject:
  1026  			item.Project = ""
  1027  		case TimeSerie_FieldPathSelectorRegion:
  1028  			item.Region = ""
  1029  		case TimeSerie_FieldPathSelectorUnit:
  1030  			item.Unit = ""
  1031  		case TimeSerie_FieldPathSelectorMetric:
  1032  			item.Metric = nil
  1033  		case TimeSerie_FieldPathSelectorResource:
  1034  			item.Resource = nil
  1035  		case TimeSerie_FieldPathSelectorMetricKind:
  1036  			item.MetricKind = metric_descriptor.MetricDescriptor_METRIC_KIND_UNSPECIFIED
  1037  		case TimeSerie_FieldPathSelectorValueType:
  1038  			item.ValueType = metric_descriptor.MetricDescriptor_VALUE_TYPE_UNSPECIFIED
  1039  		case TimeSerie_FieldPathSelectorPoints:
  1040  			item.Points = nil
  1041  		default:
  1042  			panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fp.selector))
  1043  		}
  1044  	}
  1045  }
  1046  
  1047  func (fp *TimeSerie_FieldTerminalPath) ClearValueRaw(item proto.Message) {
  1048  	fp.ClearValue(item.(*TimeSerie))
  1049  }
  1050  
  1051  // IsLeaf - whether field path is holds simple value
  1052  func (fp *TimeSerie_FieldTerminalPath) IsLeaf() bool {
  1053  	return fp.selector == TimeSerie_FieldPathSelectorKey ||
  1054  		fp.selector == TimeSerie_FieldPathSelectorProject ||
  1055  		fp.selector == TimeSerie_FieldPathSelectorRegion ||
  1056  		fp.selector == TimeSerie_FieldPathSelectorUnit ||
  1057  		fp.selector == TimeSerie_FieldPathSelectorMetricKind ||
  1058  		fp.selector == TimeSerie_FieldPathSelectorValueType
  1059  }
  1060  
  1061  func (fp *TimeSerie_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
  1062  	return []gotenobject.FieldPath{fp}
  1063  }
  1064  
  1065  func (fp *TimeSerie_FieldTerminalPath) WithIValue(value interface{}) TimeSerie_FieldPathValue {
  1066  	switch fp.selector {
  1067  	case TimeSerie_FieldPathSelectorKey:
  1068  		return &TimeSerie_FieldTerminalPathValue{TimeSerie_FieldTerminalPath: *fp, value: value.([]byte)}
  1069  	case TimeSerie_FieldPathSelectorProject:
  1070  		return &TimeSerie_FieldTerminalPathValue{TimeSerie_FieldTerminalPath: *fp, value: value.(string)}
  1071  	case TimeSerie_FieldPathSelectorRegion:
  1072  		return &TimeSerie_FieldTerminalPathValue{TimeSerie_FieldTerminalPath: *fp, value: value.(string)}
  1073  	case TimeSerie_FieldPathSelectorUnit:
  1074  		return &TimeSerie_FieldTerminalPathValue{TimeSerie_FieldTerminalPath: *fp, value: value.(string)}
  1075  	case TimeSerie_FieldPathSelectorMetric:
  1076  		return &TimeSerie_FieldTerminalPathValue{TimeSerie_FieldTerminalPath: *fp, value: value.(*common.Metric)}
  1077  	case TimeSerie_FieldPathSelectorResource:
  1078  		return &TimeSerie_FieldTerminalPathValue{TimeSerie_FieldTerminalPath: *fp, value: value.(*common.MonitoredResource)}
  1079  	case TimeSerie_FieldPathSelectorMetricKind:
  1080  		return &TimeSerie_FieldTerminalPathValue{TimeSerie_FieldTerminalPath: *fp, value: value.(metric_descriptor.MetricDescriptor_MetricKind)}
  1081  	case TimeSerie_FieldPathSelectorValueType:
  1082  		return &TimeSerie_FieldTerminalPathValue{TimeSerie_FieldTerminalPath: *fp, value: value.(metric_descriptor.MetricDescriptor_ValueType)}
  1083  	case TimeSerie_FieldPathSelectorPoints:
  1084  		return &TimeSerie_FieldTerminalPathValue{TimeSerie_FieldTerminalPath: *fp, value: value.([]*Point)}
  1085  	default:
  1086  		panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fp.selector))
  1087  	}
  1088  }
  1089  
  1090  func (fp *TimeSerie_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
  1091  	return fp.WithIValue(value)
  1092  }
  1093  
  1094  func (fp *TimeSerie_FieldTerminalPath) WithIArrayOfValues(values interface{}) TimeSerie_FieldPathArrayOfValues {
  1095  	fpaov := &TimeSerie_FieldTerminalPathArrayOfValues{TimeSerie_FieldTerminalPath: *fp}
  1096  	switch fp.selector {
  1097  	case TimeSerie_FieldPathSelectorKey:
  1098  		return &TimeSerie_FieldTerminalPathArrayOfValues{TimeSerie_FieldTerminalPath: *fp, values: values.([][]byte)}
  1099  	case TimeSerie_FieldPathSelectorProject:
  1100  		return &TimeSerie_FieldTerminalPathArrayOfValues{TimeSerie_FieldTerminalPath: *fp, values: values.([]string)}
  1101  	case TimeSerie_FieldPathSelectorRegion:
  1102  		return &TimeSerie_FieldTerminalPathArrayOfValues{TimeSerie_FieldTerminalPath: *fp, values: values.([]string)}
  1103  	case TimeSerie_FieldPathSelectorUnit:
  1104  		return &TimeSerie_FieldTerminalPathArrayOfValues{TimeSerie_FieldTerminalPath: *fp, values: values.([]string)}
  1105  	case TimeSerie_FieldPathSelectorMetric:
  1106  		return &TimeSerie_FieldTerminalPathArrayOfValues{TimeSerie_FieldTerminalPath: *fp, values: values.([]*common.Metric)}
  1107  	case TimeSerie_FieldPathSelectorResource:
  1108  		return &TimeSerie_FieldTerminalPathArrayOfValues{TimeSerie_FieldTerminalPath: *fp, values: values.([]*common.MonitoredResource)}
  1109  	case TimeSerie_FieldPathSelectorMetricKind:
  1110  		return &TimeSerie_FieldTerminalPathArrayOfValues{TimeSerie_FieldTerminalPath: *fp, values: values.([]metric_descriptor.MetricDescriptor_MetricKind)}
  1111  	case TimeSerie_FieldPathSelectorValueType:
  1112  		return &TimeSerie_FieldTerminalPathArrayOfValues{TimeSerie_FieldTerminalPath: *fp, values: values.([]metric_descriptor.MetricDescriptor_ValueType)}
  1113  	case TimeSerie_FieldPathSelectorPoints:
  1114  		return &TimeSerie_FieldTerminalPathArrayOfValues{TimeSerie_FieldTerminalPath: *fp, values: values.([][]*Point)}
  1115  	default:
  1116  		panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fp.selector))
  1117  	}
  1118  	return fpaov
  1119  }
  1120  
  1121  func (fp *TimeSerie_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
  1122  	return fp.WithIArrayOfValues(values)
  1123  }
  1124  
  1125  func (fp *TimeSerie_FieldTerminalPath) WithIArrayItemValue(value interface{}) TimeSerie_FieldPathArrayItemValue {
  1126  	switch fp.selector {
  1127  	case TimeSerie_FieldPathSelectorPoints:
  1128  		return &TimeSerie_FieldTerminalPathArrayItemValue{TimeSerie_FieldTerminalPath: *fp, value: value.(*Point)}
  1129  	default:
  1130  		panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fp.selector))
  1131  	}
  1132  }
  1133  
  1134  func (fp *TimeSerie_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
  1135  	return fp.WithIArrayItemValue(value)
  1136  }
  1137  
  1138  type TimeSerie_FieldSubPath struct {
  1139  	selector TimeSerie_FieldPathSelector
  1140  	subPath  gotenobject.FieldPath
  1141  }
  1142  
  1143  var _ TimeSerie_FieldPath = (*TimeSerie_FieldSubPath)(nil)
  1144  
  1145  func (fps *TimeSerie_FieldSubPath) Selector() TimeSerie_FieldPathSelector {
  1146  	return fps.selector
  1147  }
  1148  func (fps *TimeSerie_FieldSubPath) AsMetricSubPath() (common.Metric_FieldPath, bool) {
  1149  	res, ok := fps.subPath.(common.Metric_FieldPath)
  1150  	return res, ok
  1151  }
  1152  func (fps *TimeSerie_FieldSubPath) AsResourceSubPath() (common.MonitoredResource_FieldPath, bool) {
  1153  	res, ok := fps.subPath.(common.MonitoredResource_FieldPath)
  1154  	return res, ok
  1155  }
  1156  func (fps *TimeSerie_FieldSubPath) AsPointsSubPath() (Point_FieldPath, bool) {
  1157  	res, ok := fps.subPath.(Point_FieldPath)
  1158  	return res, ok
  1159  }
  1160  
  1161  // String returns path representation in proto convention
  1162  func (fps *TimeSerie_FieldSubPath) String() string {
  1163  	return fps.selector.String() + "." + fps.subPath.String()
  1164  }
  1165  
  1166  // JSONString returns path representation is JSON convention
  1167  func (fps *TimeSerie_FieldSubPath) JSONString() string {
  1168  	return strcase.ToLowerCamel(fps.selector.String()) + "." + fps.subPath.JSONString()
  1169  }
  1170  
  1171  // Get returns all values pointed by selected field from source TimeSerie
  1172  func (fps *TimeSerie_FieldSubPath) Get(source *TimeSerie) (values []interface{}) {
  1173  	switch fps.selector {
  1174  	case TimeSerie_FieldPathSelectorMetric:
  1175  		values = append(values, fps.subPath.GetRaw(source.GetMetric())...)
  1176  	case TimeSerie_FieldPathSelectorResource:
  1177  		values = append(values, fps.subPath.GetRaw(source.GetResource())...)
  1178  	case TimeSerie_FieldPathSelectorPoints:
  1179  		for _, item := range source.GetPoints() {
  1180  			values = append(values, fps.subPath.GetRaw(item)...)
  1181  		}
  1182  	default:
  1183  		panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fps.selector))
  1184  	}
  1185  	return
  1186  }
  1187  
  1188  func (fps *TimeSerie_FieldSubPath) GetRaw(source proto.Message) []interface{} {
  1189  	return fps.Get(source.(*TimeSerie))
  1190  }
  1191  
  1192  // GetSingle returns value of selected field from source TimeSerie
  1193  func (fps *TimeSerie_FieldSubPath) GetSingle(source *TimeSerie) (interface{}, bool) {
  1194  	switch fps.selector {
  1195  	case TimeSerie_FieldPathSelectorMetric:
  1196  		if source.GetMetric() == nil {
  1197  			return nil, false
  1198  		}
  1199  		return fps.subPath.GetSingleRaw(source.GetMetric())
  1200  	case TimeSerie_FieldPathSelectorResource:
  1201  		if source.GetResource() == nil {
  1202  			return nil, false
  1203  		}
  1204  		return fps.subPath.GetSingleRaw(source.GetResource())
  1205  	case TimeSerie_FieldPathSelectorPoints:
  1206  		if len(source.GetPoints()) == 0 {
  1207  			return nil, false
  1208  		}
  1209  		return fps.subPath.GetSingleRaw(source.GetPoints()[0])
  1210  	default:
  1211  		panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fps.selector))
  1212  	}
  1213  }
  1214  
  1215  func (fps *TimeSerie_FieldSubPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
  1216  	return fps.GetSingle(source.(*TimeSerie))
  1217  }
  1218  
  1219  // GetDefault returns a default value of the field type
  1220  func (fps *TimeSerie_FieldSubPath) GetDefault() interface{} {
  1221  	return fps.subPath.GetDefault()
  1222  }
  1223  
  1224  func (fps *TimeSerie_FieldSubPath) ClearValue(item *TimeSerie) {
  1225  	if item != nil {
  1226  		switch fps.selector {
  1227  		case TimeSerie_FieldPathSelectorMetric:
  1228  			fps.subPath.ClearValueRaw(item.Metric)
  1229  		case TimeSerie_FieldPathSelectorResource:
  1230  			fps.subPath.ClearValueRaw(item.Resource)
  1231  		case TimeSerie_FieldPathSelectorPoints:
  1232  			for _, subItem := range item.Points {
  1233  				fps.subPath.ClearValueRaw(subItem)
  1234  			}
  1235  		default:
  1236  			panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fps.selector))
  1237  		}
  1238  	}
  1239  }
  1240  
  1241  func (fps *TimeSerie_FieldSubPath) ClearValueRaw(item proto.Message) {
  1242  	fps.ClearValue(item.(*TimeSerie))
  1243  }
  1244  
  1245  // IsLeaf - whether field path is holds simple value
  1246  func (fps *TimeSerie_FieldSubPath) IsLeaf() bool {
  1247  	return fps.subPath.IsLeaf()
  1248  }
  1249  
  1250  func (fps *TimeSerie_FieldSubPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
  1251  	iPaths := []gotenobject.FieldPath{&TimeSerie_FieldTerminalPath{selector: fps.selector}}
  1252  	iPaths = append(iPaths, fps.subPath.SplitIntoTerminalIPaths()...)
  1253  	return iPaths
  1254  }
  1255  
  1256  func (fps *TimeSerie_FieldSubPath) WithIValue(value interface{}) TimeSerie_FieldPathValue {
  1257  	return &TimeSerie_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
  1258  }
  1259  
  1260  func (fps *TimeSerie_FieldSubPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
  1261  	return fps.WithIValue(value)
  1262  }
  1263  
  1264  func (fps *TimeSerie_FieldSubPath) WithIArrayOfValues(values interface{}) TimeSerie_FieldPathArrayOfValues {
  1265  	return &TimeSerie_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
  1266  }
  1267  
  1268  func (fps *TimeSerie_FieldSubPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
  1269  	return fps.WithIArrayOfValues(values)
  1270  }
  1271  
  1272  func (fps *TimeSerie_FieldSubPath) WithIArrayItemValue(value interface{}) TimeSerie_FieldPathArrayItemValue {
  1273  	return &TimeSerie_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
  1274  }
  1275  
  1276  func (fps *TimeSerie_FieldSubPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
  1277  	return fps.WithIArrayItemValue(value)
  1278  }
  1279  
  1280  // TimeSerie_FieldPathValue allows storing values for TimeSerie fields according to their type
  1281  type TimeSerie_FieldPathValue interface {
  1282  	TimeSerie_FieldPath
  1283  	gotenobject.FieldPathValue
  1284  	SetTo(target **TimeSerie)
  1285  	CompareWith(*TimeSerie) (cmp int, comparable bool)
  1286  }
  1287  
  1288  func ParseTimeSerie_FieldPathValue(pathStr, valueStr string) (TimeSerie_FieldPathValue, error) {
  1289  	fp, err := ParseTimeSerie_FieldPath(pathStr)
  1290  	if err != nil {
  1291  		return nil, err
  1292  	}
  1293  	fpv, err := gotenobject.ParseFieldPathValue(fp, valueStr)
  1294  	if err != nil {
  1295  		return nil, status.Errorf(codes.InvalidArgument, "error parsing TimeSerie field path value from %s: %v", valueStr, err)
  1296  	}
  1297  	return fpv.(TimeSerie_FieldPathValue), nil
  1298  }
  1299  
  1300  func MustParseTimeSerie_FieldPathValue(pathStr, valueStr string) TimeSerie_FieldPathValue {
  1301  	fpv, err := ParseTimeSerie_FieldPathValue(pathStr, valueStr)
  1302  	if err != nil {
  1303  		panic(err)
  1304  	}
  1305  	return fpv
  1306  }
  1307  
  1308  type TimeSerie_FieldTerminalPathValue struct {
  1309  	TimeSerie_FieldTerminalPath
  1310  	value interface{}
  1311  }
  1312  
  1313  var _ TimeSerie_FieldPathValue = (*TimeSerie_FieldTerminalPathValue)(nil)
  1314  
  1315  // GetRawValue returns raw value stored under selected path for 'TimeSerie' as interface{}
  1316  func (fpv *TimeSerie_FieldTerminalPathValue) GetRawValue() interface{} {
  1317  	return fpv.value
  1318  }
  1319  func (fpv *TimeSerie_FieldTerminalPathValue) AsKeyValue() ([]byte, bool) {
  1320  	res, ok := fpv.value.([]byte)
  1321  	return res, ok
  1322  }
  1323  func (fpv *TimeSerie_FieldTerminalPathValue) AsProjectValue() (string, bool) {
  1324  	res, ok := fpv.value.(string)
  1325  	return res, ok
  1326  }
  1327  func (fpv *TimeSerie_FieldTerminalPathValue) AsRegionValue() (string, bool) {
  1328  	res, ok := fpv.value.(string)
  1329  	return res, ok
  1330  }
  1331  func (fpv *TimeSerie_FieldTerminalPathValue) AsUnitValue() (string, bool) {
  1332  	res, ok := fpv.value.(string)
  1333  	return res, ok
  1334  }
  1335  func (fpv *TimeSerie_FieldTerminalPathValue) AsMetricValue() (*common.Metric, bool) {
  1336  	res, ok := fpv.value.(*common.Metric)
  1337  	return res, ok
  1338  }
  1339  func (fpv *TimeSerie_FieldTerminalPathValue) AsResourceValue() (*common.MonitoredResource, bool) {
  1340  	res, ok := fpv.value.(*common.MonitoredResource)
  1341  	return res, ok
  1342  }
  1343  func (fpv *TimeSerie_FieldTerminalPathValue) AsMetricKindValue() (metric_descriptor.MetricDescriptor_MetricKind, bool) {
  1344  	res, ok := fpv.value.(metric_descriptor.MetricDescriptor_MetricKind)
  1345  	return res, ok
  1346  }
  1347  func (fpv *TimeSerie_FieldTerminalPathValue) AsValueTypeValue() (metric_descriptor.MetricDescriptor_ValueType, bool) {
  1348  	res, ok := fpv.value.(metric_descriptor.MetricDescriptor_ValueType)
  1349  	return res, ok
  1350  }
  1351  func (fpv *TimeSerie_FieldTerminalPathValue) AsPointsValue() ([]*Point, bool) {
  1352  	res, ok := fpv.value.([]*Point)
  1353  	return res, ok
  1354  }
  1355  
  1356  // SetTo stores value for selected field for object TimeSerie
  1357  func (fpv *TimeSerie_FieldTerminalPathValue) SetTo(target **TimeSerie) {
  1358  	if *target == nil {
  1359  		*target = new(TimeSerie)
  1360  	}
  1361  	switch fpv.selector {
  1362  	case TimeSerie_FieldPathSelectorKey:
  1363  		(*target).Key = fpv.value.([]byte)
  1364  	case TimeSerie_FieldPathSelectorProject:
  1365  		(*target).Project = fpv.value.(string)
  1366  	case TimeSerie_FieldPathSelectorRegion:
  1367  		(*target).Region = fpv.value.(string)
  1368  	case TimeSerie_FieldPathSelectorUnit:
  1369  		(*target).Unit = fpv.value.(string)
  1370  	case TimeSerie_FieldPathSelectorMetric:
  1371  		(*target).Metric = fpv.value.(*common.Metric)
  1372  	case TimeSerie_FieldPathSelectorResource:
  1373  		(*target).Resource = fpv.value.(*common.MonitoredResource)
  1374  	case TimeSerie_FieldPathSelectorMetricKind:
  1375  		(*target).MetricKind = fpv.value.(metric_descriptor.MetricDescriptor_MetricKind)
  1376  	case TimeSerie_FieldPathSelectorValueType:
  1377  		(*target).ValueType = fpv.value.(metric_descriptor.MetricDescriptor_ValueType)
  1378  	case TimeSerie_FieldPathSelectorPoints:
  1379  		(*target).Points = fpv.value.([]*Point)
  1380  	default:
  1381  		panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fpv.selector))
  1382  	}
  1383  }
  1384  
  1385  func (fpv *TimeSerie_FieldTerminalPathValue) SetToRaw(target proto.Message) {
  1386  	typedObject := target.(*TimeSerie)
  1387  	fpv.SetTo(&typedObject)
  1388  }
  1389  
  1390  // CompareWith compares value in the 'TimeSerie_FieldTerminalPathValue' with the value under path in 'TimeSerie'.
  1391  func (fpv *TimeSerie_FieldTerminalPathValue) CompareWith(source *TimeSerie) (int, bool) {
  1392  	switch fpv.selector {
  1393  	case TimeSerie_FieldPathSelectorKey:
  1394  		return 0, false
  1395  	case TimeSerie_FieldPathSelectorProject:
  1396  		leftValue := fpv.value.(string)
  1397  		rightValue := source.GetProject()
  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_FieldPathSelectorRegion:
  1406  		leftValue := fpv.value.(string)
  1407  		rightValue := source.GetRegion()
  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_FieldPathSelectorUnit:
  1416  		leftValue := fpv.value.(string)
  1417  		rightValue := source.GetUnit()
  1418  		if (leftValue) == (rightValue) {
  1419  			return 0, true
  1420  		} else if (leftValue) < (rightValue) {
  1421  			return -1, true
  1422  		} else {
  1423  			return 1, true
  1424  		}
  1425  	case TimeSerie_FieldPathSelectorMetric:
  1426  		return 0, false
  1427  	case TimeSerie_FieldPathSelectorResource:
  1428  		return 0, false
  1429  	case TimeSerie_FieldPathSelectorMetricKind:
  1430  		leftValue := fpv.value.(metric_descriptor.MetricDescriptor_MetricKind)
  1431  		rightValue := source.GetMetricKind()
  1432  		if (leftValue) == (rightValue) {
  1433  			return 0, true
  1434  		} else if (leftValue) < (rightValue) {
  1435  			return -1, true
  1436  		} else {
  1437  			return 1, true
  1438  		}
  1439  	case TimeSerie_FieldPathSelectorValueType:
  1440  		leftValue := fpv.value.(metric_descriptor.MetricDescriptor_ValueType)
  1441  		rightValue := source.GetValueType()
  1442  		if (leftValue) == (rightValue) {
  1443  			return 0, true
  1444  		} else if (leftValue) < (rightValue) {
  1445  			return -1, true
  1446  		} else {
  1447  			return 1, true
  1448  		}
  1449  	case TimeSerie_FieldPathSelectorPoints:
  1450  		return 0, false
  1451  	default:
  1452  		panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fpv.selector))
  1453  	}
  1454  }
  1455  
  1456  func (fpv *TimeSerie_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
  1457  	return fpv.CompareWith(source.(*TimeSerie))
  1458  }
  1459  
  1460  type TimeSerie_FieldSubPathValue struct {
  1461  	TimeSerie_FieldPath
  1462  	subPathValue gotenobject.FieldPathValue
  1463  }
  1464  
  1465  var _ TimeSerie_FieldPathValue = (*TimeSerie_FieldSubPathValue)(nil)
  1466  
  1467  func (fpvs *TimeSerie_FieldSubPathValue) AsMetricPathValue() (common.Metric_FieldPathValue, bool) {
  1468  	res, ok := fpvs.subPathValue.(common.Metric_FieldPathValue)
  1469  	return res, ok
  1470  }
  1471  func (fpvs *TimeSerie_FieldSubPathValue) AsResourcePathValue() (common.MonitoredResource_FieldPathValue, bool) {
  1472  	res, ok := fpvs.subPathValue.(common.MonitoredResource_FieldPathValue)
  1473  	return res, ok
  1474  }
  1475  func (fpvs *TimeSerie_FieldSubPathValue) AsPointsPathValue() (Point_FieldPathValue, bool) {
  1476  	res, ok := fpvs.subPathValue.(Point_FieldPathValue)
  1477  	return res, ok
  1478  }
  1479  
  1480  func (fpvs *TimeSerie_FieldSubPathValue) SetTo(target **TimeSerie) {
  1481  	if *target == nil {
  1482  		*target = new(TimeSerie)
  1483  	}
  1484  	switch fpvs.Selector() {
  1485  	case TimeSerie_FieldPathSelectorMetric:
  1486  		fpvs.subPathValue.(common.Metric_FieldPathValue).SetTo(&(*target).Metric)
  1487  	case TimeSerie_FieldPathSelectorResource:
  1488  		fpvs.subPathValue.(common.MonitoredResource_FieldPathValue).SetTo(&(*target).Resource)
  1489  	case TimeSerie_FieldPathSelectorPoints:
  1490  		panic("FieldPath setter is unsupported for array subpaths")
  1491  	default:
  1492  		panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fpvs.Selector()))
  1493  	}
  1494  }
  1495  
  1496  func (fpvs *TimeSerie_FieldSubPathValue) SetToRaw(target proto.Message) {
  1497  	typedObject := target.(*TimeSerie)
  1498  	fpvs.SetTo(&typedObject)
  1499  }
  1500  
  1501  func (fpvs *TimeSerie_FieldSubPathValue) GetRawValue() interface{} {
  1502  	return fpvs.subPathValue.GetRawValue()
  1503  }
  1504  
  1505  func (fpvs *TimeSerie_FieldSubPathValue) CompareWith(source *TimeSerie) (int, bool) {
  1506  	switch fpvs.Selector() {
  1507  	case TimeSerie_FieldPathSelectorMetric:
  1508  		return fpvs.subPathValue.(common.Metric_FieldPathValue).CompareWith(source.GetMetric())
  1509  	case TimeSerie_FieldPathSelectorResource:
  1510  		return fpvs.subPathValue.(common.MonitoredResource_FieldPathValue).CompareWith(source.GetResource())
  1511  	case TimeSerie_FieldPathSelectorPoints:
  1512  		return 0, false // repeated field
  1513  	default:
  1514  		panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fpvs.Selector()))
  1515  	}
  1516  }
  1517  
  1518  func (fpvs *TimeSerie_FieldSubPathValue) CompareWithRaw(source proto.Message) (int, bool) {
  1519  	return fpvs.CompareWith(source.(*TimeSerie))
  1520  }
  1521  
  1522  // TimeSerie_FieldPathArrayItemValue allows storing single item in Path-specific values for TimeSerie according to their type
  1523  // Present only for array (repeated) types.
  1524  type TimeSerie_FieldPathArrayItemValue interface {
  1525  	gotenobject.FieldPathArrayItemValue
  1526  	TimeSerie_FieldPath
  1527  	ContainsValue(*TimeSerie) bool
  1528  }
  1529  
  1530  // ParseTimeSerie_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
  1531  func ParseTimeSerie_FieldPathArrayItemValue(pathStr, valueStr string) (TimeSerie_FieldPathArrayItemValue, error) {
  1532  	fp, err := ParseTimeSerie_FieldPath(pathStr)
  1533  	if err != nil {
  1534  		return nil, err
  1535  	}
  1536  	fpaiv, err := gotenobject.ParseFieldPathArrayItemValue(fp, valueStr)
  1537  	if err != nil {
  1538  		return nil, status.Errorf(codes.InvalidArgument, "error parsing TimeSerie field path array item value from %s: %v", valueStr, err)
  1539  	}
  1540  	return fpaiv.(TimeSerie_FieldPathArrayItemValue), nil
  1541  }
  1542  
  1543  func MustParseTimeSerie_FieldPathArrayItemValue(pathStr, valueStr string) TimeSerie_FieldPathArrayItemValue {
  1544  	fpaiv, err := ParseTimeSerie_FieldPathArrayItemValue(pathStr, valueStr)
  1545  	if err != nil {
  1546  		panic(err)
  1547  	}
  1548  	return fpaiv
  1549  }
  1550  
  1551  type TimeSerie_FieldTerminalPathArrayItemValue struct {
  1552  	TimeSerie_FieldTerminalPath
  1553  	value interface{}
  1554  }
  1555  
  1556  var _ TimeSerie_FieldPathArrayItemValue = (*TimeSerie_FieldTerminalPathArrayItemValue)(nil)
  1557  
  1558  // GetRawValue returns stored element value for array in object TimeSerie as interface{}
  1559  func (fpaiv *TimeSerie_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
  1560  	return fpaiv.value
  1561  }
  1562  func (fpaiv *TimeSerie_FieldTerminalPathArrayItemValue) AsPointsItemValue() (*Point, bool) {
  1563  	res, ok := fpaiv.value.(*Point)
  1564  	return res, ok
  1565  }
  1566  
  1567  func (fpaiv *TimeSerie_FieldTerminalPathArrayItemValue) GetSingle(source *TimeSerie) (interface{}, bool) {
  1568  	return nil, false
  1569  }
  1570  
  1571  func (fpaiv *TimeSerie_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
  1572  	return fpaiv.GetSingle(source.(*TimeSerie))
  1573  }
  1574  
  1575  // Contains returns a boolean indicating if value that is being held is present in given 'TimeSerie'
  1576  func (fpaiv *TimeSerie_FieldTerminalPathArrayItemValue) ContainsValue(source *TimeSerie) bool {
  1577  	slice := fpaiv.TimeSerie_FieldTerminalPath.Get(source)
  1578  	for _, v := range slice {
  1579  		if asProtoMsg, ok := fpaiv.value.(proto.Message); ok {
  1580  			if proto.Equal(asProtoMsg, v.(proto.Message)) {
  1581  				return true
  1582  			}
  1583  		} else if reflect.DeepEqual(v, fpaiv.value) {
  1584  			return true
  1585  		}
  1586  	}
  1587  	return false
  1588  }
  1589  
  1590  type TimeSerie_FieldSubPathArrayItemValue struct {
  1591  	TimeSerie_FieldPath
  1592  	subPathItemValue gotenobject.FieldPathArrayItemValue
  1593  }
  1594  
  1595  // GetRawValue returns stored array item value
  1596  func (fpaivs *TimeSerie_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
  1597  	return fpaivs.subPathItemValue.GetRawItemValue()
  1598  }
  1599  func (fpaivs *TimeSerie_FieldSubPathArrayItemValue) AsMetricPathItemValue() (common.Metric_FieldPathArrayItemValue, bool) {
  1600  	res, ok := fpaivs.subPathItemValue.(common.Metric_FieldPathArrayItemValue)
  1601  	return res, ok
  1602  }
  1603  func (fpaivs *TimeSerie_FieldSubPathArrayItemValue) AsResourcePathItemValue() (common.MonitoredResource_FieldPathArrayItemValue, bool) {
  1604  	res, ok := fpaivs.subPathItemValue.(common.MonitoredResource_FieldPathArrayItemValue)
  1605  	return res, ok
  1606  }
  1607  func (fpaivs *TimeSerie_FieldSubPathArrayItemValue) AsPointsPathItemValue() (Point_FieldPathArrayItemValue, bool) {
  1608  	res, ok := fpaivs.subPathItemValue.(Point_FieldPathArrayItemValue)
  1609  	return res, ok
  1610  }
  1611  
  1612  // Contains returns a boolean indicating if value that is being held is present in given 'TimeSerie'
  1613  func (fpaivs *TimeSerie_FieldSubPathArrayItemValue) ContainsValue(source *TimeSerie) bool {
  1614  	switch fpaivs.Selector() {
  1615  	case TimeSerie_FieldPathSelectorMetric:
  1616  		return fpaivs.subPathItemValue.(common.Metric_FieldPathArrayItemValue).ContainsValue(source.GetMetric())
  1617  	case TimeSerie_FieldPathSelectorResource:
  1618  		return fpaivs.subPathItemValue.(common.MonitoredResource_FieldPathArrayItemValue).ContainsValue(source.GetResource())
  1619  	case TimeSerie_FieldPathSelectorPoints:
  1620  		return false // repeated/map field
  1621  	default:
  1622  		panic(fmt.Sprintf("Invalid selector for TimeSerie: %d", fpaivs.Selector()))
  1623  	}
  1624  }
  1625  
  1626  // TimeSerie_FieldPathArrayOfValues allows storing slice of values for TimeSerie fields according to their type
  1627  type TimeSerie_FieldPathArrayOfValues interface {
  1628  	gotenobject.FieldPathArrayOfValues
  1629  	TimeSerie_FieldPath
  1630  }
  1631  
  1632  func ParseTimeSerie_FieldPathArrayOfValues(pathStr, valuesStr string) (TimeSerie_FieldPathArrayOfValues, error) {
  1633  	fp, err := ParseTimeSerie_FieldPath(pathStr)
  1634  	if err != nil {
  1635  		return nil, err
  1636  	}
  1637  	fpaov, err := gotenobject.ParseFieldPathArrayOfValues(fp, valuesStr)
  1638  	if err != nil {
  1639  		return nil, status.Errorf(codes.InvalidArgument, "error parsing TimeSerie field path array of values from %s: %v", valuesStr, err)
  1640  	}
  1641  	return fpaov.(TimeSerie_FieldPathArrayOfValues), nil
  1642  }
  1643  
  1644  func MustParseTimeSerie_FieldPathArrayOfValues(pathStr, valuesStr string) TimeSerie_FieldPathArrayOfValues {
  1645  	fpaov, err := ParseTimeSerie_FieldPathArrayOfValues(pathStr, valuesStr)
  1646  	if err != nil {
  1647  		panic(err)
  1648  	}
  1649  	return fpaov
  1650  }
  1651  
  1652  type TimeSerie_FieldTerminalPathArrayOfValues struct {
  1653  	TimeSerie_FieldTerminalPath
  1654  	values interface{}
  1655  }
  1656  
  1657  var _ TimeSerie_FieldPathArrayOfValues = (*TimeSerie_FieldTerminalPathArrayOfValues)(nil)
  1658  
  1659  func (fpaov *TimeSerie_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
  1660  	switch fpaov.selector {
  1661  	case TimeSerie_FieldPathSelectorKey:
  1662  		for _, v := range fpaov.values.([][]byte) {
  1663  			values = append(values, v)
  1664  		}
  1665  	case TimeSerie_FieldPathSelectorProject:
  1666  		for _, v := range fpaov.values.([]string) {
  1667  			values = append(values, v)
  1668  		}
  1669  	case TimeSerie_FieldPathSelectorRegion:
  1670  		for _, v := range fpaov.values.([]string) {
  1671  			values = append(values, v)
  1672  		}
  1673  	case TimeSerie_FieldPathSelectorUnit:
  1674  		for _, v := range fpaov.values.([]string) {
  1675  			values = append(values, v)
  1676  		}
  1677  	case TimeSerie_FieldPathSelectorMetric:
  1678  		for _, v := range fpaov.values.([]*common.Metric) {
  1679  			values = append(values, v)
  1680  		}
  1681  	case TimeSerie_FieldPathSelectorResource:
  1682  		for _, v := range fpaov.values.([]*common.MonitoredResource) {
  1683  			values = append(values, v)
  1684  		}
  1685  	case TimeSerie_FieldPathSelectorMetricKind:
  1686  		for _, v := range fpaov.values.([]metric_descriptor.MetricDescriptor_MetricKind) {
  1687  			values = append(values, v)
  1688  		}
  1689  	case TimeSerie_FieldPathSelectorValueType:
  1690  		for _, v := range fpaov.values.([]metric_descriptor.MetricDescriptor_ValueType) {
  1691  			values = append(values, v)
  1692  		}
  1693  	case TimeSerie_FieldPathSelectorPoints:
  1694  		for _, v := range fpaov.values.([][]*Point) {
  1695  			values = append(values, v)
  1696  		}
  1697  	}
  1698  	return
  1699  }
  1700  func (fpaov *TimeSerie_FieldTerminalPathArrayOfValues) AsKeyArrayOfValues() ([][]byte, bool) {
  1701  	res, ok := fpaov.values.([][]byte)
  1702  	return res, ok
  1703  }
  1704  func (fpaov *TimeSerie_FieldTerminalPathArrayOfValues) AsProjectArrayOfValues() ([]string, bool) {
  1705  	res, ok := fpaov.values.([]string)
  1706  	return res, ok
  1707  }
  1708  func (fpaov *TimeSerie_FieldTerminalPathArrayOfValues) AsRegionArrayOfValues() ([]string, bool) {
  1709  	res, ok := fpaov.values.([]string)
  1710  	return res, ok
  1711  }
  1712  func (fpaov *TimeSerie_FieldTerminalPathArrayOfValues) AsUnitArrayOfValues() ([]string, bool) {
  1713  	res, ok := fpaov.values.([]string)
  1714  	return res, ok
  1715  }
  1716  func (fpaov *TimeSerie_FieldTerminalPathArrayOfValues) AsMetricArrayOfValues() ([]*common.Metric, bool) {
  1717  	res, ok := fpaov.values.([]*common.Metric)
  1718  	return res, ok
  1719  }
  1720  func (fpaov *TimeSerie_FieldTerminalPathArrayOfValues) AsResourceArrayOfValues() ([]*common.MonitoredResource, bool) {
  1721  	res, ok := fpaov.values.([]*common.MonitoredResource)
  1722  	return res, ok
  1723  }
  1724  func (fpaov *TimeSerie_FieldTerminalPathArrayOfValues) AsMetricKindArrayOfValues() ([]metric_descriptor.MetricDescriptor_MetricKind, bool) {
  1725  	res, ok := fpaov.values.([]metric_descriptor.MetricDescriptor_MetricKind)
  1726  	return res, ok
  1727  }
  1728  func (fpaov *TimeSerie_FieldTerminalPathArrayOfValues) AsValueTypeArrayOfValues() ([]metric_descriptor.MetricDescriptor_ValueType, bool) {
  1729  	res, ok := fpaov.values.([]metric_descriptor.MetricDescriptor_ValueType)
  1730  	return res, ok
  1731  }
  1732  func (fpaov *TimeSerie_FieldTerminalPathArrayOfValues) AsPointsArrayOfValues() ([][]*Point, bool) {
  1733  	res, ok := fpaov.values.([][]*Point)
  1734  	return res, ok
  1735  }
  1736  
  1737  type TimeSerie_FieldSubPathArrayOfValues struct {
  1738  	TimeSerie_FieldPath
  1739  	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
  1740  }
  1741  
  1742  var _ TimeSerie_FieldPathArrayOfValues = (*TimeSerie_FieldSubPathArrayOfValues)(nil)
  1743  
  1744  func (fpsaov *TimeSerie_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
  1745  	return fpsaov.subPathArrayOfValues.GetRawValues()
  1746  }
  1747  func (fpsaov *TimeSerie_FieldSubPathArrayOfValues) AsMetricPathArrayOfValues() (common.Metric_FieldPathArrayOfValues, bool) {
  1748  	res, ok := fpsaov.subPathArrayOfValues.(common.Metric_FieldPathArrayOfValues)
  1749  	return res, ok
  1750  }
  1751  func (fpsaov *TimeSerie_FieldSubPathArrayOfValues) AsResourcePathArrayOfValues() (common.MonitoredResource_FieldPathArrayOfValues, bool) {
  1752  	res, ok := fpsaov.subPathArrayOfValues.(common.MonitoredResource_FieldPathArrayOfValues)
  1753  	return res, ok
  1754  }
  1755  func (fpsaov *TimeSerie_FieldSubPathArrayOfValues) AsPointsPathArrayOfValues() (Point_FieldPathArrayOfValues, bool) {
  1756  	res, ok := fpsaov.subPathArrayOfValues.(Point_FieldPathArrayOfValues)
  1757  	return res, ok
  1758  }
  1759  
  1760  // FieldPath provides implementation to handle
  1761  // https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/field_mask.proto
  1762  type BulkTimeSeries_FieldPath interface {
  1763  	gotenobject.FieldPath
  1764  	Selector() BulkTimeSeries_FieldPathSelector
  1765  	Get(source *BulkTimeSeries) []interface{}
  1766  	GetSingle(source *BulkTimeSeries) (interface{}, bool)
  1767  	ClearValue(item *BulkTimeSeries)
  1768  
  1769  	// Those methods build corresponding BulkTimeSeries_FieldPathValue
  1770  	// (or array of values) and holds passed value. Panics if injected type is incorrect.
  1771  	WithIValue(value interface{}) BulkTimeSeries_FieldPathValue
  1772  	WithIArrayOfValues(values interface{}) BulkTimeSeries_FieldPathArrayOfValues
  1773  	WithIArrayItemValue(value interface{}) BulkTimeSeries_FieldPathArrayItemValue
  1774  }
  1775  
  1776  type BulkTimeSeries_FieldPathSelector int32
  1777  
  1778  const (
  1779  	BulkTimeSeries_FieldPathSelectorTimeSeries  BulkTimeSeries_FieldPathSelector = 0
  1780  	BulkTimeSeries_FieldPathSelectorPhantomFlag BulkTimeSeries_FieldPathSelector = 1
  1781  )
  1782  
  1783  func (s BulkTimeSeries_FieldPathSelector) String() string {
  1784  	switch s {
  1785  	case BulkTimeSeries_FieldPathSelectorTimeSeries:
  1786  		return "time_series"
  1787  	case BulkTimeSeries_FieldPathSelectorPhantomFlag:
  1788  		return "phantom_flag"
  1789  	default:
  1790  		panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", s))
  1791  	}
  1792  }
  1793  
  1794  func BuildBulkTimeSeries_FieldPath(fp gotenobject.RawFieldPath) (BulkTimeSeries_FieldPath, error) {
  1795  	if len(fp) == 0 {
  1796  		return nil, status.Error(codes.InvalidArgument, "empty field path for object BulkTimeSeries")
  1797  	}
  1798  	if len(fp) == 1 {
  1799  		switch fp[0] {
  1800  		case "time_series", "timeSeries", "time-series":
  1801  			return &BulkTimeSeries_FieldTerminalPath{selector: BulkTimeSeries_FieldPathSelectorTimeSeries}, nil
  1802  		case "phantom_flag", "phantomFlag", "phantom-flag":
  1803  			return &BulkTimeSeries_FieldTerminalPath{selector: BulkTimeSeries_FieldPathSelectorPhantomFlag}, nil
  1804  		}
  1805  	} else {
  1806  		switch fp[0] {
  1807  		case "time_series", "timeSeries", "time-series":
  1808  			if subpath, err := BuildTimeSerie_FieldPath(fp[1:]); err != nil {
  1809  				return nil, err
  1810  			} else {
  1811  				return &BulkTimeSeries_FieldSubPath{selector: BulkTimeSeries_FieldPathSelectorTimeSeries, subPath: subpath}, nil
  1812  			}
  1813  		}
  1814  	}
  1815  	return nil, status.Errorf(codes.InvalidArgument, "unknown field path '%s' for object BulkTimeSeries", fp)
  1816  }
  1817  
  1818  func ParseBulkTimeSeries_FieldPath(rawField string) (BulkTimeSeries_FieldPath, error) {
  1819  	fp, err := gotenobject.ParseRawFieldPath(rawField)
  1820  	if err != nil {
  1821  		return nil, err
  1822  	}
  1823  	return BuildBulkTimeSeries_FieldPath(fp)
  1824  }
  1825  
  1826  func MustParseBulkTimeSeries_FieldPath(rawField string) BulkTimeSeries_FieldPath {
  1827  	fp, err := ParseBulkTimeSeries_FieldPath(rawField)
  1828  	if err != nil {
  1829  		panic(err)
  1830  	}
  1831  	return fp
  1832  }
  1833  
  1834  type BulkTimeSeries_FieldTerminalPath struct {
  1835  	selector BulkTimeSeries_FieldPathSelector
  1836  }
  1837  
  1838  var _ BulkTimeSeries_FieldPath = (*BulkTimeSeries_FieldTerminalPath)(nil)
  1839  
  1840  func (fp *BulkTimeSeries_FieldTerminalPath) Selector() BulkTimeSeries_FieldPathSelector {
  1841  	return fp.selector
  1842  }
  1843  
  1844  // String returns path representation in proto convention
  1845  func (fp *BulkTimeSeries_FieldTerminalPath) String() string {
  1846  	return fp.selector.String()
  1847  }
  1848  
  1849  // JSONString returns path representation is JSON convention
  1850  func (fp *BulkTimeSeries_FieldTerminalPath) JSONString() string {
  1851  	return strcase.ToLowerCamel(fp.String())
  1852  }
  1853  
  1854  // Get returns all values pointed by specific field from source BulkTimeSeries
  1855  func (fp *BulkTimeSeries_FieldTerminalPath) Get(source *BulkTimeSeries) (values []interface{}) {
  1856  	if source != nil {
  1857  		switch fp.selector {
  1858  		case BulkTimeSeries_FieldPathSelectorTimeSeries:
  1859  			for _, value := range source.GetTimeSeries() {
  1860  				values = append(values, value)
  1861  			}
  1862  		case BulkTimeSeries_FieldPathSelectorPhantomFlag:
  1863  			values = append(values, source.PhantomFlag)
  1864  		default:
  1865  			panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fp.selector))
  1866  		}
  1867  	}
  1868  	return
  1869  }
  1870  
  1871  func (fp *BulkTimeSeries_FieldTerminalPath) GetRaw(source proto.Message) []interface{} {
  1872  	return fp.Get(source.(*BulkTimeSeries))
  1873  }
  1874  
  1875  // GetSingle returns value pointed by specific field of from source BulkTimeSeries
  1876  func (fp *BulkTimeSeries_FieldTerminalPath) GetSingle(source *BulkTimeSeries) (interface{}, bool) {
  1877  	switch fp.selector {
  1878  	case BulkTimeSeries_FieldPathSelectorTimeSeries:
  1879  		res := source.GetTimeSeries()
  1880  		return res, res != nil
  1881  	case BulkTimeSeries_FieldPathSelectorPhantomFlag:
  1882  		return source.GetPhantomFlag(), source != nil
  1883  	default:
  1884  		panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fp.selector))
  1885  	}
  1886  }
  1887  
  1888  func (fp *BulkTimeSeries_FieldTerminalPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
  1889  	return fp.GetSingle(source.(*BulkTimeSeries))
  1890  }
  1891  
  1892  // GetDefault returns a default value of the field type
  1893  func (fp *BulkTimeSeries_FieldTerminalPath) GetDefault() interface{} {
  1894  	switch fp.selector {
  1895  	case BulkTimeSeries_FieldPathSelectorTimeSeries:
  1896  		return ([]*TimeSerie)(nil)
  1897  	case BulkTimeSeries_FieldPathSelectorPhantomFlag:
  1898  		return false
  1899  	default:
  1900  		panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fp.selector))
  1901  	}
  1902  }
  1903  
  1904  func (fp *BulkTimeSeries_FieldTerminalPath) ClearValue(item *BulkTimeSeries) {
  1905  	if item != nil {
  1906  		switch fp.selector {
  1907  		case BulkTimeSeries_FieldPathSelectorTimeSeries:
  1908  			item.TimeSeries = nil
  1909  		case BulkTimeSeries_FieldPathSelectorPhantomFlag:
  1910  			item.PhantomFlag = false
  1911  		default:
  1912  			panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fp.selector))
  1913  		}
  1914  	}
  1915  }
  1916  
  1917  func (fp *BulkTimeSeries_FieldTerminalPath) ClearValueRaw(item proto.Message) {
  1918  	fp.ClearValue(item.(*BulkTimeSeries))
  1919  }
  1920  
  1921  // IsLeaf - whether field path is holds simple value
  1922  func (fp *BulkTimeSeries_FieldTerminalPath) IsLeaf() bool {
  1923  	return fp.selector == BulkTimeSeries_FieldPathSelectorPhantomFlag
  1924  }
  1925  
  1926  func (fp *BulkTimeSeries_FieldTerminalPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
  1927  	return []gotenobject.FieldPath{fp}
  1928  }
  1929  
  1930  func (fp *BulkTimeSeries_FieldTerminalPath) WithIValue(value interface{}) BulkTimeSeries_FieldPathValue {
  1931  	switch fp.selector {
  1932  	case BulkTimeSeries_FieldPathSelectorTimeSeries:
  1933  		return &BulkTimeSeries_FieldTerminalPathValue{BulkTimeSeries_FieldTerminalPath: *fp, value: value.([]*TimeSerie)}
  1934  	case BulkTimeSeries_FieldPathSelectorPhantomFlag:
  1935  		return &BulkTimeSeries_FieldTerminalPathValue{BulkTimeSeries_FieldTerminalPath: *fp, value: value.(bool)}
  1936  	default:
  1937  		panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fp.selector))
  1938  	}
  1939  }
  1940  
  1941  func (fp *BulkTimeSeries_FieldTerminalPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
  1942  	return fp.WithIValue(value)
  1943  }
  1944  
  1945  func (fp *BulkTimeSeries_FieldTerminalPath) WithIArrayOfValues(values interface{}) BulkTimeSeries_FieldPathArrayOfValues {
  1946  	fpaov := &BulkTimeSeries_FieldTerminalPathArrayOfValues{BulkTimeSeries_FieldTerminalPath: *fp}
  1947  	switch fp.selector {
  1948  	case BulkTimeSeries_FieldPathSelectorTimeSeries:
  1949  		return &BulkTimeSeries_FieldTerminalPathArrayOfValues{BulkTimeSeries_FieldTerminalPath: *fp, values: values.([][]*TimeSerie)}
  1950  	case BulkTimeSeries_FieldPathSelectorPhantomFlag:
  1951  		return &BulkTimeSeries_FieldTerminalPathArrayOfValues{BulkTimeSeries_FieldTerminalPath: *fp, values: values.([]bool)}
  1952  	default:
  1953  		panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fp.selector))
  1954  	}
  1955  	return fpaov
  1956  }
  1957  
  1958  func (fp *BulkTimeSeries_FieldTerminalPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
  1959  	return fp.WithIArrayOfValues(values)
  1960  }
  1961  
  1962  func (fp *BulkTimeSeries_FieldTerminalPath) WithIArrayItemValue(value interface{}) BulkTimeSeries_FieldPathArrayItemValue {
  1963  	switch fp.selector {
  1964  	case BulkTimeSeries_FieldPathSelectorTimeSeries:
  1965  		return &BulkTimeSeries_FieldTerminalPathArrayItemValue{BulkTimeSeries_FieldTerminalPath: *fp, value: value.(*TimeSerie)}
  1966  	default:
  1967  		panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fp.selector))
  1968  	}
  1969  }
  1970  
  1971  func (fp *BulkTimeSeries_FieldTerminalPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
  1972  	return fp.WithIArrayItemValue(value)
  1973  }
  1974  
  1975  type BulkTimeSeries_FieldSubPath struct {
  1976  	selector BulkTimeSeries_FieldPathSelector
  1977  	subPath  gotenobject.FieldPath
  1978  }
  1979  
  1980  var _ BulkTimeSeries_FieldPath = (*BulkTimeSeries_FieldSubPath)(nil)
  1981  
  1982  func (fps *BulkTimeSeries_FieldSubPath) Selector() BulkTimeSeries_FieldPathSelector {
  1983  	return fps.selector
  1984  }
  1985  func (fps *BulkTimeSeries_FieldSubPath) AsTimeSeriesSubPath() (TimeSerie_FieldPath, bool) {
  1986  	res, ok := fps.subPath.(TimeSerie_FieldPath)
  1987  	return res, ok
  1988  }
  1989  
  1990  // String returns path representation in proto convention
  1991  func (fps *BulkTimeSeries_FieldSubPath) String() string {
  1992  	return fps.selector.String() + "." + fps.subPath.String()
  1993  }
  1994  
  1995  // JSONString returns path representation is JSON convention
  1996  func (fps *BulkTimeSeries_FieldSubPath) JSONString() string {
  1997  	return strcase.ToLowerCamel(fps.selector.String()) + "." + fps.subPath.JSONString()
  1998  }
  1999  
  2000  // Get returns all values pointed by selected field from source BulkTimeSeries
  2001  func (fps *BulkTimeSeries_FieldSubPath) Get(source *BulkTimeSeries) (values []interface{}) {
  2002  	switch fps.selector {
  2003  	case BulkTimeSeries_FieldPathSelectorTimeSeries:
  2004  		for _, item := range source.GetTimeSeries() {
  2005  			values = append(values, fps.subPath.GetRaw(item)...)
  2006  		}
  2007  	default:
  2008  		panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fps.selector))
  2009  	}
  2010  	return
  2011  }
  2012  
  2013  func (fps *BulkTimeSeries_FieldSubPath) GetRaw(source proto.Message) []interface{} {
  2014  	return fps.Get(source.(*BulkTimeSeries))
  2015  }
  2016  
  2017  // GetSingle returns value of selected field from source BulkTimeSeries
  2018  func (fps *BulkTimeSeries_FieldSubPath) GetSingle(source *BulkTimeSeries) (interface{}, bool) {
  2019  	switch fps.selector {
  2020  	case BulkTimeSeries_FieldPathSelectorTimeSeries:
  2021  		if len(source.GetTimeSeries()) == 0 {
  2022  			return nil, false
  2023  		}
  2024  		return fps.subPath.GetSingleRaw(source.GetTimeSeries()[0])
  2025  	default:
  2026  		panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fps.selector))
  2027  	}
  2028  }
  2029  
  2030  func (fps *BulkTimeSeries_FieldSubPath) GetSingleRaw(source proto.Message) (interface{}, bool) {
  2031  	return fps.GetSingle(source.(*BulkTimeSeries))
  2032  }
  2033  
  2034  // GetDefault returns a default value of the field type
  2035  func (fps *BulkTimeSeries_FieldSubPath) GetDefault() interface{} {
  2036  	return fps.subPath.GetDefault()
  2037  }
  2038  
  2039  func (fps *BulkTimeSeries_FieldSubPath) ClearValue(item *BulkTimeSeries) {
  2040  	if item != nil {
  2041  		switch fps.selector {
  2042  		case BulkTimeSeries_FieldPathSelectorTimeSeries:
  2043  			for _, subItem := range item.TimeSeries {
  2044  				fps.subPath.ClearValueRaw(subItem)
  2045  			}
  2046  		default:
  2047  			panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fps.selector))
  2048  		}
  2049  	}
  2050  }
  2051  
  2052  func (fps *BulkTimeSeries_FieldSubPath) ClearValueRaw(item proto.Message) {
  2053  	fps.ClearValue(item.(*BulkTimeSeries))
  2054  }
  2055  
  2056  // IsLeaf - whether field path is holds simple value
  2057  func (fps *BulkTimeSeries_FieldSubPath) IsLeaf() bool {
  2058  	return fps.subPath.IsLeaf()
  2059  }
  2060  
  2061  func (fps *BulkTimeSeries_FieldSubPath) SplitIntoTerminalIPaths() []gotenobject.FieldPath {
  2062  	iPaths := []gotenobject.FieldPath{&BulkTimeSeries_FieldTerminalPath{selector: fps.selector}}
  2063  	iPaths = append(iPaths, fps.subPath.SplitIntoTerminalIPaths()...)
  2064  	return iPaths
  2065  }
  2066  
  2067  func (fps *BulkTimeSeries_FieldSubPath) WithIValue(value interface{}) BulkTimeSeries_FieldPathValue {
  2068  	return &BulkTimeSeries_FieldSubPathValue{fps, fps.subPath.WithRawIValue(value)}
  2069  }
  2070  
  2071  func (fps *BulkTimeSeries_FieldSubPath) WithRawIValue(value interface{}) gotenobject.FieldPathValue {
  2072  	return fps.WithIValue(value)
  2073  }
  2074  
  2075  func (fps *BulkTimeSeries_FieldSubPath) WithIArrayOfValues(values interface{}) BulkTimeSeries_FieldPathArrayOfValues {
  2076  	return &BulkTimeSeries_FieldSubPathArrayOfValues{fps, fps.subPath.WithRawIArrayOfValues(values)}
  2077  }
  2078  
  2079  func (fps *BulkTimeSeries_FieldSubPath) WithRawIArrayOfValues(values interface{}) gotenobject.FieldPathArrayOfValues {
  2080  	return fps.WithIArrayOfValues(values)
  2081  }
  2082  
  2083  func (fps *BulkTimeSeries_FieldSubPath) WithIArrayItemValue(value interface{}) BulkTimeSeries_FieldPathArrayItemValue {
  2084  	return &BulkTimeSeries_FieldSubPathArrayItemValue{fps, fps.subPath.WithRawIArrayItemValue(value)}
  2085  }
  2086  
  2087  func (fps *BulkTimeSeries_FieldSubPath) WithRawIArrayItemValue(value interface{}) gotenobject.FieldPathArrayItemValue {
  2088  	return fps.WithIArrayItemValue(value)
  2089  }
  2090  
  2091  // BulkTimeSeries_FieldPathValue allows storing values for BulkTimeSeries fields according to their type
  2092  type BulkTimeSeries_FieldPathValue interface {
  2093  	BulkTimeSeries_FieldPath
  2094  	gotenobject.FieldPathValue
  2095  	SetTo(target **BulkTimeSeries)
  2096  	CompareWith(*BulkTimeSeries) (cmp int, comparable bool)
  2097  }
  2098  
  2099  func ParseBulkTimeSeries_FieldPathValue(pathStr, valueStr string) (BulkTimeSeries_FieldPathValue, error) {
  2100  	fp, err := ParseBulkTimeSeries_FieldPath(pathStr)
  2101  	if err != nil {
  2102  		return nil, err
  2103  	}
  2104  	fpv, err := gotenobject.ParseFieldPathValue(fp, valueStr)
  2105  	if err != nil {
  2106  		return nil, status.Errorf(codes.InvalidArgument, "error parsing BulkTimeSeries field path value from %s: %v", valueStr, err)
  2107  	}
  2108  	return fpv.(BulkTimeSeries_FieldPathValue), nil
  2109  }
  2110  
  2111  func MustParseBulkTimeSeries_FieldPathValue(pathStr, valueStr string) BulkTimeSeries_FieldPathValue {
  2112  	fpv, err := ParseBulkTimeSeries_FieldPathValue(pathStr, valueStr)
  2113  	if err != nil {
  2114  		panic(err)
  2115  	}
  2116  	return fpv
  2117  }
  2118  
  2119  type BulkTimeSeries_FieldTerminalPathValue struct {
  2120  	BulkTimeSeries_FieldTerminalPath
  2121  	value interface{}
  2122  }
  2123  
  2124  var _ BulkTimeSeries_FieldPathValue = (*BulkTimeSeries_FieldTerminalPathValue)(nil)
  2125  
  2126  // GetRawValue returns raw value stored under selected path for 'BulkTimeSeries' as interface{}
  2127  func (fpv *BulkTimeSeries_FieldTerminalPathValue) GetRawValue() interface{} {
  2128  	return fpv.value
  2129  }
  2130  func (fpv *BulkTimeSeries_FieldTerminalPathValue) AsTimeSeriesValue() ([]*TimeSerie, bool) {
  2131  	res, ok := fpv.value.([]*TimeSerie)
  2132  	return res, ok
  2133  }
  2134  func (fpv *BulkTimeSeries_FieldTerminalPathValue) AsPhantomFlagValue() (bool, bool) {
  2135  	res, ok := fpv.value.(bool)
  2136  	return res, ok
  2137  }
  2138  
  2139  // SetTo stores value for selected field for object BulkTimeSeries
  2140  func (fpv *BulkTimeSeries_FieldTerminalPathValue) SetTo(target **BulkTimeSeries) {
  2141  	if *target == nil {
  2142  		*target = new(BulkTimeSeries)
  2143  	}
  2144  	switch fpv.selector {
  2145  	case BulkTimeSeries_FieldPathSelectorTimeSeries:
  2146  		(*target).TimeSeries = fpv.value.([]*TimeSerie)
  2147  	case BulkTimeSeries_FieldPathSelectorPhantomFlag:
  2148  		(*target).PhantomFlag = fpv.value.(bool)
  2149  	default:
  2150  		panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fpv.selector))
  2151  	}
  2152  }
  2153  
  2154  func (fpv *BulkTimeSeries_FieldTerminalPathValue) SetToRaw(target proto.Message) {
  2155  	typedObject := target.(*BulkTimeSeries)
  2156  	fpv.SetTo(&typedObject)
  2157  }
  2158  
  2159  // CompareWith compares value in the 'BulkTimeSeries_FieldTerminalPathValue' with the value under path in 'BulkTimeSeries'.
  2160  func (fpv *BulkTimeSeries_FieldTerminalPathValue) CompareWith(source *BulkTimeSeries) (int, bool) {
  2161  	switch fpv.selector {
  2162  	case BulkTimeSeries_FieldPathSelectorTimeSeries:
  2163  		return 0, false
  2164  	case BulkTimeSeries_FieldPathSelectorPhantomFlag:
  2165  		leftValue := fpv.value.(bool)
  2166  		rightValue := source.GetPhantomFlag()
  2167  		if (leftValue) == (rightValue) {
  2168  			return 0, true
  2169  		} else if !(leftValue) && (rightValue) {
  2170  			return -1, true
  2171  		} else {
  2172  			return 1, true
  2173  		}
  2174  	default:
  2175  		panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fpv.selector))
  2176  	}
  2177  }
  2178  
  2179  func (fpv *BulkTimeSeries_FieldTerminalPathValue) CompareWithRaw(source proto.Message) (int, bool) {
  2180  	return fpv.CompareWith(source.(*BulkTimeSeries))
  2181  }
  2182  
  2183  type BulkTimeSeries_FieldSubPathValue struct {
  2184  	BulkTimeSeries_FieldPath
  2185  	subPathValue gotenobject.FieldPathValue
  2186  }
  2187  
  2188  var _ BulkTimeSeries_FieldPathValue = (*BulkTimeSeries_FieldSubPathValue)(nil)
  2189  
  2190  func (fpvs *BulkTimeSeries_FieldSubPathValue) AsTimeSeriesPathValue() (TimeSerie_FieldPathValue, bool) {
  2191  	res, ok := fpvs.subPathValue.(TimeSerie_FieldPathValue)
  2192  	return res, ok
  2193  }
  2194  
  2195  func (fpvs *BulkTimeSeries_FieldSubPathValue) SetTo(target **BulkTimeSeries) {
  2196  	if *target == nil {
  2197  		*target = new(BulkTimeSeries)
  2198  	}
  2199  	switch fpvs.Selector() {
  2200  	case BulkTimeSeries_FieldPathSelectorTimeSeries:
  2201  		panic("FieldPath setter is unsupported for array subpaths")
  2202  	default:
  2203  		panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fpvs.Selector()))
  2204  	}
  2205  }
  2206  
  2207  func (fpvs *BulkTimeSeries_FieldSubPathValue) SetToRaw(target proto.Message) {
  2208  	typedObject := target.(*BulkTimeSeries)
  2209  	fpvs.SetTo(&typedObject)
  2210  }
  2211  
  2212  func (fpvs *BulkTimeSeries_FieldSubPathValue) GetRawValue() interface{} {
  2213  	return fpvs.subPathValue.GetRawValue()
  2214  }
  2215  
  2216  func (fpvs *BulkTimeSeries_FieldSubPathValue) CompareWith(source *BulkTimeSeries) (int, bool) {
  2217  	switch fpvs.Selector() {
  2218  	case BulkTimeSeries_FieldPathSelectorTimeSeries:
  2219  		return 0, false // repeated field
  2220  	default:
  2221  		panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fpvs.Selector()))
  2222  	}
  2223  }
  2224  
  2225  func (fpvs *BulkTimeSeries_FieldSubPathValue) CompareWithRaw(source proto.Message) (int, bool) {
  2226  	return fpvs.CompareWith(source.(*BulkTimeSeries))
  2227  }
  2228  
  2229  // BulkTimeSeries_FieldPathArrayItemValue allows storing single item in Path-specific values for BulkTimeSeries according to their type
  2230  // Present only for array (repeated) types.
  2231  type BulkTimeSeries_FieldPathArrayItemValue interface {
  2232  	gotenobject.FieldPathArrayItemValue
  2233  	BulkTimeSeries_FieldPath
  2234  	ContainsValue(*BulkTimeSeries) bool
  2235  }
  2236  
  2237  // ParseBulkTimeSeries_FieldPathArrayItemValue parses string and JSON-encoded value to its Value
  2238  func ParseBulkTimeSeries_FieldPathArrayItemValue(pathStr, valueStr string) (BulkTimeSeries_FieldPathArrayItemValue, error) {
  2239  	fp, err := ParseBulkTimeSeries_FieldPath(pathStr)
  2240  	if err != nil {
  2241  		return nil, err
  2242  	}
  2243  	fpaiv, err := gotenobject.ParseFieldPathArrayItemValue(fp, valueStr)
  2244  	if err != nil {
  2245  		return nil, status.Errorf(codes.InvalidArgument, "error parsing BulkTimeSeries field path array item value from %s: %v", valueStr, err)
  2246  	}
  2247  	return fpaiv.(BulkTimeSeries_FieldPathArrayItemValue), nil
  2248  }
  2249  
  2250  func MustParseBulkTimeSeries_FieldPathArrayItemValue(pathStr, valueStr string) BulkTimeSeries_FieldPathArrayItemValue {
  2251  	fpaiv, err := ParseBulkTimeSeries_FieldPathArrayItemValue(pathStr, valueStr)
  2252  	if err != nil {
  2253  		panic(err)
  2254  	}
  2255  	return fpaiv
  2256  }
  2257  
  2258  type BulkTimeSeries_FieldTerminalPathArrayItemValue struct {
  2259  	BulkTimeSeries_FieldTerminalPath
  2260  	value interface{}
  2261  }
  2262  
  2263  var _ BulkTimeSeries_FieldPathArrayItemValue = (*BulkTimeSeries_FieldTerminalPathArrayItemValue)(nil)
  2264  
  2265  // GetRawValue returns stored element value for array in object BulkTimeSeries as interface{}
  2266  func (fpaiv *BulkTimeSeries_FieldTerminalPathArrayItemValue) GetRawItemValue() interface{} {
  2267  	return fpaiv.value
  2268  }
  2269  func (fpaiv *BulkTimeSeries_FieldTerminalPathArrayItemValue) AsTimeSeriesItemValue() (*TimeSerie, bool) {
  2270  	res, ok := fpaiv.value.(*TimeSerie)
  2271  	return res, ok
  2272  }
  2273  
  2274  func (fpaiv *BulkTimeSeries_FieldTerminalPathArrayItemValue) GetSingle(source *BulkTimeSeries) (interface{}, bool) {
  2275  	return nil, false
  2276  }
  2277  
  2278  func (fpaiv *BulkTimeSeries_FieldTerminalPathArrayItemValue) GetSingleRaw(source proto.Message) (interface{}, bool) {
  2279  	return fpaiv.GetSingle(source.(*BulkTimeSeries))
  2280  }
  2281  
  2282  // Contains returns a boolean indicating if value that is being held is present in given 'BulkTimeSeries'
  2283  func (fpaiv *BulkTimeSeries_FieldTerminalPathArrayItemValue) ContainsValue(source *BulkTimeSeries) bool {
  2284  	slice := fpaiv.BulkTimeSeries_FieldTerminalPath.Get(source)
  2285  	for _, v := range slice {
  2286  		if asProtoMsg, ok := fpaiv.value.(proto.Message); ok {
  2287  			if proto.Equal(asProtoMsg, v.(proto.Message)) {
  2288  				return true
  2289  			}
  2290  		} else if reflect.DeepEqual(v, fpaiv.value) {
  2291  			return true
  2292  		}
  2293  	}
  2294  	return false
  2295  }
  2296  
  2297  type BulkTimeSeries_FieldSubPathArrayItemValue struct {
  2298  	BulkTimeSeries_FieldPath
  2299  	subPathItemValue gotenobject.FieldPathArrayItemValue
  2300  }
  2301  
  2302  // GetRawValue returns stored array item value
  2303  func (fpaivs *BulkTimeSeries_FieldSubPathArrayItemValue) GetRawItemValue() interface{} {
  2304  	return fpaivs.subPathItemValue.GetRawItemValue()
  2305  }
  2306  func (fpaivs *BulkTimeSeries_FieldSubPathArrayItemValue) AsTimeSeriesPathItemValue() (TimeSerie_FieldPathArrayItemValue, bool) {
  2307  	res, ok := fpaivs.subPathItemValue.(TimeSerie_FieldPathArrayItemValue)
  2308  	return res, ok
  2309  }
  2310  
  2311  // Contains returns a boolean indicating if value that is being held is present in given 'BulkTimeSeries'
  2312  func (fpaivs *BulkTimeSeries_FieldSubPathArrayItemValue) ContainsValue(source *BulkTimeSeries) bool {
  2313  	switch fpaivs.Selector() {
  2314  	case BulkTimeSeries_FieldPathSelectorTimeSeries:
  2315  		return false // repeated/map field
  2316  	default:
  2317  		panic(fmt.Sprintf("Invalid selector for BulkTimeSeries: %d", fpaivs.Selector()))
  2318  	}
  2319  }
  2320  
  2321  // BulkTimeSeries_FieldPathArrayOfValues allows storing slice of values for BulkTimeSeries fields according to their type
  2322  type BulkTimeSeries_FieldPathArrayOfValues interface {
  2323  	gotenobject.FieldPathArrayOfValues
  2324  	BulkTimeSeries_FieldPath
  2325  }
  2326  
  2327  func ParseBulkTimeSeries_FieldPathArrayOfValues(pathStr, valuesStr string) (BulkTimeSeries_FieldPathArrayOfValues, error) {
  2328  	fp, err := ParseBulkTimeSeries_FieldPath(pathStr)
  2329  	if err != nil {
  2330  		return nil, err
  2331  	}
  2332  	fpaov, err := gotenobject.ParseFieldPathArrayOfValues(fp, valuesStr)
  2333  	if err != nil {
  2334  		return nil, status.Errorf(codes.InvalidArgument, "error parsing BulkTimeSeries field path array of values from %s: %v", valuesStr, err)
  2335  	}
  2336  	return fpaov.(BulkTimeSeries_FieldPathArrayOfValues), nil
  2337  }
  2338  
  2339  func MustParseBulkTimeSeries_FieldPathArrayOfValues(pathStr, valuesStr string) BulkTimeSeries_FieldPathArrayOfValues {
  2340  	fpaov, err := ParseBulkTimeSeries_FieldPathArrayOfValues(pathStr, valuesStr)
  2341  	if err != nil {
  2342  		panic(err)
  2343  	}
  2344  	return fpaov
  2345  }
  2346  
  2347  type BulkTimeSeries_FieldTerminalPathArrayOfValues struct {
  2348  	BulkTimeSeries_FieldTerminalPath
  2349  	values interface{}
  2350  }
  2351  
  2352  var _ BulkTimeSeries_FieldPathArrayOfValues = (*BulkTimeSeries_FieldTerminalPathArrayOfValues)(nil)
  2353  
  2354  func (fpaov *BulkTimeSeries_FieldTerminalPathArrayOfValues) GetRawValues() (values []interface{}) {
  2355  	switch fpaov.selector {
  2356  	case BulkTimeSeries_FieldPathSelectorTimeSeries:
  2357  		for _, v := range fpaov.values.([][]*TimeSerie) {
  2358  			values = append(values, v)
  2359  		}
  2360  	case BulkTimeSeries_FieldPathSelectorPhantomFlag:
  2361  		for _, v := range fpaov.values.([]bool) {
  2362  			values = append(values, v)
  2363  		}
  2364  	}
  2365  	return
  2366  }
  2367  func (fpaov *BulkTimeSeries_FieldTerminalPathArrayOfValues) AsTimeSeriesArrayOfValues() ([][]*TimeSerie, bool) {
  2368  	res, ok := fpaov.values.([][]*TimeSerie)
  2369  	return res, ok
  2370  }
  2371  func (fpaov *BulkTimeSeries_FieldTerminalPathArrayOfValues) AsPhantomFlagArrayOfValues() ([]bool, bool) {
  2372  	res, ok := fpaov.values.([]bool)
  2373  	return res, ok
  2374  }
  2375  
  2376  type BulkTimeSeries_FieldSubPathArrayOfValues struct {
  2377  	BulkTimeSeries_FieldPath
  2378  	subPathArrayOfValues gotenobject.FieldPathArrayOfValues
  2379  }
  2380  
  2381  var _ BulkTimeSeries_FieldPathArrayOfValues = (*BulkTimeSeries_FieldSubPathArrayOfValues)(nil)
  2382  
  2383  func (fpsaov *BulkTimeSeries_FieldSubPathArrayOfValues) GetRawValues() []interface{} {
  2384  	return fpsaov.subPathArrayOfValues.GetRawValues()
  2385  }
  2386  func (fpsaov *BulkTimeSeries_FieldSubPathArrayOfValues) AsTimeSeriesPathArrayOfValues() (TimeSerie_FieldPathArrayOfValues, bool) {
  2387  	res, ok := fpsaov.subPathArrayOfValues.(TimeSerie_FieldPathArrayOfValues)
  2388  	return res, ok
  2389  }