source: code/trunk/vendor/github.com/golang/protobuf/proto/properties.go@ 822

// 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 }