internal/impl/export.go

// Copyright 2018 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 impl

import (
	"strconv"

	"github.com/golang/protobuf/v2/encoding/textpb"
	ptype "github.com/golang/protobuf/v2/internal/prototype"
	pref "github.com/golang/protobuf/v2/reflect/protoreflect"
)

// Export is a zero-length named type that exists only to export a set of
// functions that we do not want to appear in godoc.
type Export struct{}

// EnumOf returns the protoreflect.Enum interface over e.
// If e already implements proto.Enum, then it directly calls the
// ProtoReflect method, otherwise it wraps the v1 enum to implement
// the v2 reflective interface.
func (Export) EnumOf(e interface{}) pref.Enum {
	if ev, ok := e.(pref.Enum); ok {
		return ev
	}
	return legacyWrapper.EnumOf(e)
}

// EnumTypeOf returns the protoreflect.EnumType for e.
// If e already implements proto.Enum, then it obtains the type by directly
// calling the ProtoReflect.Type method, otherwise it derives an enum type
// from the v1 named int32 type.
func (Export) EnumTypeOf(e interface{}) pref.EnumType {
	if ev, ok := e.(pref.Enum); ok {
		return ev.Type()
	}
	return legacyWrapper.EnumTypeOf(e)
}

// EnumStringOf returns the enum value as a string, either as the name if
// the number is resolvable, or the number formatted as a string.
func (Export) EnumStringOf(ed pref.EnumDescriptor, n pref.EnumNumber) string {
	ev := ed.Values().ByNumber(n)
	if ev != nil {
		return string(ev.Name())
	}
	return strconv.Itoa(int(n))
}

// MessageOf returns the protoreflect.Message interface over m.
// If m already implements proto.Message, then it directly calls the
// ProtoReflect method, otherwise it wraps the v1 message to implement
// the v2 reflective interface.
func (Export) MessageOf(m interface{}) pref.Message {
	if mv, ok := m.(pref.ProtoMessage); ok {
		return mv.ProtoReflect()
	}
	return legacyWrapper.MessageOf(m)
}

// MessageTypeOf returns the protoreflect.MessageType for m.
// If m already implements proto.Message, then it obtains the type by directly
// calling the ProtoReflect.Type method, otherwise it derives a message type
// from the v1 message struct.
func (Export) MessageTypeOf(m interface{}) pref.MessageType {
	if mv, ok := m.(pref.ProtoMessage); ok {
		return mv.ProtoReflect().Type()
	}
	return legacyWrapper.MessageTypeOf(m)
}

// ExtensionTypeOf returns a protoreflect.ExtensionType where the type of the
// field is t. The type t must be provided if the field is an enum or message.
// If t already implements proto.Enum or proto.Message, then this returns
// an extension type by directly calling prototype.GoExtension.
// Otherwise, it derives an extension type by wrapping the enum or message
// using EnumOf or MessageOf.
func (Export) ExtensionTypeOf(d pref.ExtensionDescriptor, t interface{}) pref.ExtensionType {
	switch t := t.(type) {
	case nil:
		return ptype.GoExtension(d, nil, nil)
	case pref.Enum:
		return ptype.GoExtension(d, t.Type(), nil)
	case pref.ProtoMessage:
		return ptype.GoExtension(d, nil, t.ProtoReflect().Type())
	}
	return legacyWrapper.ExtensionTypeOf(d, t)
}

// MessageStringOf returns the message value as a string,
// which is the message serialized in the protobuf text format.
func (Export) MessageStringOf(m pref.ProtoMessage) string {
	b, _ := textpb.MarshalOptions{AllowPartial: true}.Marshal(m)
	return string(b)
}