Source file src/google.golang.org/protobuf/internal/impl/codec_tables.go

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

     1  // Copyright 2019 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  
    11  	"google.golang.org/protobuf/encoding/protowire"
    12  	"google.golang.org/protobuf/internal/strs"
    13  	"google.golang.org/protobuf/reflect/protoreflect"
    14  )
    15  
    16  // pointerCoderFuncs is a set of pointer encoding functions.
    17  type pointerCoderFuncs struct {
    18  	mi        *MessageInfo
    19  	size      func(p pointer, f *coderFieldInfo, opts marshalOptions) int
    20  	marshal   func(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error)
    21  	unmarshal func(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error)
    22  	isInit    func(p pointer, f *coderFieldInfo) error
    23  	merge     func(dst, src pointer, f *coderFieldInfo, opts mergeOptions)
    24  }
    25  
    26  // valueCoderFuncs is a set of protoreflect.Value encoding functions.
    27  type valueCoderFuncs struct {
    28  	size      func(v protoreflect.Value, tagsize int, opts marshalOptions) int
    29  	marshal   func(b []byte, v protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error)
    30  	unmarshal func(b []byte, v protoreflect.Value, num protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (protoreflect.Value, unmarshalOutput, error)
    31  	isInit    func(v protoreflect.Value) error
    32  	merge     func(dst, src protoreflect.Value, opts mergeOptions) protoreflect.Value
    33  }
    34  
    35  // fieldCoder returns pointer functions for a field, used for operating on
    36  // struct fields.
    37  func fieldCoder(fd protoreflect.FieldDescriptor, ft reflect.Type) (*MessageInfo, pointerCoderFuncs) {
    38  	switch {
    39  	case fd.IsMap():
    40  		return encoderFuncsForMap(fd, ft)
    41  	case fd.Cardinality() == protoreflect.Repeated && !fd.IsPacked():
    42  		// Repeated fields (not packed).
    43  		if ft.Kind() != reflect.Slice {
    44  			break
    45  		}
    46  		ft := ft.Elem()
    47  		switch fd.Kind() {
    48  		case protoreflect.BoolKind:
    49  			if ft.Kind() == reflect.Bool {
    50  				return nil, coderBoolSlice
    51  			}
    52  		case protoreflect.EnumKind:
    53  			if ft.Kind() == reflect.Int32 {
    54  				return nil, coderEnumSlice
    55  			}
    56  		case protoreflect.Int32Kind:
    57  			if ft.Kind() == reflect.Int32 {
    58  				return nil, coderInt32Slice
    59  			}
    60  		case protoreflect.Sint32Kind:
    61  			if ft.Kind() == reflect.Int32 {
    62  				return nil, coderSint32Slice
    63  			}
    64  		case protoreflect.Uint32Kind:
    65  			if ft.Kind() == reflect.Uint32 {
    66  				return nil, coderUint32Slice
    67  			}
    68  		case protoreflect.Int64Kind:
    69  			if ft.Kind() == reflect.Int64 {
    70  				return nil, coderInt64Slice
    71  			}
    72  		case protoreflect.Sint64Kind:
    73  			if ft.Kind() == reflect.Int64 {
    74  				return nil, coderSint64Slice
    75  			}
    76  		case protoreflect.Uint64Kind:
    77  			if ft.Kind() == reflect.Uint64 {
    78  				return nil, coderUint64Slice
    79  			}
    80  		case protoreflect.Sfixed32Kind:
    81  			if ft.Kind() == reflect.Int32 {
    82  				return nil, coderSfixed32Slice
    83  			}
    84  		case protoreflect.Fixed32Kind:
    85  			if ft.Kind() == reflect.Uint32 {
    86  				return nil, coderFixed32Slice
    87  			}
    88  		case protoreflect.FloatKind:
    89  			if ft.Kind() == reflect.Float32 {
    90  				return nil, coderFloatSlice
    91  			}
    92  		case protoreflect.Sfixed64Kind:
    93  			if ft.Kind() == reflect.Int64 {
    94  				return nil, coderSfixed64Slice
    95  			}
    96  		case protoreflect.Fixed64Kind:
    97  			if ft.Kind() == reflect.Uint64 {
    98  				return nil, coderFixed64Slice
    99  			}
   100  		case protoreflect.DoubleKind:
   101  			if ft.Kind() == reflect.Float64 {
   102  				return nil, coderDoubleSlice
   103  			}
   104  		case protoreflect.StringKind:
   105  			if ft.Kind() == reflect.String && strs.EnforceUTF8(fd) {
   106  				return nil, coderStringSliceValidateUTF8
   107  			}
   108  			if ft.Kind() == reflect.String {
   109  				return nil, coderStringSlice
   110  			}
   111  			if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 && strs.EnforceUTF8(fd) {
   112  				return nil, coderBytesSliceValidateUTF8
   113  			}
   114  			if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 {
   115  				return nil, coderBytesSlice
   116  			}
   117  		case protoreflect.BytesKind:
   118  			if ft.Kind() == reflect.String {
   119  				return nil, coderStringSlice
   120  			}
   121  			if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 {
   122  				return nil, coderBytesSlice
   123  			}
   124  		case protoreflect.MessageKind:
   125  			return getMessageInfo(ft), makeMessageSliceFieldCoder(fd, ft)
   126  		case protoreflect.GroupKind:
   127  			return getMessageInfo(ft), makeGroupSliceFieldCoder(fd, ft)
   128  		}
   129  	case fd.Cardinality() == protoreflect.Repeated && fd.IsPacked():
   130  		// Packed repeated fields.
   131  		//
   132  		// Only repeated fields of primitive numeric types
   133  		// (Varint, Fixed32, or Fixed64 wire type) can be packed.
   134  		if ft.Kind() != reflect.Slice {
   135  			break
   136  		}
   137  		ft := ft.Elem()
   138  		switch fd.Kind() {
   139  		case protoreflect.BoolKind:
   140  			if ft.Kind() == reflect.Bool {
   141  				return nil, coderBoolPackedSlice
   142  			}
   143  		case protoreflect.EnumKind:
   144  			if ft.Kind() == reflect.Int32 {
   145  				return nil, coderEnumPackedSlice
   146  			}
   147  		case protoreflect.Int32Kind:
   148  			if ft.Kind() == reflect.Int32 {
   149  				return nil, coderInt32PackedSlice
   150  			}
   151  		case protoreflect.Sint32Kind:
   152  			if ft.Kind() == reflect.Int32 {
   153  				return nil, coderSint32PackedSlice
   154  			}
   155  		case protoreflect.Uint32Kind:
   156  			if ft.Kind() == reflect.Uint32 {
   157  				return nil, coderUint32PackedSlice
   158  			}
   159  		case protoreflect.Int64Kind:
   160  			if ft.Kind() == reflect.Int64 {
   161  				return nil, coderInt64PackedSlice
   162  			}
   163  		case protoreflect.Sint64Kind:
   164  			if ft.Kind() == reflect.Int64 {
   165  				return nil, coderSint64PackedSlice
   166  			}
   167  		case protoreflect.Uint64Kind:
   168  			if ft.Kind() == reflect.Uint64 {
   169  				return nil, coderUint64PackedSlice
   170  			}
   171  		case protoreflect.Sfixed32Kind:
   172  			if ft.Kind() == reflect.Int32 {
   173  				return nil, coderSfixed32PackedSlice
   174  			}
   175  		case protoreflect.Fixed32Kind:
   176  			if ft.Kind() == reflect.Uint32 {
   177  				return nil, coderFixed32PackedSlice
   178  			}
   179  		case protoreflect.FloatKind:
   180  			if ft.Kind() == reflect.Float32 {
   181  				return nil, coderFloatPackedSlice
   182  			}
   183  		case protoreflect.Sfixed64Kind:
   184  			if ft.Kind() == reflect.Int64 {
   185  				return nil, coderSfixed64PackedSlice
   186  			}
   187  		case protoreflect.Fixed64Kind:
   188  			if ft.Kind() == reflect.Uint64 {
   189  				return nil, coderFixed64PackedSlice
   190  			}
   191  		case protoreflect.DoubleKind:
   192  			if ft.Kind() == reflect.Float64 {
   193  				return nil, coderDoublePackedSlice
   194  			}
   195  		}
   196  	case fd.Kind() == protoreflect.MessageKind:
   197  		return getMessageInfo(ft), makeMessageFieldCoder(fd, ft)
   198  	case fd.Kind() == protoreflect.GroupKind:
   199  		return getMessageInfo(ft), makeGroupFieldCoder(fd, ft)
   200  	case fd.Syntax() == protoreflect.Proto3 && fd.ContainingOneof() == nil:
   201  		// Populated oneof fields always encode even if set to the zero value,
   202  		// which normally are not encoded in proto3.
   203  		switch fd.Kind() {
   204  		case protoreflect.BoolKind:
   205  			if ft.Kind() == reflect.Bool {
   206  				return nil, coderBoolNoZero
   207  			}
   208  		case protoreflect.EnumKind:
   209  			if ft.Kind() == reflect.Int32 {
   210  				return nil, coderEnumNoZero
   211  			}
   212  		case protoreflect.Int32Kind:
   213  			if ft.Kind() == reflect.Int32 {
   214  				return nil, coderInt32NoZero
   215  			}
   216  		case protoreflect.Sint32Kind:
   217  			if ft.Kind() == reflect.Int32 {
   218  				return nil, coderSint32NoZero
   219  			}
   220  		case protoreflect.Uint32Kind:
   221  			if ft.Kind() == reflect.Uint32 {
   222  				return nil, coderUint32NoZero
   223  			}
   224  		case protoreflect.Int64Kind:
   225  			if ft.Kind() == reflect.Int64 {
   226  				return nil, coderInt64NoZero
   227  			}
   228  		case protoreflect.Sint64Kind:
   229  			if ft.Kind() == reflect.Int64 {
   230  				return nil, coderSint64NoZero
   231  			}
   232  		case protoreflect.Uint64Kind:
   233  			if ft.Kind() == reflect.Uint64 {
   234  				return nil, coderUint64NoZero
   235  			}
   236  		case protoreflect.Sfixed32Kind:
   237  			if ft.Kind() == reflect.Int32 {
   238  				return nil, coderSfixed32NoZero
   239  			}
   240  		case protoreflect.Fixed32Kind:
   241  			if ft.Kind() == reflect.Uint32 {
   242  				return nil, coderFixed32NoZero
   243  			}
   244  		case protoreflect.FloatKind:
   245  			if ft.Kind() == reflect.Float32 {
   246  				return nil, coderFloatNoZero
   247  			}
   248  		case protoreflect.Sfixed64Kind:
   249  			if ft.Kind() == reflect.Int64 {
   250  				return nil, coderSfixed64NoZero
   251  			}
   252  		case protoreflect.Fixed64Kind:
   253  			if ft.Kind() == reflect.Uint64 {
   254  				return nil, coderFixed64NoZero
   255  			}
   256  		case protoreflect.DoubleKind:
   257  			if ft.Kind() == reflect.Float64 {
   258  				return nil, coderDoubleNoZero
   259  			}
   260  		case protoreflect.StringKind:
   261  			if ft.Kind() == reflect.String && strs.EnforceUTF8(fd) {
   262  				return nil, coderStringNoZeroValidateUTF8
   263  			}
   264  			if ft.Kind() == reflect.String {
   265  				return nil, coderStringNoZero
   266  			}
   267  			if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 && strs.EnforceUTF8(fd) {
   268  				return nil, coderBytesNoZeroValidateUTF8
   269  			}
   270  			if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 {
   271  				return nil, coderBytesNoZero
   272  			}
   273  		case protoreflect.BytesKind:
   274  			if ft.Kind() == reflect.String {
   275  				return nil, coderStringNoZero
   276  			}
   277  			if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 {
   278  				return nil, coderBytesNoZero
   279  			}
   280  		}
   281  	case ft.Kind() == reflect.Ptr:
   282  		ft := ft.Elem()
   283  		switch fd.Kind() {
   284  		case protoreflect.BoolKind:
   285  			if ft.Kind() == reflect.Bool {
   286  				return nil, coderBoolPtr
   287  			}
   288  		case protoreflect.EnumKind:
   289  			if ft.Kind() == reflect.Int32 {
   290  				return nil, coderEnumPtr
   291  			}
   292  		case protoreflect.Int32Kind:
   293  			if ft.Kind() == reflect.Int32 {
   294  				return nil, coderInt32Ptr
   295  			}
   296  		case protoreflect.Sint32Kind:
   297  			if ft.Kind() == reflect.Int32 {
   298  				return nil, coderSint32Ptr
   299  			}
   300  		case protoreflect.Uint32Kind:
   301  			if ft.Kind() == reflect.Uint32 {
   302  				return nil, coderUint32Ptr
   303  			}
   304  		case protoreflect.Int64Kind:
   305  			if ft.Kind() == reflect.Int64 {
   306  				return nil, coderInt64Ptr
   307  			}
   308  		case protoreflect.Sint64Kind:
   309  			if ft.Kind() == reflect.Int64 {
   310  				return nil, coderSint64Ptr
   311  			}
   312  		case protoreflect.Uint64Kind:
   313  			if ft.Kind() == reflect.Uint64 {
   314  				return nil, coderUint64Ptr
   315  			}
   316  		case protoreflect.Sfixed32Kind:
   317  			if ft.Kind() == reflect.Int32 {
   318  				return nil, coderSfixed32Ptr
   319  			}
   320  		case protoreflect.Fixed32Kind:
   321  			if ft.Kind() == reflect.Uint32 {
   322  				return nil, coderFixed32Ptr
   323  			}
   324  		case protoreflect.FloatKind:
   325  			if ft.Kind() == reflect.Float32 {
   326  				return nil, coderFloatPtr
   327  			}
   328  		case protoreflect.Sfixed64Kind:
   329  			if ft.Kind() == reflect.Int64 {
   330  				return nil, coderSfixed64Ptr
   331  			}
   332  		case protoreflect.Fixed64Kind:
   333  			if ft.Kind() == reflect.Uint64 {
   334  				return nil, coderFixed64Ptr
   335  			}
   336  		case protoreflect.DoubleKind:
   337  			if ft.Kind() == reflect.Float64 {
   338  				return nil, coderDoublePtr
   339  			}
   340  		case protoreflect.StringKind:
   341  			if ft.Kind() == reflect.String && strs.EnforceUTF8(fd) {
   342  				return nil, coderStringPtrValidateUTF8
   343  			}
   344  			if ft.Kind() == reflect.String {
   345  				return nil, coderStringPtr
   346  			}
   347  		case protoreflect.BytesKind:
   348  			if ft.Kind() == reflect.String {
   349  				return nil, coderStringPtr
   350  			}
   351  		}
   352  	default:
   353  		switch fd.Kind() {
   354  		case protoreflect.BoolKind:
   355  			if ft.Kind() == reflect.Bool {
   356  				return nil, coderBool
   357  			}
   358  		case protoreflect.EnumKind:
   359  			if ft.Kind() == reflect.Int32 {
   360  				return nil, coderEnum
   361  			}
   362  		case protoreflect.Int32Kind:
   363  			if ft.Kind() == reflect.Int32 {
   364  				return nil, coderInt32
   365  			}
   366  		case protoreflect.Sint32Kind:
   367  			if ft.Kind() == reflect.Int32 {
   368  				return nil, coderSint32
   369  			}
   370  		case protoreflect.Uint32Kind:
   371  			if ft.Kind() == reflect.Uint32 {
   372  				return nil, coderUint32
   373  			}
   374  		case protoreflect.Int64Kind:
   375  			if ft.Kind() == reflect.Int64 {
   376  				return nil, coderInt64
   377  			}
   378  		case protoreflect.Sint64Kind:
   379  			if ft.Kind() == reflect.Int64 {
   380  				return nil, coderSint64
   381  			}
   382  		case protoreflect.Uint64Kind:
   383  			if ft.Kind() == reflect.Uint64 {
   384  				return nil, coderUint64
   385  			}
   386  		case protoreflect.Sfixed32Kind:
   387  			if ft.Kind() == reflect.Int32 {
   388  				return nil, coderSfixed32
   389  			}
   390  		case protoreflect.Fixed32Kind:
   391  			if ft.Kind() == reflect.Uint32 {
   392  				return nil, coderFixed32
   393  			}
   394  		case protoreflect.FloatKind:
   395  			if ft.Kind() == reflect.Float32 {
   396  				return nil, coderFloat
   397  			}
   398  		case protoreflect.Sfixed64Kind:
   399  			if ft.Kind() == reflect.Int64 {
   400  				return nil, coderSfixed64
   401  			}
   402  		case protoreflect.Fixed64Kind:
   403  			if ft.Kind() == reflect.Uint64 {
   404  				return nil, coderFixed64
   405  			}
   406  		case protoreflect.DoubleKind:
   407  			if ft.Kind() == reflect.Float64 {
   408  				return nil, coderDouble
   409  			}
   410  		case protoreflect.StringKind:
   411  			if ft.Kind() == reflect.String && strs.EnforceUTF8(fd) {
   412  				return nil, coderStringValidateUTF8
   413  			}
   414  			if ft.Kind() == reflect.String {
   415  				return nil, coderString
   416  			}
   417  			if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 && strs.EnforceUTF8(fd) {
   418  				return nil, coderBytesValidateUTF8
   419  			}
   420  			if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 {
   421  				return nil, coderBytes
   422  			}
   423  		case protoreflect.BytesKind:
   424  			if ft.Kind() == reflect.String {
   425  				return nil, coderString
   426  			}
   427  			if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 {
   428  				return nil, coderBytes
   429  			}
   430  		}
   431  	}
   432  	panic(fmt.Sprintf("invalid type: no encoder for %v %v %v/%v", fd.FullName(), fd.Cardinality(), fd.Kind(), ft))
   433  }
   434  
   435  // encoderFuncsForValue returns value functions for a field, used for
   436  // extension values and map encoding.
   437  func encoderFuncsForValue(fd protoreflect.FieldDescriptor) valueCoderFuncs {
   438  	switch {
   439  	case fd.Cardinality() == protoreflect.Repeated && !fd.IsPacked():
   440  		switch fd.Kind() {
   441  		case protoreflect.BoolKind:
   442  			return coderBoolSliceValue
   443  		case protoreflect.EnumKind:
   444  			return coderEnumSliceValue
   445  		case protoreflect.Int32Kind:
   446  			return coderInt32SliceValue
   447  		case protoreflect.Sint32Kind:
   448  			return coderSint32SliceValue
   449  		case protoreflect.Uint32Kind:
   450  			return coderUint32SliceValue
   451  		case protoreflect.Int64Kind:
   452  			return coderInt64SliceValue
   453  		case protoreflect.Sint64Kind:
   454  			return coderSint64SliceValue
   455  		case protoreflect.Uint64Kind:
   456  			return coderUint64SliceValue
   457  		case protoreflect.Sfixed32Kind:
   458  			return coderSfixed32SliceValue
   459  		case protoreflect.Fixed32Kind:
   460  			return coderFixed32SliceValue
   461  		case protoreflect.FloatKind:
   462  			return coderFloatSliceValue
   463  		case protoreflect.Sfixed64Kind:
   464  			return coderSfixed64SliceValue
   465  		case protoreflect.Fixed64Kind:
   466  			return coderFixed64SliceValue
   467  		case protoreflect.DoubleKind:
   468  			return coderDoubleSliceValue
   469  		case protoreflect.StringKind:
   470  			// We don't have a UTF-8 validating coder for repeated string fields.
   471  			// Value coders are used for extensions and maps.
   472  			// Extensions are never proto3, and maps never contain lists.
   473  			return coderStringSliceValue
   474  		case protoreflect.BytesKind:
   475  			return coderBytesSliceValue
   476  		case protoreflect.MessageKind:
   477  			return coderMessageSliceValue
   478  		case protoreflect.GroupKind:
   479  			return coderGroupSliceValue
   480  		}
   481  	case fd.Cardinality() == protoreflect.Repeated && fd.IsPacked():
   482  		switch fd.Kind() {
   483  		case protoreflect.BoolKind:
   484  			return coderBoolPackedSliceValue
   485  		case protoreflect.EnumKind:
   486  			return coderEnumPackedSliceValue
   487  		case protoreflect.Int32Kind:
   488  			return coderInt32PackedSliceValue
   489  		case protoreflect.Sint32Kind:
   490  			return coderSint32PackedSliceValue
   491  		case protoreflect.Uint32Kind:
   492  			return coderUint32PackedSliceValue
   493  		case protoreflect.Int64Kind:
   494  			return coderInt64PackedSliceValue
   495  		case protoreflect.Sint64Kind:
   496  			return coderSint64PackedSliceValue
   497  		case protoreflect.Uint64Kind:
   498  			return coderUint64PackedSliceValue
   499  		case protoreflect.Sfixed32Kind:
   500  			return coderSfixed32PackedSliceValue
   501  		case protoreflect.Fixed32Kind:
   502  			return coderFixed32PackedSliceValue
   503  		case protoreflect.FloatKind:
   504  			return coderFloatPackedSliceValue
   505  		case protoreflect.Sfixed64Kind:
   506  			return coderSfixed64PackedSliceValue
   507  		case protoreflect.Fixed64Kind:
   508  			return coderFixed64PackedSliceValue
   509  		case protoreflect.DoubleKind:
   510  			return coderDoublePackedSliceValue
   511  		}
   512  	default:
   513  		switch fd.Kind() {
   514  		default:
   515  		case protoreflect.BoolKind:
   516  			return coderBoolValue
   517  		case protoreflect.EnumKind:
   518  			return coderEnumValue
   519  		case protoreflect.Int32Kind:
   520  			return coderInt32Value
   521  		case protoreflect.Sint32Kind:
   522  			return coderSint32Value
   523  		case protoreflect.Uint32Kind:
   524  			return coderUint32Value
   525  		case protoreflect.Int64Kind:
   526  			return coderInt64Value
   527  		case protoreflect.Sint64Kind:
   528  			return coderSint64Value
   529  		case protoreflect.Uint64Kind:
   530  			return coderUint64Value
   531  		case protoreflect.Sfixed32Kind:
   532  			return coderSfixed32Value
   533  		case protoreflect.Fixed32Kind:
   534  			return coderFixed32Value
   535  		case protoreflect.FloatKind:
   536  			return coderFloatValue
   537  		case protoreflect.Sfixed64Kind:
   538  			return coderSfixed64Value
   539  		case protoreflect.Fixed64Kind:
   540  			return coderFixed64Value
   541  		case protoreflect.DoubleKind:
   542  			return coderDoubleValue
   543  		case protoreflect.StringKind:
   544  			if strs.EnforceUTF8(fd) {
   545  				return coderStringValueValidateUTF8
   546  			}
   547  			return coderStringValue
   548  		case protoreflect.BytesKind:
   549  			return coderBytesValue
   550  		case protoreflect.MessageKind:
   551  			return coderMessageValue
   552  		case protoreflect.GroupKind:
   553  			return coderGroupValue
   554  		}
   555  	}
   556  	panic(fmt.Sprintf("invalid field: no encoder for %v %v %v", fd.FullName(), fd.Cardinality(), fd.Kind()))
   557  }
   558  

View as plain text