api_export.go

Documentation: google.golang.org/protobuf/internal/impl

     1  // Copyright 2018 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package impl
     6  
     7  import (
     8  	"fmt"
     9  	"reflect"
    10  	"strconv"
    11  
    12  	"google.golang.org/protobuf/encoding/prototext"
    13  	"google.golang.org/protobuf/internal/errors"
    14  	"google.golang.org/protobuf/proto"
    15  	"google.golang.org/protobuf/reflect/protoreflect"
    16  	"google.golang.org/protobuf/runtime/protoiface"
    17  )
    18  
    19  // Export is a zero-length named type that exists only to export a set of
    20  // functions that we do not want to appear in godoc.
    21  type Export struct{}
    22  
    23  // NewError formats a string according to the format specifier and arguments and
    24  // returns an error that has a "proto" prefix.
    25  func (Export) NewError(f string, x ...interface{}) error {
    26  	return errors.New(f, x...)
    27  }
    28  
    29  // enum is any enum type generated by protoc-gen-go
    30  // and must be a named int32 type.
    31  type enum = interface{}
    32  
    33  // EnumOf returns the protoreflect.Enum interface over e.
    34  // It returns nil if e is nil.
    35  func (Export) EnumOf(e enum) protoreflect.Enum {
    36  	switch e := e.(type) {
    37  	case nil:
    38  		return nil
    39  	case protoreflect.Enum:
    40  		return e
    41  	default:
    42  		return legacyWrapEnum(reflect.ValueOf(e))
    43  	}
    44  }
    45  
    46  // EnumDescriptorOf returns the protoreflect.EnumDescriptor for e.
    47  // It returns nil if e is nil.
    48  func (Export) EnumDescriptorOf(e enum) protoreflect.EnumDescriptor {
    49  	switch e := e.(type) {
    50  	case nil:
    51  		return nil
    52  	case protoreflect.Enum:
    53  		return e.Descriptor()
    54  	default:
    55  		return LegacyLoadEnumDesc(reflect.TypeOf(e))
    56  	}
    57  }
    58  
    59  // EnumTypeOf returns the protoreflect.EnumType for e.
    60  // It returns nil if e is nil.
    61  func (Export) EnumTypeOf(e enum) protoreflect.EnumType {
    62  	switch e := e.(type) {
    63  	case nil:
    64  		return nil
    65  	case protoreflect.Enum:
    66  		return e.Type()
    67  	default:
    68  		return legacyLoadEnumType(reflect.TypeOf(e))
    69  	}
    70  }
    71  
    72  // EnumStringOf returns the enum value as a string, either as the name if
    73  // the number is resolvable, or the number formatted as a string.
    74  func (Export) EnumStringOf(ed protoreflect.EnumDescriptor, n protoreflect.EnumNumber) string {
    75  	ev := ed.Values().ByNumber(n)
    76  	if ev != nil {
    77  		return string(ev.Name())
    78  	}
    79  	return strconv.Itoa(int(n))
    80  }
    81  
    82  // message is any message type generated by protoc-gen-go
    83  // and must be a pointer to a named struct type.
    84  type message = interface{}
    85  
    86  // legacyMessageWrapper wraps a v2 message as a v1 message.
    87  type legacyMessageWrapper struct{ m protoreflect.ProtoMessage }
    88  
    89  func (m legacyMessageWrapper) Reset()         { proto.Reset(m.m) }
    90  func (m legacyMessageWrapper) String() string { return Export{}.MessageStringOf(m.m) }
    91  func (m legacyMessageWrapper) ProtoMessage()  {}
    92  
    93  // ProtoMessageV1Of converts either a v1 or v2 message to a v1 message.
    94  // It returns nil if m is nil.
    95  func (Export) ProtoMessageV1Of(m message) protoiface.MessageV1 {
    96  	switch mv := m.(type) {
    97  	case nil:
    98  		return nil
    99  	case protoiface.MessageV1:
   100  		return mv
   101  	case unwrapper:
   102  		return Export{}.ProtoMessageV1Of(mv.protoUnwrap())
   103  	case protoreflect.ProtoMessage:
   104  		return legacyMessageWrapper{mv}
   105  	default:
   106  		panic(fmt.Sprintf("message %T is neither a v1 or v2 Message", m))
   107  	}
   108  }
   109  
   110  func (Export) protoMessageV2Of(m message) protoreflect.ProtoMessage {
   111  	switch mv := m.(type) {
   112  	case nil:
   113  		return nil
   114  	case protoreflect.ProtoMessage:
   115  		return mv
   116  	case legacyMessageWrapper:
   117  		return mv.m
   118  	case protoiface.MessageV1:
   119  		return nil
   120  	default:
   121  		panic(fmt.Sprintf("message %T is neither a v1 or v2 Message", m))
   122  	}
   123  }
   124  
   125  // ProtoMessageV2Of converts either a v1 or v2 message to a v2 message.
   126  // It returns nil if m is nil.
   127  func (Export) ProtoMessageV2Of(m message) protoreflect.ProtoMessage {
   128  	if m == nil {
   129  		return nil
   130  	}
   131  	if mv := (Export{}).protoMessageV2Of(m); mv != nil {
   132  		return mv
   133  	}
   134  	return legacyWrapMessage(reflect.ValueOf(m)).Interface()
   135  }
   136  
   137  // MessageOf returns the protoreflect.Message interface over m.
   138  // It returns nil if m is nil.
   139  func (Export) MessageOf(m message) protoreflect.Message {
   140  	if m == nil {
   141  		return nil
   142  	}
   143  	if mv := (Export{}).protoMessageV2Of(m); mv != nil {
   144  		return mv.ProtoReflect()
   145  	}
   146  	return legacyWrapMessage(reflect.ValueOf(m))
   147  }
   148  
   149  // MessageDescriptorOf returns the protoreflect.MessageDescriptor for m.
   150  // It returns nil if m is nil.
   151  func (Export) MessageDescriptorOf(m message) protoreflect.MessageDescriptor {
   152  	if m == nil {
   153  		return nil
   154  	}
   155  	if mv := (Export{}).protoMessageV2Of(m); mv != nil {
   156  		return mv.ProtoReflect().Descriptor()
   157  	}
   158  	return LegacyLoadMessageDesc(reflect.TypeOf(m))
   159  }
   160  
   161  // MessageTypeOf returns the protoreflect.MessageType for m.
   162  // It returns nil if m is nil.
   163  func (Export) MessageTypeOf(m message) protoreflect.MessageType {
   164  	if m == nil {
   165  		return nil
   166  	}
   167  	if mv := (Export{}).protoMessageV2Of(m); mv != nil {
   168  		return mv.ProtoReflect().Type()
   169  	}
   170  	return legacyLoadMessageType(reflect.TypeOf(m), "")
   171  }
   172  
   173  // MessageStringOf returns the message value as a string,
   174  // which is the message serialized in the protobuf text format.
   175  func (Export) MessageStringOf(m protoreflect.ProtoMessage) string {
   176  	return prototext.MarshalOptions{Multiline: false}.Format(m)
   177  }
   178
View as plain text