Well known type wrappers

[vmg]

@biosvs pointed out this comment and I quite like the approach. I've implemented it and it took very few changes to the generator code to make it work for all Well-known types.

The generated code is a bit noisy because of the type casting but very efficient in practice. Unless somebody points a glaring issue in this PR, this is how we'll add support for fast (de)serialization of WKTs.

[vmg]

• Example of a generated type wrapper: https://github.com/planetscale/vtprotobuf/blob/f080268430b80a37547d21886c3a5aecfcf15dcb/types/known/anypb/any_vtproto.pb.go

• Example of integrating a WKT in an existing struct:

  • Equals:

    vtprotobuf/testproto/wkt/wkt_vtproto.pb.go

    Lines 64 to 112 in f080268

    	func (this *MessageWithWKT) EqualVT(that *MessageWithWKT) bool {
    	if this == that {
    	return true
    	} else if this == nil || that == nil {
    	return false
    	}
    	if !(*anypb1.Any)(this.Any).EqualVT((*anypb1.Any)(that.Any)) {
    	return false
    	}
    	if !(*durationpb1.Duration)(this.Duration).EqualVT((*durationpb1.Duration)(that.Duration)) {
    	return false
    	}
    	if !(*emptypb1.Empty)(this.Empty).EqualVT((*emptypb1.Empty)(that.Empty)) {
    	return false
    	}
    	if !(*fieldmaskpb1.FieldMask)(this.FieldMask).EqualVT((*fieldmaskpb1.FieldMask)(that.FieldMask)) {
    	return false
    	}
    	if !(*timestamppb1.Timestamp)(this.Timestamp).EqualVT((*timestamppb1.Timestamp)(that.Timestamp)) {
    	return false
    	}
    	if !(*wrapperspb1.DoubleValue)(this.DoubleValue).EqualVT((*wrapperspb1.DoubleValue)(that.DoubleValue)) {
    	return false
    	}
    	if !(*wrapperspb1.FloatValue)(this.FloatValue).EqualVT((*wrapperspb1.FloatValue)(that.FloatValue)) {
    	return false
    	}
    	if !(*wrapperspb1.Int64Value)(this.Int64Value).EqualVT((*wrapperspb1.Int64Value)(that.Int64Value)) {
    	return false
    	}
    	if !(*wrapperspb1.UInt64Value)(this.Uint64Value).EqualVT((*wrapperspb1.UInt64Value)(that.Uint64Value)) {
    	return false
    	}
    	if !(*wrapperspb1.Int32Value)(this.Int32Value).EqualVT((*wrapperspb1.Int32Value)(that.Int32Value)) {
    	return false
    	}
    	if !(*wrapperspb1.UInt32Value)(this.Uint32Value).EqualVT((*wrapperspb1.UInt32Value)(that.Uint32Value)) {
    	return false
    	}
    	if !(*wrapperspb1.BoolValue)(this.BoolValue).EqualVT((*wrapperspb1.BoolValue)(that.BoolValue)) {
    	return false
    	}
    	if !(*wrapperspb1.StringValue)(this.StringValue).EqualVT((*wrapperspb1.StringValue)(that.StringValue)) {
    	return false
    	}
    	if !(*wrapperspb1.BytesValue)(this.BytesValue).EqualVT((*wrapperspb1.BytesValue)(that.BytesValue)) {
    	return false
    	}
    	return string(this.unknownFields) == string(that.unknownFields)

  • Marshal:

    vtprotobuf/testproto/wkt/wkt_vtproto.pb.go

    Lines 140 to 293 in f080268

    	func (m *MessageWithWKT) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
    	if m == nil {
    	return 0, nil
    	}
    	i := len(dAtA)
    	_ = i
    	var l int
    	_ = l
    	if m.unknownFields != nil {
    	i -= len(m.unknownFields)
    	copy(dAtA[i:], m.unknownFields)
    	}
    	if m.BytesValue != nil {
    	size, err := (*wrapperspb1.BytesValue)(m.BytesValue).MarshalToSizedBufferVT(dAtA[:i])
    	if err != nil {
    	return 0, err
    	}
    	i -= size
    	i = encodeVarint(dAtA, i, uint64(size))
    	i--
    	dAtA[i] = 0x72
    	}
    	if m.StringValue != nil {
    	size, err := (*wrapperspb1.StringValue)(m.StringValue).MarshalToSizedBufferVT(dAtA[:i])
    	if err != nil {
    	return 0, err
    	}
    	i -= size
    	i = encodeVarint(dAtA, i, uint64(size))
    	i--
    	dAtA[i] = 0x6a
    	}
    	if m.BoolValue != nil {
    	size, err := (*wrapperspb1.BoolValue)(m.BoolValue).MarshalToSizedBufferVT(dAtA[:i])
    	if err != nil {
    	return 0, err
    	}
    	i -= size
    	i = encodeVarint(dAtA, i, uint64(size))
    	i--
    	dAtA[i] = 0x62
    	}
    	if m.Uint32Value != nil {
    	size, err := (*wrapperspb1.UInt32Value)(m.Uint32Value).MarshalToSizedBufferVT(dAtA[:i])
    	if err != nil {
    	return 0, err
    	}
    	i -= size
    	i = encodeVarint(dAtA, i, uint64(size))
    	i--
    	dAtA[i] = 0x5a
    	}
    	if m.Int32Value != nil {
    	size, err := (*wrapperspb1.Int32Value)(m.Int32Value).MarshalToSizedBufferVT(dAtA[:i])
    	if err != nil {
    	return 0, err
    	}
    	i -= size
    	i = encodeVarint(dAtA, i, uint64(size))
    	i--
    	dAtA[i] = 0x52
    	}
    	if m.Uint64Value != nil {
    	size, err := (*wrapperspb1.UInt64Value)(m.Uint64Value).MarshalToSizedBufferVT(dAtA[:i])
    	if err != nil {
    	return 0, err
    	}
    	i -= size
    	i = encodeVarint(dAtA, i, uint64(size))
    	i--
    	dAtA[i] = 0x4a
    	}
    	if m.Int64Value != nil {
    	size, err := (*wrapperspb1.Int64Value)(m.Int64Value).MarshalToSizedBufferVT(dAtA[:i])
    	if err != nil {
    	return 0, err
    	}
    	i -= size
    	i = encodeVarint(dAtA, i, uint64(size))
    	i--
    	dAtA[i] = 0x42
    	}
    	if m.FloatValue != nil {
    	size, err := (*wrapperspb1.FloatValue)(m.FloatValue).MarshalToSizedBufferVT(dAtA[:i])
    	if err != nil {
    	return 0, err
    	}
    	i -= size
    	i = encodeVarint(dAtA, i, uint64(size))
    	i--
    	dAtA[i] = 0x3a
    	}
    	if m.DoubleValue != nil {
    	size, err := (*wrapperspb1.DoubleValue)(m.DoubleValue).MarshalToSizedBufferVT(dAtA[:i])
    	if err != nil {
    	return 0, err
    	}
    	i -= size
    	i = encodeVarint(dAtA, i, uint64(size))
    	i--
    	dAtA[i] = 0x32
    	}
    	if m.Timestamp != nil {
    	size, err := (*timestamppb1.Timestamp)(m.Timestamp).MarshalToSizedBufferVT(dAtA[:i])
    	if err != nil {
    	return 0, err
    	}
    	i -= size
    	i = encodeVarint(dAtA, i, uint64(size))
    	i--
    	dAtA[i] = 0x2a
    	}
    	if m.FieldMask != nil {
    	size, err := (*fieldmaskpb1.FieldMask)(m.FieldMask).MarshalToSizedBufferVT(dAtA[:i])
    	if err != nil {
    	return 0, err
    	}
    	i -= size
    	i = encodeVarint(dAtA, i, uint64(size))
    	i--
    	dAtA[i] = 0x22
    	}
    	if m.Empty != nil {
    	size, err := (*emptypb1.Empty)(m.Empty).MarshalToSizedBufferVT(dAtA[:i])
    	if err != nil {
    	return 0, err
    	}
    	i -= size
    	i = encodeVarint(dAtA, i, uint64(size))
    	i--
    	dAtA[i] = 0x1a
    	}
    	if m.Duration != nil {
    	size, err := (*durationpb1.Duration)(m.Duration).MarshalToSizedBufferVT(dAtA[:i])
    	if err != nil {
    	return 0, err
    	}
    	i -= size
    	i = encodeVarint(dAtA, i, uint64(size))
    	i--
    	dAtA[i] = 0x12
    	}
    	if m.Any != nil {
    	size, err := (*anypb1.Any)(m.Any).MarshalToSizedBufferVT(dAtA[:i])
    	if err != nil {
    	return 0, err
    	}
    	i -= size
    	i = encodeVarint(dAtA, i, uint64(size))
    	i--
    	dAtA[i] = 0xa
    	}
    	return len(dAtA) - i, nil
    	}

  • Size:

    vtprotobuf/testproto/wkt/wkt_vtproto.pb.go

    Lines 479 to 543 in f080268

    	func (m *MessageWithWKT) SizeVT() (n int) {
    	if m == nil {
    	return 0
    	}
    	var l int
    	_ = l
    	if m.Any != nil {
    	l = (*anypb1.Any)(m.Any).SizeVT()
    	n += 1 + l + sov(uint64(l))
    	}
    	if m.Duration != nil {
    	l = (*durationpb1.Duration)(m.Duration).SizeVT()
    	n += 1 + l + sov(uint64(l))
    	}
    	if m.Empty != nil {
    	l = (*emptypb1.Empty)(m.Empty).SizeVT()
    	n += 1 + l + sov(uint64(l))
    	}
    	if m.FieldMask != nil {
    	l = (*fieldmaskpb1.FieldMask)(m.FieldMask).SizeVT()
    	n += 1 + l + sov(uint64(l))
    	}
    	if m.Timestamp != nil {
    	l = (*timestamppb1.Timestamp)(m.Timestamp).SizeVT()
    	n += 1 + l + sov(uint64(l))
    	}
    	if m.DoubleValue != nil {
    	l = (*wrapperspb1.DoubleValue)(m.DoubleValue).SizeVT()
    	n += 1 + l + sov(uint64(l))
    	}
    	if m.FloatValue != nil {
    	l = (*wrapperspb1.FloatValue)(m.FloatValue).SizeVT()
    	n += 1 + l + sov(uint64(l))
    	}
    	if m.Int64Value != nil {
    	l = (*wrapperspb1.Int64Value)(m.Int64Value).SizeVT()
    	n += 1 + l + sov(uint64(l))
    	}
    	if m.Uint64Value != nil {
    	l = (*wrapperspb1.UInt64Value)(m.Uint64Value).SizeVT()
    	n += 1 + l + sov(uint64(l))
    	}
    	if m.Int32Value != nil {
    	l = (*wrapperspb1.Int32Value)(m.Int32Value).SizeVT()
    	n += 1 + l + sov(uint64(l))
    	}
    	if m.Uint32Value != nil {
    	l = (*wrapperspb1.UInt32Value)(m.Uint32Value).SizeVT()
    	n += 1 + l + sov(uint64(l))
    	}
    	if m.BoolValue != nil {
    	l = (*wrapperspb1.BoolValue)(m.BoolValue).SizeVT()
    	n += 1 + l + sov(uint64(l))
    	}
    	if m.StringValue != nil {
    	l = (*wrapperspb1.StringValue)(m.StringValue).SizeVT()
    	n += 1 + l + sov(uint64(l))
    	}
    	if m.BytesValue != nil {
    	l = (*wrapperspb1.BytesValue)(m.BytesValue).SizeVT()
    	n += 1 + l + sov(uint64(l))
    	}
    	n += len(m.unknownFields)
    	return n
    	}

  • Unmarshal:

    vtprotobuf/testproto/wkt/wkt_vtproto.pb.go

    Lines 551 to 1105 in f080268

    	func (m *MessageWithWKT) UnmarshalVT(dAtA []byte) error {
    	l := len(dAtA)
    	iNdEx := 0
    	for iNdEx < l {
    	preIndex := iNdEx
    	var wire uint64
    	for shift := uint(0); ; shift += 7 {
    	if shift >= 64 {
    	return ErrIntOverflow
    	}
    	if iNdEx >= l {
    	return io.ErrUnexpectedEOF
    	}
    	b := dAtA[iNdEx]
    	iNdEx++
    	wire |= uint64(b&0x7F) << shift
    	if b < 0x80 {
    	break
    	}
    	}
    	fieldNum := int32(wire >> 3)
    	wireType := int(wire & 0x7)
    	if wireType == 4 {
    	return fmt.Errorf("proto: MessageWithWKT: wiretype end group for non-group")
    	}
    	if fieldNum <= 0 {
    	return fmt.Errorf("proto: MessageWithWKT: illegal tag %d (wire type %d)", fieldNum, wire)
    	}
    	switch fieldNum {
    	case 1:
    	if wireType != 2 {
    	return fmt.Errorf("proto: wrong wireType = %d for field Any", wireType)
    	}
    	var msglen int
    	for shift := uint(0); ; shift += 7 {
    	if shift >= 64 {
    	return ErrIntOverflow
    	}
    	if iNdEx >= l {
    	return io.ErrUnexpectedEOF
    	}
    	b := dAtA[iNdEx]
    	iNdEx++
    	msglen |= int(b&0x7F) << shift
    	if b < 0x80 {
    	break
    	}
    	}
    	if msglen < 0 {
    	return ErrInvalidLength
    	}
    	postIndex := iNdEx + msglen
    	if postIndex < 0 {
    	return ErrInvalidLength
    	}
    	if postIndex > l {
    	return io.ErrUnexpectedEOF
    	}
    	if m.Any == nil {
    	m.Any = &anypb.Any{}
    	}
    	if err := (*anypb1.Any)(m.Any).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
    	return err
    	}
    	iNdEx = postIndex
    	case 2:
    	if wireType != 2 {
    	return fmt.Errorf("proto: wrong wireType = %d for field Duration", wireType)
    	}
    	var msglen int
    	for shift := uint(0); ; shift += 7 {
    	if shift >= 64 {
    	return ErrIntOverflow
    	}
    	if iNdEx >= l {
    	return io.ErrUnexpectedEOF
    	}
    	b := dAtA[iNdEx]
    	iNdEx++
    	msglen |= int(b&0x7F) << shift
    	if b < 0x80 {
    	break
    	}
    	}
    	if msglen < 0 {
    	return ErrInvalidLength
    	}
    	postIndex := iNdEx + msglen
    	if postIndex < 0 {
    	return ErrInvalidLength
    	}
    	if postIndex > l {
    	return io.ErrUnexpectedEOF
    	}
    	if m.Duration == nil {
    	m.Duration = &durationpb.Duration{}
    	}
    	if err := (*durationpb1.Duration)(m.Duration).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
    	return err
    	}
    	iNdEx = postIndex
    	case 3:
    	if wireType != 2 {
    	return fmt.Errorf("proto: wrong wireType = %d for field Empty", wireType)
    	}
    	var msglen int
    	for shift := uint(0); ; shift += 7 {
    	if shift >= 64 {
    	return ErrIntOverflow
    	}
    	if iNdEx >= l {
    	return io.ErrUnexpectedEOF
    	}
    	b := dAtA[iNdEx]
    	iNdEx++
    	msglen |= int(b&0x7F) << shift
    	if b < 0x80 {
    	break
    	}
    	}
    	if msglen < 0 {
    	return ErrInvalidLength
    	}
    	postIndex := iNdEx + msglen
    	if postIndex < 0 {
    	return ErrInvalidLength
    	}
    	if postIndex > l {
    	return io.ErrUnexpectedEOF
    	}
    	if m.Empty == nil {
    	m.Empty = &emptypb.Empty{}
    	}
    	if err := (*emptypb1.Empty)(m.Empty).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
    	return err
    	}
    	iNdEx = postIndex
    	case 4:
    	if wireType != 2 {
    	return fmt.Errorf("proto: wrong wireType = %d for field FieldMask", wireType)
    	}
    	var msglen int
    	for shift := uint(0); ; shift += 7 {
    	if shift >= 64 {
    	return ErrIntOverflow
    	}
    	if iNdEx >= l {
    	return io.ErrUnexpectedEOF
    	}
    	b := dAtA[iNdEx]
    	iNdEx++
    	msglen |= int(b&0x7F) << shift
    	if b < 0x80 {
    	break
    	}
    	}
    	if msglen < 0 {
    	return ErrInvalidLength
    	}
    	postIndex := iNdEx + msglen
    	if postIndex < 0 {
    	return ErrInvalidLength
    	}
    	if postIndex > l {
    	return io.ErrUnexpectedEOF
    	}
    	if m.FieldMask == nil {
    	m.FieldMask = &fieldmaskpb.FieldMask{}
    	}
    	if err := (*fieldmaskpb1.FieldMask)(m.FieldMask).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
    	return err
    	}
    	iNdEx = postIndex
    	case 5:
    	if wireType != 2 {
    	return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
    	}
    	var msglen int
    	for shift := uint(0); ; shift += 7 {
    	if shift >= 64 {
    	return ErrIntOverflow
    	}
    	if iNdEx >= l {
    	return io.ErrUnexpectedEOF
    	}
    	b := dAtA[iNdEx]
    	iNdEx++
    	msglen |= int(b&0x7F) << shift
    	if b < 0x80 {
    	break
    	}
    	}
    	if msglen < 0 {
    	return ErrInvalidLength
    	}
    	postIndex := iNdEx + msglen
    	if postIndex < 0 {
    	return ErrInvalidLength
    	}
    	if postIndex > l {
    	return io.ErrUnexpectedEOF
    	}
    	if m.Timestamp == nil {
    	m.Timestamp = &timestamppb.Timestamp{}
    	}
    	if err := (*timestamppb1.Timestamp)(m.Timestamp).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
    	return err
    	}
    	iNdEx = postIndex
    	case 6:
    	if wireType != 2 {
    	return fmt.Errorf("proto: wrong wireType = %d for field DoubleValue", wireType)
    	}
    	var msglen int
    	for shift := uint(0); ; shift += 7 {
    	if shift >= 64 {
    	return ErrIntOverflow
    	}
    	if iNdEx >= l {
    	return io.ErrUnexpectedEOF
    	}
    	b := dAtA[iNdEx]
    	iNdEx++
    	msglen |= int(b&0x7F) << shift
    	if b < 0x80 {
    	break
    	}
    	}
    	if msglen < 0 {
    	return ErrInvalidLength
    	}
    	postIndex := iNdEx + msglen
    	if postIndex < 0 {
    	return ErrInvalidLength
    	}
    	if postIndex > l {
    	return io.ErrUnexpectedEOF
    	}
    	if m.DoubleValue == nil {
    	m.DoubleValue = &wrapperspb.DoubleValue{}
    	}
    	if err := (*wrapperspb1.DoubleValue)(m.DoubleValue).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
    	return err
    	}
    	iNdEx = postIndex
    	case 7:
    	if wireType != 2 {
    	return fmt.Errorf("proto: wrong wireType = %d for field FloatValue", wireType)
    	}
    	var msglen int
    	for shift := uint(0); ; shift += 7 {
    	if shift >= 64 {
    	return ErrIntOverflow
    	}
    	if iNdEx >= l {
    	return io.ErrUnexpectedEOF
    	}
    	b := dAtA[iNdEx]
    	iNdEx++
    	msglen |= int(b&0x7F) << shift
    	if b < 0x80 {
    	break
    	}
    	}
    	if msglen < 0 {
    	return ErrInvalidLength
    	}
    	postIndex := iNdEx + msglen
    	if postIndex < 0 {
    	return ErrInvalidLength
    	}
    	if postIndex > l {
    	return io.ErrUnexpectedEOF
    	}
    	if m.FloatValue == nil {
    	m.FloatValue = &wrapperspb.FloatValue{}
    	}
    	if err := (*wrapperspb1.FloatValue)(m.FloatValue).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
    	return err
    	}
    	iNdEx = postIndex
    	case 8:
    	if wireType != 2 {
    	return fmt.Errorf("proto: wrong wireType = %d for field Int64Value", wireType)
    	}
    	var msglen int
    	for shift := uint(0); ; shift += 7 {
    	if shift >= 64 {
    	return ErrIntOverflow
    	}
    	if iNdEx >= l {
    	return io.ErrUnexpectedEOF
    	}
    	b := dAtA[iNdEx]
    	iNdEx++
    	msglen |= int(b&0x7F) << shift
    	if b < 0x80 {
    	break
    	}
    	}
    	if msglen < 0 {
    	return ErrInvalidLength
    	}
    	postIndex := iNdEx + msglen
    	if postIndex < 0 {
    	return ErrInvalidLength
    	}
    	if postIndex > l {
    	return io.ErrUnexpectedEOF
    	}
    	if m.Int64Value == nil {
    	m.Int64Value = &wrapperspb.Int64Value{}
    	}
    	if err := (*wrapperspb1.Int64Value)(m.Int64Value).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
    	return err
    	}
    	iNdEx = postIndex
    	case 9:
    	if wireType != 2 {
    	return fmt.Errorf("proto: wrong wireType = %d for field Uint64Value", wireType)
    	}
    	var msglen int
    	for shift := uint(0); ; shift += 7 {
    	if shift >= 64 {
    	return ErrIntOverflow
    	}
    	if iNdEx >= l {
    	return io.ErrUnexpectedEOF
    	}
    	b := dAtA[iNdEx]
    	iNdEx++
    	msglen |= int(b&0x7F) << shift
    	if b < 0x80 {
    	break
    	}
    	}
    	if msglen < 0 {
    	return ErrInvalidLength
    	}
    	postIndex := iNdEx + msglen
    	if postIndex < 0 {
    	return ErrInvalidLength
    	}
    	if postIndex > l {
    	return io.ErrUnexpectedEOF
    	}
    	if m.Uint64Value == nil {
    	m.Uint64Value = &wrapperspb.UInt64Value{}
    	}
    	if err := (*wrapperspb1.UInt64Value)(m.Uint64Value).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
    	return err
    	}
    	iNdEx = postIndex
    	case 10:
    	if wireType != 2 {
    	return fmt.Errorf("proto: wrong wireType = %d for field Int32Value", wireType)
    	}
    	var msglen int
    	for shift := uint(0); ; shift += 7 {
    	if shift >= 64 {
    	return ErrIntOverflow
    	}
    	if iNdEx >= l {
    	return io.ErrUnexpectedEOF
    	}
    	b := dAtA[iNdEx]
    	iNdEx++
    	msglen |= int(b&0x7F) << shift
    	if b < 0x80 {
    	break
    	}
    	}
    	if msglen < 0 {
    	return ErrInvalidLength
    	}
    	postIndex := iNdEx + msglen
    	if postIndex < 0 {
    	return ErrInvalidLength
    	}
    	if postIndex > l {
    	return io.ErrUnexpectedEOF
    	}
    	if m.Int32Value == nil {
    	m.Int32Value = &wrapperspb.Int32Value{}
    	}
    	if err := (*wrapperspb1.Int32Value)(m.Int32Value).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
    	return err
    	}
    	iNdEx = postIndex
    	case 11:
    	if wireType != 2 {
    	return fmt.Errorf("proto: wrong wireType = %d for field Uint32Value", wireType)
    	}
    	var msglen int
    	for shift := uint(0); ; shift += 7 {
    	if shift >= 64 {
    	return ErrIntOverflow
    	}
    	if iNdEx >= l {
    	return io.ErrUnexpectedEOF
    	}
    	b := dAtA[iNdEx]
    	iNdEx++
    	msglen |= int(b&0x7F) << shift
    	if b < 0x80 {
    	break
    	}
    	}
    	if msglen < 0 {
    	return ErrInvalidLength
    	}
    	postIndex := iNdEx + msglen
    	if postIndex < 0 {
    	return ErrInvalidLength
    	}
    	if postIndex > l {
    	return io.ErrUnexpectedEOF
    	}
    	if m.Uint32Value == nil {
    	m.Uint32Value = &wrapperspb.UInt32Value{}
    	}
    	if err := (*wrapperspb1.UInt32Value)(m.Uint32Value).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
    	return err
    	}
    	iNdEx = postIndex
    	case 12:
    	if wireType != 2 {
    	return fmt.Errorf("proto: wrong wireType = %d for field BoolValue", wireType)
    	}
    	var msglen int
    	for shift := uint(0); ; shift += 7 {
    	if shift >= 64 {
    	return ErrIntOverflow
    	}
    	if iNdEx >= l {
    	return io.ErrUnexpectedEOF
    	}
    	b := dAtA[iNdEx]
    	iNdEx++
    	msglen |= int(b&0x7F) << shift
    	if b < 0x80 {
    	break
    	}
    	}
    	if msglen < 0 {
    	return ErrInvalidLength
    	}
    	postIndex := iNdEx + msglen
    	if postIndex < 0 {
    	return ErrInvalidLength
    	}
    	if postIndex > l {
    	return io.ErrUnexpectedEOF
    	}
    	if m.BoolValue == nil {
    	m.BoolValue = &wrapperspb.BoolValue{}
    	}
    	if err := (*wrapperspb1.BoolValue)(m.BoolValue).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
    	return err
    	}
    	iNdEx = postIndex
    	case 13:
    	if wireType != 2 {
    	return fmt.Errorf("proto: wrong wireType = %d for field StringValue", wireType)
    	}
    	var msglen int
    	for shift := uint(0); ; shift += 7 {
    	if shift >= 64 {
    	return ErrIntOverflow
    	}
    	if iNdEx >= l {
    	return io.ErrUnexpectedEOF
    	}
    	b := dAtA[iNdEx]
    	iNdEx++
    	msglen |= int(b&0x7F) << shift
    	if b < 0x80 {
    	break
    	}
    	}
    	if msglen < 0 {
    	return ErrInvalidLength
    	}
    	postIndex := iNdEx + msglen
    	if postIndex < 0 {
    	return ErrInvalidLength
    	}
    	if postIndex > l {
    	return io.ErrUnexpectedEOF
    	}
    	if m.StringValue == nil {
    	m.StringValue = &wrapperspb.StringValue{}
    	}
    	if err := (*wrapperspb1.StringValue)(m.StringValue).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
    	return err
    	}
    	iNdEx = postIndex
    	case 14:
    	if wireType != 2 {
    	return fmt.Errorf("proto: wrong wireType = %d for field BytesValue", wireType)
    	}
    	var msglen int
    	for shift := uint(0); ; shift += 7 {
    	if shift >= 64 {
    	return ErrIntOverflow
    	}
    	if iNdEx >= l {
    	return io.ErrUnexpectedEOF
    	}
    	b := dAtA[iNdEx]
    	iNdEx++
    	msglen |= int(b&0x7F) << shift
    	if b < 0x80 {
    	break
    	}
    	}
    	if msglen < 0 {
    	return ErrInvalidLength
    	}
    	postIndex := iNdEx + msglen
    	if postIndex < 0 {
    	return ErrInvalidLength
    	}
    	if postIndex > l {
    	return io.ErrUnexpectedEOF
    	}
    	if m.BytesValue == nil {
    	m.BytesValue = &wrapperspb.BytesValue{}
    	}
    	if err := (*wrapperspb1.BytesValue)(m.BytesValue).UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
    	return err
    	}
    	iNdEx = postIndex
    	default:
    	iNdEx = preIndex
    	skippy, err := skip(dAtA[iNdEx:])
    	if err != nil {
    	return err
    	}
    	if (skippy < 0) || (iNdEx+skippy) < 0 {
    	return ErrInvalidLength
    	}
    	if (iNdEx + skippy) > l {
    	return io.ErrUnexpectedEOF
    	}
    	m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
    	iNdEx += skippy
    	}
    	}
    	if iNdEx > l {
    	return io.ErrUnexpectedEOF
    	}
    	return nil
    	}

[vmg]

Merged!