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

     1  // Code generated by protoc-gen-goten-object
     2  // File: edgelq/monitoring/proto/v3/phantom_time_serie.proto
     3  // DO NOT EDIT!!!
     4  
     5  package phantom_time_serie
     6  
     7  import (
     8  	"encoding/json"
     9  	"strings"
    10  
    11  	"google.golang.org/grpc/codes"
    12  	"google.golang.org/grpc/status"
    13  	"google.golang.org/protobuf/proto"
    14  	preflect "google.golang.org/protobuf/reflect/protoreflect"
    15  	googlefieldmaskpb "google.golang.org/protobuf/types/known/fieldmaskpb"
    16  
    17  	gotenobject "github.com/cloudwan/goten-sdk/runtime/object"
    18  )
    19  
    20  // proto imports
    21  import (
    22  	common "github.com/cloudwan/edgelq-sdk/monitoring/resources/v3/common"
    23  	metric_descriptor "github.com/cloudwan/edgelq-sdk/monitoring/resources/v3/metric_descriptor"
    24  	project "github.com/cloudwan/edgelq-sdk/monitoring/resources/v3/project"
    25  	meta "github.com/cloudwan/goten-sdk/types/meta"
    26  )
    27  
    28  // ensure the imports are used
    29  var (
    30  	_ = new(json.Marshaler)
    31  	_ = strings.Builder{}
    32  
    33  	_ = codes.NotFound
    34  	_ = status.Status{}
    35  	_ = new(proto.Message)
    36  	_ = new(preflect.Message)
    37  	_ = googlefieldmaskpb.FieldMask{}
    38  
    39  	_ = new(gotenobject.FieldMask)
    40  )
    41  
    42  // make sure we're using proto imports
    43  var (
    44  	_ = &common.LabelDescriptor{}
    45  	_ = &metric_descriptor.MetricDescriptor{}
    46  	_ = &project.Project{}
    47  	_ = &meta.Meta{}
    48  )
    49  
    50  type PhantomTimeSerie_FieldMask struct {
    51  	Paths []PhantomTimeSerie_FieldPath
    52  }
    53  
    54  func FullPhantomTimeSerie_FieldMask() *PhantomTimeSerie_FieldMask {
    55  	res := &PhantomTimeSerie_FieldMask{}
    56  	res.Paths = append(res.Paths, &PhantomTimeSerie_FieldTerminalPath{selector: PhantomTimeSerie_FieldPathSelectorMetadata})
    57  	res.Paths = append(res.Paths, &PhantomTimeSerie_FieldTerminalPath{selector: PhantomTimeSerie_FieldPathSelectorName})
    58  	res.Paths = append(res.Paths, &PhantomTimeSerie_FieldTerminalPath{selector: PhantomTimeSerie_FieldPathSelectorKey})
    59  	res.Paths = append(res.Paths, &PhantomTimeSerie_FieldTerminalPath{selector: PhantomTimeSerie_FieldPathSelectorProject})
    60  	res.Paths = append(res.Paths, &PhantomTimeSerie_FieldTerminalPath{selector: PhantomTimeSerie_FieldPathSelectorMetric})
    61  	res.Paths = append(res.Paths, &PhantomTimeSerie_FieldTerminalPath{selector: PhantomTimeSerie_FieldPathSelectorResource})
    62  	res.Paths = append(res.Paths, &PhantomTimeSerie_FieldTerminalPath{selector: PhantomTimeSerie_FieldPathSelectorMetricKind})
    63  	res.Paths = append(res.Paths, &PhantomTimeSerie_FieldTerminalPath{selector: PhantomTimeSerie_FieldPathSelectorValueType})
    64  	res.Paths = append(res.Paths, &PhantomTimeSerie_FieldTerminalPath{selector: PhantomTimeSerie_FieldPathSelectorValue})
    65  	return res
    66  }
    67  
    68  func (fieldMask *PhantomTimeSerie_FieldMask) String() string {
    69  	if fieldMask == nil {
    70  		return "<nil>"
    71  	}
    72  	pathsStr := make([]string, 0, len(fieldMask.Paths))
    73  	for _, path := range fieldMask.Paths {
    74  		pathsStr = append(pathsStr, path.String())
    75  	}
    76  	return strings.Join(pathsStr, ", ")
    77  }
    78  
    79  func (fieldMask *PhantomTimeSerie_FieldMask) IsFull() bool {
    80  	if fieldMask == nil {
    81  		return false
    82  	}
    83  	presentSelectors := make([]bool, 9)
    84  	for _, path := range fieldMask.Paths {
    85  		if asFinal, ok := path.(*PhantomTimeSerie_FieldTerminalPath); ok {
    86  			presentSelectors[int(asFinal.selector)] = true
    87  		}
    88  	}
    89  	for _, flag := range presentSelectors {
    90  		if !flag {
    91  			return false
    92  		}
    93  	}
    94  	return true
    95  }
    96  
    97  func (fieldMask *PhantomTimeSerie_FieldMask) ProtoReflect() preflect.Message {
    98  	return gotenobject.MakeFieldMaskReflection(fieldMask, func(raw string) (gotenobject.FieldPath, error) {
    99  		return ParsePhantomTimeSerie_FieldPath(raw)
   100  	})
   101  }
   102  
   103  func (fieldMask *PhantomTimeSerie_FieldMask) ProtoMessage() {}
   104  
   105  func (fieldMask *PhantomTimeSerie_FieldMask) Reset() {
   106  	if fieldMask != nil {
   107  		fieldMask.Paths = nil
   108  	}
   109  }
   110  
   111  func (fieldMask *PhantomTimeSerie_FieldMask) Subtract(other *PhantomTimeSerie_FieldMask) *PhantomTimeSerie_FieldMask {
   112  	result := &PhantomTimeSerie_FieldMask{}
   113  	removedSelectors := make([]bool, 9)
   114  	otherSubMasks := map[PhantomTimeSerie_FieldPathSelector]gotenobject.FieldMask{
   115  		PhantomTimeSerie_FieldPathSelectorMetadata: &meta.Meta_FieldMask{},
   116  		PhantomTimeSerie_FieldPathSelectorMetric:   &common.Metric_FieldMask{},
   117  		PhantomTimeSerie_FieldPathSelectorResource: &common.MonitoredResource_FieldMask{},
   118  		PhantomTimeSerie_FieldPathSelectorValue:    &common.TypedValue_FieldMask{},
   119  	}
   120  	mySubMasks := map[PhantomTimeSerie_FieldPathSelector]gotenobject.FieldMask{
   121  		PhantomTimeSerie_FieldPathSelectorMetadata: &meta.Meta_FieldMask{},
   122  		PhantomTimeSerie_FieldPathSelectorMetric:   &common.Metric_FieldMask{},
   123  		PhantomTimeSerie_FieldPathSelectorResource: &common.MonitoredResource_FieldMask{},
   124  		PhantomTimeSerie_FieldPathSelectorValue:    &common.TypedValue_FieldMask{},
   125  	}
   126  
   127  	for _, path := range other.GetPaths() {
   128  		switch tp := path.(type) {
   129  		case *PhantomTimeSerie_FieldTerminalPath:
   130  			removedSelectors[int(tp.selector)] = true
   131  		case *PhantomTimeSerie_FieldSubPath:
   132  			otherSubMasks[tp.selector].AppendRawPath(tp.subPath)
   133  		}
   134  	}
   135  	for _, path := range fieldMask.GetPaths() {
   136  		if !removedSelectors[int(path.Selector())] {
   137  			if otherSubMask := otherSubMasks[path.Selector()]; otherSubMask != nil && otherSubMask.PathsCount() > 0 {
   138  				if tp, ok := path.(*PhantomTimeSerie_FieldTerminalPath); ok {
   139  					switch tp.selector {
   140  					case PhantomTimeSerie_FieldPathSelectorMetadata:
   141  						mySubMasks[PhantomTimeSerie_FieldPathSelectorMetadata] = meta.FullMeta_FieldMask()
   142  					case PhantomTimeSerie_FieldPathSelectorMetric:
   143  						mySubMasks[PhantomTimeSerie_FieldPathSelectorMetric] = common.FullMetric_FieldMask()
   144  					case PhantomTimeSerie_FieldPathSelectorResource:
   145  						mySubMasks[PhantomTimeSerie_FieldPathSelectorResource] = common.FullMonitoredResource_FieldMask()
   146  					case PhantomTimeSerie_FieldPathSelectorValue:
   147  						mySubMasks[PhantomTimeSerie_FieldPathSelectorValue] = common.FullTypedValue_FieldMask()
   148  					}
   149  				} else if tp, ok := path.(*PhantomTimeSerie_FieldSubPath); ok {
   150  					mySubMasks[tp.selector].AppendRawPath(tp.subPath)
   151  				}
   152  			} else {
   153  				result.Paths = append(result.Paths, path)
   154  			}
   155  		}
   156  	}
   157  	for selector, mySubMask := range mySubMasks {
   158  		if mySubMask.PathsCount() > 0 {
   159  			for _, allowedPath := range mySubMask.SubtractRaw(otherSubMasks[selector]).GetRawPaths() {
   160  				result.Paths = append(result.Paths, &PhantomTimeSerie_FieldSubPath{selector: selector, subPath: allowedPath})
   161  			}
   162  		}
   163  	}
   164  
   165  	if len(result.Paths) == 0 {
   166  		return nil
   167  	}
   168  	return result
   169  }
   170  
   171  func (fieldMask *PhantomTimeSerie_FieldMask) SubtractRaw(other gotenobject.FieldMask) gotenobject.FieldMask {
   172  	return fieldMask.Subtract(other.(*PhantomTimeSerie_FieldMask))
   173  }
   174  
   175  // FilterInputFields generates copy of field paths with output_only field paths removed
   176  func (fieldMask *PhantomTimeSerie_FieldMask) FilterInputFields() *PhantomTimeSerie_FieldMask {
   177  	result := &PhantomTimeSerie_FieldMask{}
   178  	for _, path := range fieldMask.Paths {
   179  		switch path.Selector() {
   180  		case PhantomTimeSerie_FieldPathSelectorKey:
   181  		case PhantomTimeSerie_FieldPathSelectorProject:
   182  		case PhantomTimeSerie_FieldPathSelectorMetricKind:
   183  		case PhantomTimeSerie_FieldPathSelectorValueType:
   184  		case PhantomTimeSerie_FieldPathSelectorMetadata:
   185  			if _, ok := path.(*PhantomTimeSerie_FieldTerminalPath); ok {
   186  				for _, subpath := range meta.FullMeta_FieldMask().FilterInputFields().Paths {
   187  					result.Paths = append(result.Paths, &PhantomTimeSerie_FieldSubPath{selector: path.Selector(), subPath: subpath})
   188  				}
   189  			} else if sub, ok := path.(*PhantomTimeSerie_FieldSubPath); ok {
   190  				selectedMask := &meta.Meta_FieldMask{
   191  					Paths: []meta.Meta_FieldPath{sub.subPath.(meta.Meta_FieldPath)},
   192  				}
   193  				for _, allowedPath := range selectedMask.FilterInputFields().Paths {
   194  					result.Paths = append(result.Paths, &PhantomTimeSerie_FieldSubPath{selector: PhantomTimeSerie_FieldPathSelectorMetadata, subPath: allowedPath})
   195  				}
   196  			}
   197  		default:
   198  			result.Paths = append(result.Paths, path)
   199  		}
   200  	}
   201  	return result
   202  }
   203  
   204  // ToFieldMask is used for proto conversions
   205  func (fieldMask *PhantomTimeSerie_FieldMask) ToProtoFieldMask() *googlefieldmaskpb.FieldMask {
   206  	protoFieldMask := &googlefieldmaskpb.FieldMask{}
   207  	for _, path := range fieldMask.Paths {
   208  		protoFieldMask.Paths = append(protoFieldMask.Paths, path.String())
   209  	}
   210  	return protoFieldMask
   211  }
   212  
   213  func (fieldMask *PhantomTimeSerie_FieldMask) FromProtoFieldMask(protoFieldMask *googlefieldmaskpb.FieldMask) error {
   214  	if fieldMask == nil {
   215  		return status.Error(codes.Internal, "target field mask is nil")
   216  	}
   217  	fieldMask.Paths = make([]PhantomTimeSerie_FieldPath, 0, len(protoFieldMask.Paths))
   218  	for _, strPath := range protoFieldMask.Paths {
   219  		path, err := ParsePhantomTimeSerie_FieldPath(strPath)
   220  		if err != nil {
   221  			return err
   222  		}
   223  		fieldMask.Paths = append(fieldMask.Paths, path)
   224  	}
   225  	return nil
   226  }
   227  
   228  // implement methods required by customType
   229  func (fieldMask PhantomTimeSerie_FieldMask) Marshal() ([]byte, error) {
   230  	protoFieldMask := fieldMask.ToProtoFieldMask()
   231  	return proto.Marshal(protoFieldMask)
   232  }
   233  
   234  func (fieldMask *PhantomTimeSerie_FieldMask) Unmarshal(data []byte) error {
   235  	protoFieldMask := &googlefieldmaskpb.FieldMask{}
   236  	if err := proto.Unmarshal(data, protoFieldMask); err != nil {
   237  		return err
   238  	}
   239  	if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil {
   240  		return err
   241  	}
   242  	return nil
   243  }
   244  
   245  func (fieldMask *PhantomTimeSerie_FieldMask) Size() int {
   246  	return proto.Size(fieldMask.ToProtoFieldMask())
   247  }
   248  
   249  func (fieldMask PhantomTimeSerie_FieldMask) MarshalJSON() ([]byte, error) {
   250  	return json.Marshal(fieldMask.ToProtoFieldMask())
   251  }
   252  
   253  func (fieldMask *PhantomTimeSerie_FieldMask) UnmarshalJSON(data []byte) error {
   254  	protoFieldMask := &googlefieldmaskpb.FieldMask{}
   255  	if err := json.Unmarshal(data, protoFieldMask); err != nil {
   256  		return err
   257  	}
   258  	if err := fieldMask.FromProtoFieldMask(protoFieldMask); err != nil {
   259  		return err
   260  	}
   261  	return nil
   262  }
   263  
   264  func (fieldMask *PhantomTimeSerie_FieldMask) AppendPath(path PhantomTimeSerie_FieldPath) {
   265  	fieldMask.Paths = append(fieldMask.Paths, path)
   266  }
   267  
   268  func (fieldMask *PhantomTimeSerie_FieldMask) AppendRawPath(path gotenobject.FieldPath) {
   269  	fieldMask.Paths = append(fieldMask.Paths, path.(PhantomTimeSerie_FieldPath))
   270  }
   271  
   272  func (fieldMask *PhantomTimeSerie_FieldMask) GetPaths() []PhantomTimeSerie_FieldPath {
   273  	if fieldMask == nil {
   274  		return nil
   275  	}
   276  	return fieldMask.Paths
   277  }
   278  
   279  func (fieldMask *PhantomTimeSerie_FieldMask) GetRawPaths() []gotenobject.FieldPath {
   280  	if fieldMask == nil {
   281  		return nil
   282  	}
   283  	rawPaths := make([]gotenobject.FieldPath, 0, len(fieldMask.Paths))
   284  	for _, path := range fieldMask.Paths {
   285  		rawPaths = append(rawPaths, path)
   286  	}
   287  	return rawPaths
   288  }
   289  
   290  func (fieldMask *PhantomTimeSerie_FieldMask) SetFromCliFlag(raw string) error {
   291  	path, err := ParsePhantomTimeSerie_FieldPath(raw)
   292  	if err != nil {
   293  		return err
   294  	}
   295  	fieldMask.Paths = append(fieldMask.Paths, path)
   296  	return nil
   297  }
   298  
   299  func (fieldMask *PhantomTimeSerie_FieldMask) Set(target, source *PhantomTimeSerie) {
   300  	for _, path := range fieldMask.Paths {
   301  		val, _ := path.GetSingle(source)
   302  		// if val is nil, then field does not exist in source, skip
   303  		// otherwise, process (can still reflect.ValueOf(val).IsNil!)
   304  		if val != nil {
   305  			path.WithIValue(val).SetTo(&target)
   306  		}
   307  	}
   308  }
   309  
   310  func (fieldMask *PhantomTimeSerie_FieldMask) SetRaw(target, source gotenobject.GotenObjectExt) {
   311  	fieldMask.Set(target.(*PhantomTimeSerie), source.(*PhantomTimeSerie))
   312  }
   313  
   314  func (fieldMask *PhantomTimeSerie_FieldMask) Project(source *PhantomTimeSerie) *PhantomTimeSerie {
   315  	if source == nil {
   316  		return nil
   317  	}
   318  	if fieldMask == nil {
   319  		return source
   320  	}
   321  	result := &PhantomTimeSerie{}
   322  	metadataMask := &meta.Meta_FieldMask{}
   323  	wholeMetadataAccepted := false
   324  	metricMask := &common.Metric_FieldMask{}
   325  	wholeMetricAccepted := false
   326  	resourceMask := &common.MonitoredResource_FieldMask{}
   327  	wholeResourceAccepted := false
   328  	valueMask := &common.TypedValue_FieldMask{}
   329  	wholeValueAccepted := false
   330  
   331  	for _, p := range fieldMask.Paths {
   332  		switch tp := p.(type) {
   333  		case *PhantomTimeSerie_FieldTerminalPath:
   334  			switch tp.selector {
   335  			case PhantomTimeSerie_FieldPathSelectorMetadata:
   336  				result.Metadata = source.Metadata
   337  				wholeMetadataAccepted = true
   338  			case PhantomTimeSerie_FieldPathSelectorName:
   339  				result.Name = source.Name
   340  			case PhantomTimeSerie_FieldPathSelectorKey:
   341  				result.Key = source.Key
   342  			case PhantomTimeSerie_FieldPathSelectorProject:
   343  				result.Project = source.Project
   344  			case PhantomTimeSerie_FieldPathSelectorMetric:
   345  				result.Metric = source.Metric
   346  				wholeMetricAccepted = true
   347  			case PhantomTimeSerie_FieldPathSelectorResource:
   348  				result.Resource = source.Resource
   349  				wholeResourceAccepted = true
   350  			case PhantomTimeSerie_FieldPathSelectorMetricKind:
   351  				result.MetricKind = source.MetricKind
   352  			case PhantomTimeSerie_FieldPathSelectorValueType:
   353  				result.ValueType = source.ValueType
   354  			case PhantomTimeSerie_FieldPathSelectorValue:
   355  				result.Value = source.Value
   356  				wholeValueAccepted = true
   357  			}
   358  		case *PhantomTimeSerie_FieldSubPath:
   359  			switch tp.selector {
   360  			case PhantomTimeSerie_FieldPathSelectorMetadata:
   361  				metadataMask.AppendPath(tp.subPath.(meta.Meta_FieldPath))
   362  			case PhantomTimeSerie_FieldPathSelectorMetric:
   363  				metricMask.AppendPath(tp.subPath.(common.Metric_FieldPath))
   364  			case PhantomTimeSerie_FieldPathSelectorResource:
   365  				resourceMask.AppendPath(tp.subPath.(common.MonitoredResource_FieldPath))
   366  			case PhantomTimeSerie_FieldPathSelectorValue:
   367  				valueMask.AppendPath(tp.subPath.(common.TypedValue_FieldPath))
   368  			}
   369  		}
   370  	}
   371  	if wholeMetadataAccepted == false && len(metadataMask.Paths) > 0 {
   372  		result.Metadata = metadataMask.Project(source.GetMetadata())
   373  	}
   374  	if wholeMetricAccepted == false && len(metricMask.Paths) > 0 {
   375  		result.Metric = metricMask.Project(source.GetMetric())
   376  	}
   377  	if wholeResourceAccepted == false && len(resourceMask.Paths) > 0 {
   378  		result.Resource = resourceMask.Project(source.GetResource())
   379  	}
   380  	if wholeValueAccepted == false && len(valueMask.Paths) > 0 {
   381  		result.Value = valueMask.Project(source.GetValue())
   382  	}
   383  	return result
   384  }
   385  
   386  func (fieldMask *PhantomTimeSerie_FieldMask) ProjectRaw(source gotenobject.GotenObjectExt) gotenobject.GotenObjectExt {
   387  	return fieldMask.Project(source.(*PhantomTimeSerie))
   388  }
   389  
   390  func (fieldMask *PhantomTimeSerie_FieldMask) PathsCount() int {
   391  	if fieldMask == nil {
   392  		return 0
   393  	}
   394  	return len(fieldMask.Paths)
   395  }