vendor/github.com/golang/protobuf/proto/properties.go - ofagent-go - Gitiles

 // Copyright 2010 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

 package proto

 import (
 	"fmt"
 	"reflect"
 	"strconv"
 	"strings"
 	"sync"

 	"google.golang.org/protobuf/reflect/protoreflect"
 	"google.golang.org/protobuf/runtime/protoimpl"
 )

 // StructProperties represents protocol buffer type information for a
 // generated protobuf message in the open-struct API.
 //
 // Deprecated: Do not use.
 type StructProperties struct {
 	// Prop are the properties for each field.
 	//
 	// Fields belonging to a oneof are stored in OneofTypes instead, with a
 	// single Properties representing the parent oneof held here.
 	//
 	// The order of Prop matches the order of fields in the Go struct.
 	// Struct fields that are not related to protobufs have a "XXX_" prefix
 	// in the Properties.Name and must be ignored by the user.
 	Prop []*Properties

 	// OneofTypes contains information about the oneof fields in this message.
 	// It is keyed by the protobuf field name.
 	OneofTypes map[string]*OneofProperties
 }

 // Properties represents the type information for a protobuf message field.
 //
 // Deprecated: Do not use.
 type Properties struct {
 	// Name is a placeholder name with little meaningful semantic value.
 	// If the name has an "XXX_" prefix, the entire Properties must be ignored.
 	Name string
 	// OrigName is the protobuf field name or oneof name.
 	OrigName string
 	// JSONName is the JSON name for the protobuf field.
 	JSONName string
 	// Enum is a placeholder name for enums.
 	// For historical reasons, this is neither the Go name for the enum,
 	// nor the protobuf name for the enum.
 	Enum string // Deprecated: Do not use.
 	// Weak contains the full name of the weakly referenced message.
 	Weak string
 	// Wire is a string representation of the wire type.
 	Wire string
 	// WireType is the protobuf wire type for the field.
 	WireType int
 	// Tag is the protobuf field number.
 	Tag int
 	// Required reports whether this is a required field.
 	Required bool
 	// Optional reports whether this is a optional field.
 	Optional bool
 	// Repeated reports whether this is a repeated field.
 	Repeated bool
 	// Packed reports whether this is a packed repeated field of scalars.
 	Packed bool
 	// Proto3 reports whether this field operates under the proto3 syntax.
 	Proto3 bool
 	// Oneof reports whether this field belongs within a oneof.
 	Oneof bool

 	// Default is the default value in string form.
 	Default string
 	// HasDefault reports whether the field has a default value.
 	HasDefault bool

 	// MapKeyProp is the properties for the key field for a map field.
 	MapKeyProp *Properties
 	// MapValProp is the properties for the value field for a map field.
 	MapValProp *Properties
 }

 // OneofProperties represents the type information for a protobuf oneof.
 //
 // Deprecated: Do not use.
 type OneofProperties struct {
 	// Type is a pointer to the generated wrapper type for the field value.
 	// This is nil for messages that are not in the open-struct API.
 	Type reflect.Type
 	// Field is the index into StructProperties.Prop for the containing oneof.
 	Field int
 	// Prop is the properties for the field.
 	Prop *Properties
 }

 // String formats the properties in the protobuf struct field tag style.
 func (p *Properties) String() string {
 	s := p.Wire
 	s += "," + strconv.Itoa(p.Tag)
 	if p.Required {
 		s += ",req"
 	}
 	if p.Optional {
 		s += ",opt"
 	}
 	if p.Repeated {
 		s += ",rep"
 	}
 	if p.Packed {
 		s += ",packed"
 	}
 	s += ",name=" + p.OrigName
 	if p.JSONName != "" {
 		s += ",json=" + p.JSONName
 	}
 	if len(p.Enum) > 0 {
 		s += ",enum=" + p.Enum
 	}
 	if len(p.Weak) > 0 {
 		s += ",weak=" + p.Weak
 	}
 	if p.Proto3 {
 		s += ",proto3"
 	}
 	if p.Oneof {
 		s += ",oneof"
 	}
 	if p.HasDefault {
 		s += ",def=" + p.Default
 	}
 	return s
 }

 // Parse populates p by parsing a string in the protobuf struct field tag style.
 func (p *Properties) Parse(tag string) {
 	// For example: "bytes,49,opt,name=foo,def=hello!"
 	for len(tag) > 0 {
 		i := strings.IndexByte(tag, ',')
 		if i < 0 {
 			i = len(tag)
 		}
 		switch s := tag[:i]; {
 		case strings.HasPrefix(s, "name="):
 			p.OrigName = s[len("name="):]
 		case strings.HasPrefix(s, "json="):
 			p.JSONName = s[len("json="):]
 		case strings.HasPrefix(s, "enum="):
 			p.Enum = s[len("enum="):]
 		case strings.HasPrefix(s, "weak="):
 			p.Weak = s[len("weak="):]
 		case strings.Trim(s, "0123456789") == "":
 			n, _ := strconv.ParseUint(s, 10, 32)
 			p.Tag = int(n)
 		case s == "opt":
 			p.Optional = true
 		case s == "req":
 			p.Required = true
 		case s == "rep":
 			p.Repeated = true
 		case s == "varint" || s == "zigzag32" || s == "zigzag64":
 			p.Wire = s
 			p.WireType = WireVarint
 		case s == "fixed32":
 			p.Wire = s
 			p.WireType = WireFixed32
 		case s == "fixed64":
 			p.Wire = s
 			p.WireType = WireFixed64
 		case s == "bytes":
 			p.Wire = s
 			p.WireType = WireBytes
 		case s == "group":
 			p.Wire = s
 			p.WireType = WireStartGroup
 		case s == "packed":
 			p.Packed = true
 		case s == "proto3":
 			p.Proto3 = true
 		case s == "oneof":
 			p.Oneof = true
 		case strings.HasPrefix(s, "def="):
 			// The default tag is special in that everything afterwards is the
 			// default regardless of the presence of commas.
 			p.HasDefault = true
 			p.Default, i = tag[len("def="):], len(tag)
 		}
 		tag = strings.TrimPrefix(tag[i:], ",")
 	}
 }

 // Init populates the properties from a protocol buffer struct tag.
 //
 // Deprecated: Do not use.
 func (p *Properties) Init(typ reflect.Type, name, tag string, f *reflect.StructField) {
 	p.Name = name
 	p.OrigName = name
 	if tag == "" {
 		return
 	}
 	p.Parse(tag)

 	if typ != nil && typ.Kind() == reflect.Map {
 		p.MapKeyProp = new(Properties)
 		p.MapKeyProp.Init(nil, "Key", f.Tag.Get("protobuf_key"), nil)
 		p.MapValProp = new(Properties)
 		p.MapValProp.Init(nil, "Value", f.Tag.Get("protobuf_val"), nil)
 	}
 }

 var propertiesCache sync.Map // map[reflect.Type]*StructProperties

 // GetProperties returns the list of properties for the type represented by t,
 // which must be a generated protocol buffer message in the open-struct API,
 // where protobuf message fields are represented by exported Go struct fields.
 //
 // Deprecated: Use protobuf reflection instead.
 func GetProperties(t reflect.Type) *StructProperties {
 	if p, ok := propertiesCache.Load(t); ok {
 		return p.(*StructProperties)
 	}
 	p, _ := propertiesCache.LoadOrStore(t, newProperties(t))
 	return p.(*StructProperties)
 }

 func newProperties(t reflect.Type) *StructProperties {
 	if t.Kind() != reflect.Struct {
 		panic(fmt.Sprintf("%v is not a generated message in the open-struct API", t))
 	}

 	var hasOneof bool
 	prop := new(StructProperties)

 	// Construct a list of properties for each field in the struct.
 	for i := 0; i < t.NumField(); i++ {
 		p := new(Properties)
 		f := t.Field(i)
 		tagField := f.Tag.Get("protobuf")
 		p.Init(f.Type, f.Name, tagField, &f)

 		tagOneof := f.Tag.Get("protobuf_oneof")
 		if tagOneof != "" {
 			hasOneof = true
 			p.OrigName = tagOneof
 		}

 		// Rename unrelated struct fields with the "XXX_" prefix since so much
 		// user code simply checks for this to exclude special fields.
 		if tagField == "" && tagOneof == "" && !strings.HasPrefix(p.Name, "XXX_") {
 			p.Name = "XXX_" + p.Name
 			p.OrigName = "XXX_" + p.OrigName
 		} else if p.Weak != "" {
 			p.Name = p.OrigName // avoid possible "XXX_" prefix on weak field
 		}

 		prop.Prop = append(prop.Prop, p)
 	}

 	// Construct a mapping of oneof field names to properties.
 	if hasOneof {
 		var oneofWrappers []interface{}
 		if fn, ok := reflect.PtrTo(t).MethodByName("XXX_OneofFuncs"); ok {
 			oneofWrappers = fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))})[3].Interface().([]interface{})
 		}
 		if fn, ok := reflect.PtrTo(t).MethodByName("XXX_OneofWrappers"); ok {
 			oneofWrappers = fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))})[0].Interface().([]interface{})
 		}
 		if m, ok := reflect.Zero(reflect.PtrTo(t)).Interface().(protoreflect.ProtoMessage); ok {
 			if m, ok := m.ProtoReflect().(interface{ ProtoMessageInfo() *protoimpl.MessageInfo }); ok {
 				oneofWrappers = m.ProtoMessageInfo().OneofWrappers
 			}
 		}

 		prop.OneofTypes = make(map[string]*OneofProperties)
 		for _, wrapper := range oneofWrappers {
 			p := &OneofProperties{
 				Type: reflect.ValueOf(wrapper).Type(), // *T
 				Prop: new(Properties),
 			}
 			f := p.Type.Elem().Field(0)
 			p.Prop.Name = f.Name
 			p.Prop.Parse(f.Tag.Get("protobuf"))

 			// Determine the struct field that contains this oneof.
 			// Each wrapper is assignable to exactly one parent field.
 			var foundOneof bool
 			for i := 0; i < t.NumField() && !foundOneof; i++ {
 				if p.Type.AssignableTo(t.Field(i).Type) {
 					p.Field = i
 					foundOneof = true
 				}
 			}
 			if !foundOneof {
 				panic(fmt.Sprintf("%v is not a generated message in the open-struct API", t))
 			}
 			prop.OneofTypes[p.Prop.OrigName] = p
 		}
 	}

 	return prop
 }

 func (sp *StructProperties) Len() int           { return len(sp.Prop) }
 func (sp *StructProperties) Less(i, j int) bool { return false }
 func (sp *StructProperties) Swap(i, j int)      { return }
	// Copyright 2010 The Go Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style
	// license that can be found in the LICENSE file.

	package proto

	import (
	"fmt"
	"reflect"
	"strconv"
	"strings"
	"sync"

	"google.golang.org/protobuf/reflect/protoreflect"
	"google.golang.org/protobuf/runtime/protoimpl"
	)

	// StructProperties represents protocol buffer type information for a
	// generated protobuf message in the open-struct API.
	//
	// Deprecated: Do not use.
	type StructProperties struct {
	// Prop are the properties for each field.
	//
	// Fields belonging to a oneof are stored in OneofTypes instead, with a
	// single Properties representing the parent oneof held here.
	//
	// The order of Prop matches the order of fields in the Go struct.
	// Struct fields that are not related to protobufs have a "XXX_" prefix
	// in the Properties.Name and must be ignored by the user.
	Prop []*Properties

	// OneofTypes contains information about the oneof fields in this message.
	// It is keyed by the protobuf field name.
	OneofTypes map[string]*OneofProperties
	}

	// Properties represents the type information for a protobuf message field.
	//
	// Deprecated: Do not use.
	type Properties struct {
	// Name is a placeholder name with little meaningful semantic value.
	// If the name has an "XXX_" prefix, the entire Properties must be ignored.
	Name string
	// OrigName is the protobuf field name or oneof name.
	OrigName string
	// JSONName is the JSON name for the protobuf field.
	JSONName string
	// Enum is a placeholder name for enums.
	// For historical reasons, this is neither the Go name for the enum,
	// nor the protobuf name for the enum.
	Enum string // Deprecated: Do not use.
	// Weak contains the full name of the weakly referenced message.
	Weak string
	// Wire is a string representation of the wire type.
	Wire string
	// WireType is the protobuf wire type for the field.
	WireType int
	// Tag is the protobuf field number.
	Tag int
	// Required reports whether this is a required field.
	Required bool
	// Optional reports whether this is a optional field.
	Optional bool
	// Repeated reports whether this is a repeated field.
	Repeated bool
	// Packed reports whether this is a packed repeated field of scalars.
	Packed bool
	// Proto3 reports whether this field operates under the proto3 syntax.
	Proto3 bool
	// Oneof reports whether this field belongs within a oneof.
	Oneof bool

	// Default is the default value in string form.
	Default string
	// HasDefault reports whether the field has a default value.
	HasDefault bool

	// MapKeyProp is the properties for the key field for a map field.
	MapKeyProp *Properties
	// MapValProp is the properties for the value field for a map field.
	MapValProp *Properties
	}

	// OneofProperties represents the type information for a protobuf oneof.
	//
	// Deprecated: Do not use.
	type OneofProperties struct {
	// Type is a pointer to the generated wrapper type for the field value.
	// This is nil for messages that are not in the open-struct API.
	Type reflect.Type
	// Field is the index into StructProperties.Prop for the containing oneof.
	Field int
	// Prop is the properties for the field.
	Prop *Properties
	}

	// String formats the properties in the protobuf struct field tag style.
	func (p *Properties) String() string {
	s := p.Wire
	s += "," + strconv.Itoa(p.Tag)
	if p.Required {
	s += ",req"
	}
	if p.Optional {
	s += ",opt"
	}
	if p.Repeated {
	s += ",rep"
	}
	if p.Packed {
	s += ",packed"
	}
	s += ",name=" + p.OrigName
	if p.JSONName != "" {
	s += ",json=" + p.JSONName
	}
	if len(p.Enum) > 0 {
	s += ",enum=" + p.Enum
	}
	if len(p.Weak) > 0 {
	s += ",weak=" + p.Weak
	}
	if p.Proto3 {
	s += ",proto3"
	}
	if p.Oneof {
	s += ",oneof"
	}
	if p.HasDefault {
	s += ",def=" + p.Default
	}
	return s
	}

	// Parse populates p by parsing a string in the protobuf struct field tag style.
	func (p *Properties) Parse(tag string) {
	// For example: "bytes,49,opt,name=foo,def=hello!"
	for len(tag) > 0 {
	i := strings.IndexByte(tag, ',')
	if i < 0 {
	i = len(tag)
	}
	switch s := tag[:i]; {
	case strings.HasPrefix(s, "name="):
	p.OrigName = s[len("name="):]
	case strings.HasPrefix(s, "json="):
	p.JSONName = s[len("json="):]
	case strings.HasPrefix(s, "enum="):
	p.Enum = s[len("enum="):]
	case strings.HasPrefix(s, "weak="):
	p.Weak = s[len("weak="):]
	case strings.Trim(s, "0123456789") == "":
	n, _ := strconv.ParseUint(s, 10, 32)
	p.Tag = int(n)
	case s == "opt":
	p.Optional = true
	case s == "req":
	p.Required = true
	case s == "rep":
	p.Repeated = true
	case s == "varint" \|\| s == "zigzag32" \|\| s == "zigzag64":
	p.Wire = s
	p.WireType = WireVarint
	case s == "fixed32":
	p.Wire = s
	p.WireType = WireFixed32
	case s == "fixed64":
	p.Wire = s
	p.WireType = WireFixed64
	case s == "bytes":
	p.Wire = s
	p.WireType = WireBytes
	case s == "group":
	p.Wire = s
	p.WireType = WireStartGroup
	case s == "packed":
	p.Packed = true
	case s == "proto3":
	p.Proto3 = true
	case s == "oneof":
	p.Oneof = true
	case strings.HasPrefix(s, "def="):
	// The default tag is special in that everything afterwards is the
	// default regardless of the presence of commas.
	p.HasDefault = true
	p.Default, i = tag[len("def="):], len(tag)
	}
	tag = strings.TrimPrefix(tag[i:], ",")
	}
	}

	// Init populates the properties from a protocol buffer struct tag.
	//
	// Deprecated: Do not use.
	func (p Properties) Init(typ reflect.Type, name, tag string, f reflect.StructField) {
	p.Name = name
	p.OrigName = name
	if tag == "" {
	return
	}
	p.Parse(tag)

	if typ != nil && typ.Kind() == reflect.Map {
	p.MapKeyProp = new(Properties)
	p.MapKeyProp.Init(nil, "Key", f.Tag.Get("protobuf_key"), nil)
	p.MapValProp = new(Properties)
	p.MapValProp.Init(nil, "Value", f.Tag.Get("protobuf_val"), nil)
	}
	}

	var propertiesCache sync.Map // map[reflect.Type]*StructProperties

	// GetProperties returns the list of properties for the type represented by t,
	// which must be a generated protocol buffer message in the open-struct API,
	// where protobuf message fields are represented by exported Go struct fields.
	//
	// Deprecated: Use protobuf reflection instead.
	func GetProperties(t reflect.Type) *StructProperties {
	if p, ok := propertiesCache.Load(t); ok {
	return p.(*StructProperties)
	}
	p, _ := propertiesCache.LoadOrStore(t, newProperties(t))
	return p.(*StructProperties)
	}

	func newProperties(t reflect.Type) *StructProperties {
	if t.Kind() != reflect.Struct {
	panic(fmt.Sprintf("%v is not a generated message in the open-struct API", t))
	}

	var hasOneof bool
	prop := new(StructProperties)

	// Construct a list of properties for each field in the struct.
	for i := 0; i < t.NumField(); i++ {
	p := new(Properties)
	f := t.Field(i)
	tagField := f.Tag.Get("protobuf")
	p.Init(f.Type, f.Name, tagField, &f)

	tagOneof := f.Tag.Get("protobuf_oneof")
	if tagOneof != "" {
	hasOneof = true
	p.OrigName = tagOneof
	}

	// Rename unrelated struct fields with the "XXX_" prefix since so much
	// user code simply checks for this to exclude special fields.
	if tagField == "" && tagOneof == "" && !strings.HasPrefix(p.Name, "XXX_") {
	p.Name = "XXX_" + p.Name
	p.OrigName = "XXX_" + p.OrigName
	} else if p.Weak != "" {
	p.Name = p.OrigName // avoid possible "XXX_" prefix on weak field
	}

	prop.Prop = append(prop.Prop, p)
	}

	// Construct a mapping of oneof field names to properties.
	if hasOneof {
	var oneofWrappers []interface{}
	if fn, ok := reflect.PtrTo(t).MethodByName("XXX_OneofFuncs"); ok {
	oneofWrappers = fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))})[3].Interface().([]interface{})
	}
	if fn, ok := reflect.PtrTo(t).MethodByName("XXX_OneofWrappers"); ok {
	oneofWrappers = fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))})[0].Interface().([]interface{})
	}
	if m, ok := reflect.Zero(reflect.PtrTo(t)).Interface().(protoreflect.ProtoMessage); ok {
	if m, ok := m.ProtoReflect().(interface{ ProtoMessageInfo() *protoimpl.MessageInfo }); ok {
	oneofWrappers = m.ProtoMessageInfo().OneofWrappers
	}
	}

	prop.OneofTypes = make(map[string]*OneofProperties)
	for _, wrapper := range oneofWrappers {
	p := &OneofProperties{
	Type: reflect.ValueOf(wrapper).Type(), // *T
	Prop: new(Properties),
	}
	f := p.Type.Elem().Field(0)
	p.Prop.Name = f.Name
	p.Prop.Parse(f.Tag.Get("protobuf"))

	// Determine the struct field that contains this oneof.
	// Each wrapper is assignable to exactly one parent field.
	var foundOneof bool
	for i := 0; i < t.NumField() && !foundOneof; i++ {
	if p.Type.AssignableTo(t.Field(i).Type) {
	p.Field = i
	foundOneof = true
	}
	}
	if !foundOneof {
	panic(fmt.Sprintf("%v is not a generated message in the open-struct API", t))
	}
	prop.OneofTypes[p.Prop.OrigName] = p
	}
	}

	return prop
	}

	func (sp *StructProperties) Len() int { return len(sp.Prop) }
	func (sp *StructProperties) Less(i, j int) bool { return false }
	func (sp *StructProperties) Swap(i, j int) { return }