Source file src/github.com/gogo/protobuf/types/wrappers.pb.go

Documentation: github.com/gogo/protobuf/types

     1  // Code generated by protoc-gen-gogo. DO NOT EDIT.
     2  // source: google/protobuf/wrappers.proto
     3  
     4  package types
     5  
     6  import (
     7  	bytes "bytes"
     8  	encoding_binary "encoding/binary"
     9  	fmt "fmt"
    10  	proto "github.com/gogo/protobuf/proto"
    11  	io "io"
    12  	math "math"
    13  	math_bits "math/bits"
    14  	reflect "reflect"
    15  	strings "strings"
    16  )
    17  
    18  // Reference imports to suppress errors if they are not otherwise used.
    19  var _ = proto.Marshal
    20  var _ = fmt.Errorf
    21  var _ = math.Inf
    22  
    23  // This is a compile-time assertion to ensure that this generated file
    24  // is compatible with the proto package it is being compiled against.
    25  // A compilation error at this line likely means your copy of the
    26  // proto package needs to be updated.
    27  const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
    28  
    29  // Wrapper message for `double`.
    30  //
    31  // The JSON representation for `DoubleValue` is JSON number.
    32  type DoubleValue struct {
    33  	// The double value.
    34  	Value                float64  `protobuf:"fixed64,1,opt,name=value,proto3" json:"value,omitempty"`
    35  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
    36  	XXX_unrecognized     []byte   `json:"-"`
    37  	XXX_sizecache        int32    `json:"-"`
    38  }
    39  
    40  func (m *DoubleValue) Reset()      { *m = DoubleValue{} }
    41  func (*DoubleValue) ProtoMessage() {}
    42  func (*DoubleValue) Descriptor() ([]byte, []int) {
    43  	return fileDescriptor_5377b62bda767935, []int{0}
    44  }
    45  func (*DoubleValue) XXX_WellKnownType() string { return "DoubleValue" }
    46  func (m *DoubleValue) XXX_Unmarshal(b []byte) error {
    47  	return m.Unmarshal(b)
    48  }
    49  func (m *DoubleValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    50  	if deterministic {
    51  		return xxx_messageInfo_DoubleValue.Marshal(b, m, deterministic)
    52  	} else {
    53  		b = b[:cap(b)]
    54  		n, err := m.MarshalToSizedBuffer(b)
    55  		if err != nil {
    56  			return nil, err
    57  		}
    58  		return b[:n], nil
    59  	}
    60  }
    61  func (m *DoubleValue) XXX_Merge(src proto.Message) {
    62  	xxx_messageInfo_DoubleValue.Merge(m, src)
    63  }
    64  func (m *DoubleValue) XXX_Size() int {
    65  	return m.Size()
    66  }
    67  func (m *DoubleValue) XXX_DiscardUnknown() {
    68  	xxx_messageInfo_DoubleValue.DiscardUnknown(m)
    69  }
    70  
    71  var xxx_messageInfo_DoubleValue proto.InternalMessageInfo
    72  
    73  func (m *DoubleValue) GetValue() float64 {
    74  	if m != nil {
    75  		return m.Value
    76  	}
    77  	return 0
    78  }
    79  
    80  func (*DoubleValue) XXX_MessageName() string {
    81  	return "google.protobuf.DoubleValue"
    82  }
    83  
    84  // Wrapper message for `float`.
    85  //
    86  // The JSON representation for `FloatValue` is JSON number.
    87  type FloatValue struct {
    88  	// The float value.
    89  	Value                float32  `protobuf:"fixed32,1,opt,name=value,proto3" json:"value,omitempty"`
    90  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
    91  	XXX_unrecognized     []byte   `json:"-"`
    92  	XXX_sizecache        int32    `json:"-"`
    93  }
    94  
    95  func (m *FloatValue) Reset()      { *m = FloatValue{} }
    96  func (*FloatValue) ProtoMessage() {}
    97  func (*FloatValue) Descriptor() ([]byte, []int) {
    98  	return fileDescriptor_5377b62bda767935, []int{1}
    99  }
   100  func (*FloatValue) XXX_WellKnownType() string { return "FloatValue" }
   101  func (m *FloatValue) XXX_Unmarshal(b []byte) error {
   102  	return m.Unmarshal(b)
   103  }
   104  func (m *FloatValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   105  	if deterministic {
   106  		return xxx_messageInfo_FloatValue.Marshal(b, m, deterministic)
   107  	} else {
   108  		b = b[:cap(b)]
   109  		n, err := m.MarshalToSizedBuffer(b)
   110  		if err != nil {
   111  			return nil, err
   112  		}
   113  		return b[:n], nil
   114  	}
   115  }
   116  func (m *FloatValue) XXX_Merge(src proto.Message) {
   117  	xxx_messageInfo_FloatValue.Merge(m, src)
   118  }
   119  func (m *FloatValue) XXX_Size() int {
   120  	return m.Size()
   121  }
   122  func (m *FloatValue) XXX_DiscardUnknown() {
   123  	xxx_messageInfo_FloatValue.DiscardUnknown(m)
   124  }
   125  
   126  var xxx_messageInfo_FloatValue proto.InternalMessageInfo
   127  
   128  func (m *FloatValue) GetValue() float32 {
   129  	if m != nil {
   130  		return m.Value
   131  	}
   132  	return 0
   133  }
   134  
   135  func (*FloatValue) XXX_MessageName() string {
   136  	return "google.protobuf.FloatValue"
   137  }
   138  
   139  // Wrapper message for `int64`.
   140  //
   141  // The JSON representation for `Int64Value` is JSON string.
   142  type Int64Value struct {
   143  	// The int64 value.
   144  	Value                int64    `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
   145  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
   146  	XXX_unrecognized     []byte   `json:"-"`
   147  	XXX_sizecache        int32    `json:"-"`
   148  }
   149  
   150  func (m *Int64Value) Reset()      { *m = Int64Value{} }
   151  func (*Int64Value) ProtoMessage() {}
   152  func (*Int64Value) Descriptor() ([]byte, []int) {
   153  	return fileDescriptor_5377b62bda767935, []int{2}
   154  }
   155  func (*Int64Value) XXX_WellKnownType() string { return "Int64Value" }
   156  func (m *Int64Value) XXX_Unmarshal(b []byte) error {
   157  	return m.Unmarshal(b)
   158  }
   159  func (m *Int64Value) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   160  	if deterministic {
   161  		return xxx_messageInfo_Int64Value.Marshal(b, m, deterministic)
   162  	} else {
   163  		b = b[:cap(b)]
   164  		n, err := m.MarshalToSizedBuffer(b)
   165  		if err != nil {
   166  			return nil, err
   167  		}
   168  		return b[:n], nil
   169  	}
   170  }
   171  func (m *Int64Value) XXX_Merge(src proto.Message) {
   172  	xxx_messageInfo_Int64Value.Merge(m, src)
   173  }
   174  func (m *Int64Value) XXX_Size() int {
   175  	return m.Size()
   176  }
   177  func (m *Int64Value) XXX_DiscardUnknown() {
   178  	xxx_messageInfo_Int64Value.DiscardUnknown(m)
   179  }
   180  
   181  var xxx_messageInfo_Int64Value proto.InternalMessageInfo
   182  
   183  func (m *Int64Value) GetValue() int64 {
   184  	if m != nil {
   185  		return m.Value
   186  	}
   187  	return 0
   188  }
   189  
   190  func (*Int64Value) XXX_MessageName() string {
   191  	return "google.protobuf.Int64Value"
   192  }
   193  
   194  // Wrapper message for `uint64`.
   195  //
   196  // The JSON representation for `UInt64Value` is JSON string.
   197  type UInt64Value struct {
   198  	// The uint64 value.
   199  	Value                uint64   `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
   200  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
   201  	XXX_unrecognized     []byte   `json:"-"`
   202  	XXX_sizecache        int32    `json:"-"`
   203  }
   204  
   205  func (m *UInt64Value) Reset()      { *m = UInt64Value{} }
   206  func (*UInt64Value) ProtoMessage() {}
   207  func (*UInt64Value) Descriptor() ([]byte, []int) {
   208  	return fileDescriptor_5377b62bda767935, []int{3}
   209  }
   210  func (*UInt64Value) XXX_WellKnownType() string { return "UInt64Value" }
   211  func (m *UInt64Value) XXX_Unmarshal(b []byte) error {
   212  	return m.Unmarshal(b)
   213  }
   214  func (m *UInt64Value) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   215  	if deterministic {
   216  		return xxx_messageInfo_UInt64Value.Marshal(b, m, deterministic)
   217  	} else {
   218  		b = b[:cap(b)]
   219  		n, err := m.MarshalToSizedBuffer(b)
   220  		if err != nil {
   221  			return nil, err
   222  		}
   223  		return b[:n], nil
   224  	}
   225  }
   226  func (m *UInt64Value) XXX_Merge(src proto.Message) {
   227  	xxx_messageInfo_UInt64Value.Merge(m, src)
   228  }
   229  func (m *UInt64Value) XXX_Size() int {
   230  	return m.Size()
   231  }
   232  func (m *UInt64Value) XXX_DiscardUnknown() {
   233  	xxx_messageInfo_UInt64Value.DiscardUnknown(m)
   234  }
   235  
   236  var xxx_messageInfo_UInt64Value proto.InternalMessageInfo
   237  
   238  func (m *UInt64Value) GetValue() uint64 {
   239  	if m != nil {
   240  		return m.Value
   241  	}
   242  	return 0
   243  }
   244  
   245  func (*UInt64Value) XXX_MessageName() string {
   246  	return "google.protobuf.UInt64Value"
   247  }
   248  
   249  // Wrapper message for `int32`.
   250  //
   251  // The JSON representation for `Int32Value` is JSON number.
   252  type Int32Value struct {
   253  	// The int32 value.
   254  	Value                int32    `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
   255  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
   256  	XXX_unrecognized     []byte   `json:"-"`
   257  	XXX_sizecache        int32    `json:"-"`
   258  }
   259  
   260  func (m *Int32Value) Reset()      { *m = Int32Value{} }
   261  func (*Int32Value) ProtoMessage() {}
   262  func (*Int32Value) Descriptor() ([]byte, []int) {
   263  	return fileDescriptor_5377b62bda767935, []int{4}
   264  }
   265  func (*Int32Value) XXX_WellKnownType() string { return "Int32Value" }
   266  func (m *Int32Value) XXX_Unmarshal(b []byte) error {
   267  	return m.Unmarshal(b)
   268  }
   269  func (m *Int32Value) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   270  	if deterministic {
   271  		return xxx_messageInfo_Int32Value.Marshal(b, m, deterministic)
   272  	} else {
   273  		b = b[:cap(b)]
   274  		n, err := m.MarshalToSizedBuffer(b)
   275  		if err != nil {
   276  			return nil, err
   277  		}
   278  		return b[:n], nil
   279  	}
   280  }
   281  func (m *Int32Value) XXX_Merge(src proto.Message) {
   282  	xxx_messageInfo_Int32Value.Merge(m, src)
   283  }
   284  func (m *Int32Value) XXX_Size() int {
   285  	return m.Size()
   286  }
   287  func (m *Int32Value) XXX_DiscardUnknown() {
   288  	xxx_messageInfo_Int32Value.DiscardUnknown(m)
   289  }
   290  
   291  var xxx_messageInfo_Int32Value proto.InternalMessageInfo
   292  
   293  func (m *Int32Value) GetValue() int32 {
   294  	if m != nil {
   295  		return m.Value
   296  	}
   297  	return 0
   298  }
   299  
   300  func (*Int32Value) XXX_MessageName() string {
   301  	return "google.protobuf.Int32Value"
   302  }
   303  
   304  // Wrapper message for `uint32`.
   305  //
   306  // The JSON representation for `UInt32Value` is JSON number.
   307  type UInt32Value struct {
   308  	// The uint32 value.
   309  	Value                uint32   `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
   310  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
   311  	XXX_unrecognized     []byte   `json:"-"`
   312  	XXX_sizecache        int32    `json:"-"`
   313  }
   314  
   315  func (m *UInt32Value) Reset()      { *m = UInt32Value{} }
   316  func (*UInt32Value) ProtoMessage() {}
   317  func (*UInt32Value) Descriptor() ([]byte, []int) {
   318  	return fileDescriptor_5377b62bda767935, []int{5}
   319  }
   320  func (*UInt32Value) XXX_WellKnownType() string { return "UInt32Value" }
   321  func (m *UInt32Value) XXX_Unmarshal(b []byte) error {
   322  	return m.Unmarshal(b)
   323  }
   324  func (m *UInt32Value) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   325  	if deterministic {
   326  		return xxx_messageInfo_UInt32Value.Marshal(b, m, deterministic)
   327  	} else {
   328  		b = b[:cap(b)]
   329  		n, err := m.MarshalToSizedBuffer(b)
   330  		if err != nil {
   331  			return nil, err
   332  		}
   333  		return b[:n], nil
   334  	}
   335  }
   336  func (m *UInt32Value) XXX_Merge(src proto.Message) {
   337  	xxx_messageInfo_UInt32Value.Merge(m, src)
   338  }
   339  func (m *UInt32Value) XXX_Size() int {
   340  	return m.Size()
   341  }
   342  func (m *UInt32Value) XXX_DiscardUnknown() {
   343  	xxx_messageInfo_UInt32Value.DiscardUnknown(m)
   344  }
   345  
   346  var xxx_messageInfo_UInt32Value proto.InternalMessageInfo
   347  
   348  func (m *UInt32Value) GetValue() uint32 {
   349  	if m != nil {
   350  		return m.Value
   351  	}
   352  	return 0
   353  }
   354  
   355  func (*UInt32Value) XXX_MessageName() string {
   356  	return "google.protobuf.UInt32Value"
   357  }
   358  
   359  // Wrapper message for `bool`.
   360  //
   361  // The JSON representation for `BoolValue` is JSON `true` and `false`.
   362  type BoolValue struct {
   363  	// The bool value.
   364  	Value                bool     `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
   365  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
   366  	XXX_unrecognized     []byte   `json:"-"`
   367  	XXX_sizecache        int32    `json:"-"`
   368  }
   369  
   370  func (m *BoolValue) Reset()      { *m = BoolValue{} }
   371  func (*BoolValue) ProtoMessage() {}
   372  func (*BoolValue) Descriptor() ([]byte, []int) {
   373  	return fileDescriptor_5377b62bda767935, []int{6}
   374  }
   375  func (*BoolValue) XXX_WellKnownType() string { return "BoolValue" }
   376  func (m *BoolValue) XXX_Unmarshal(b []byte) error {
   377  	return m.Unmarshal(b)
   378  }
   379  func (m *BoolValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   380  	if deterministic {
   381  		return xxx_messageInfo_BoolValue.Marshal(b, m, deterministic)
   382  	} else {
   383  		b = b[:cap(b)]
   384  		n, err := m.MarshalToSizedBuffer(b)
   385  		if err != nil {
   386  			return nil, err
   387  		}
   388  		return b[:n], nil
   389  	}
   390  }
   391  func (m *BoolValue) XXX_Merge(src proto.Message) {
   392  	xxx_messageInfo_BoolValue.Merge(m, src)
   393  }
   394  func (m *BoolValue) XXX_Size() int {
   395  	return m.Size()
   396  }
   397  func (m *BoolValue) XXX_DiscardUnknown() {
   398  	xxx_messageInfo_BoolValue.DiscardUnknown(m)
   399  }
   400  
   401  var xxx_messageInfo_BoolValue proto.InternalMessageInfo
   402  
   403  func (m *BoolValue) GetValue() bool {
   404  	if m != nil {
   405  		return m.Value
   406  	}
   407  	return false
   408  }
   409  
   410  func (*BoolValue) XXX_MessageName() string {
   411  	return "google.protobuf.BoolValue"
   412  }
   413  
   414  // Wrapper message for `string`.
   415  //
   416  // The JSON representation for `StringValue` is JSON string.
   417  type StringValue struct {
   418  	// The string value.
   419  	Value                string   `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
   420  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
   421  	XXX_unrecognized     []byte   `json:"-"`
   422  	XXX_sizecache        int32    `json:"-"`
   423  }
   424  
   425  func (m *StringValue) Reset()      { *m = StringValue{} }
   426  func (*StringValue) ProtoMessage() {}
   427  func (*StringValue) Descriptor() ([]byte, []int) {
   428  	return fileDescriptor_5377b62bda767935, []int{7}
   429  }
   430  func (*StringValue) XXX_WellKnownType() string { return "StringValue" }
   431  func (m *StringValue) XXX_Unmarshal(b []byte) error {
   432  	return m.Unmarshal(b)
   433  }
   434  func (m *StringValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   435  	if deterministic {
   436  		return xxx_messageInfo_StringValue.Marshal(b, m, deterministic)
   437  	} else {
   438  		b = b[:cap(b)]
   439  		n, err := m.MarshalToSizedBuffer(b)
   440  		if err != nil {
   441  			return nil, err
   442  		}
   443  		return b[:n], nil
   444  	}
   445  }
   446  func (m *StringValue) XXX_Merge(src proto.Message) {
   447  	xxx_messageInfo_StringValue.Merge(m, src)
   448  }
   449  func (m *StringValue) XXX_Size() int {
   450  	return m.Size()
   451  }
   452  func (m *StringValue) XXX_DiscardUnknown() {
   453  	xxx_messageInfo_StringValue.DiscardUnknown(m)
   454  }
   455  
   456  var xxx_messageInfo_StringValue proto.InternalMessageInfo
   457  
   458  func (m *StringValue) GetValue() string {
   459  	if m != nil {
   460  		return m.Value
   461  	}
   462  	return ""
   463  }
   464  
   465  func (*StringValue) XXX_MessageName() string {
   466  	return "google.protobuf.StringValue"
   467  }
   468  
   469  // Wrapper message for `bytes`.
   470  //
   471  // The JSON representation for `BytesValue` is JSON string.
   472  type BytesValue struct {
   473  	// The bytes value.
   474  	Value                []byte   `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
   475  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
   476  	XXX_unrecognized     []byte   `json:"-"`
   477  	XXX_sizecache        int32    `json:"-"`
   478  }
   479  
   480  func (m *BytesValue) Reset()      { *m = BytesValue{} }
   481  func (*BytesValue) ProtoMessage() {}
   482  func (*BytesValue) Descriptor() ([]byte, []int) {
   483  	return fileDescriptor_5377b62bda767935, []int{8}
   484  }
   485  func (*BytesValue) XXX_WellKnownType() string { return "BytesValue" }
   486  func (m *BytesValue) XXX_Unmarshal(b []byte) error {
   487  	return m.Unmarshal(b)
   488  }
   489  func (m *BytesValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   490  	if deterministic {
   491  		return xxx_messageInfo_BytesValue.Marshal(b, m, deterministic)
   492  	} else {
   493  		b = b[:cap(b)]
   494  		n, err := m.MarshalToSizedBuffer(b)
   495  		if err != nil {
   496  			return nil, err
   497  		}
   498  		return b[:n], nil
   499  	}
   500  }
   501  func (m *BytesValue) XXX_Merge(src proto.Message) {
   502  	xxx_messageInfo_BytesValue.Merge(m, src)
   503  }
   504  func (m *BytesValue) XXX_Size() int {
   505  	return m.Size()
   506  }
   507  func (m *BytesValue) XXX_DiscardUnknown() {
   508  	xxx_messageInfo_BytesValue.DiscardUnknown(m)
   509  }
   510  
   511  var xxx_messageInfo_BytesValue proto.InternalMessageInfo
   512  
   513  func (m *BytesValue) GetValue() []byte {
   514  	if m != nil {
   515  		return m.Value
   516  	}
   517  	return nil
   518  }
   519  
   520  func (*BytesValue) XXX_MessageName() string {
   521  	return "google.protobuf.BytesValue"
   522  }
   523  func init() {
   524  	proto.RegisterType((*DoubleValue)(nil), "google.protobuf.DoubleValue")
   525  	proto.RegisterType((*FloatValue)(nil), "google.protobuf.FloatValue")
   526  	proto.RegisterType((*Int64Value)(nil), "google.protobuf.Int64Value")
   527  	proto.RegisterType((*UInt64Value)(nil), "google.protobuf.UInt64Value")
   528  	proto.RegisterType((*Int32Value)(nil), "google.protobuf.Int32Value")
   529  	proto.RegisterType((*UInt32Value)(nil), "google.protobuf.UInt32Value")
   530  	proto.RegisterType((*BoolValue)(nil), "google.protobuf.BoolValue")
   531  	proto.RegisterType((*StringValue)(nil), "google.protobuf.StringValue")
   532  	proto.RegisterType((*BytesValue)(nil), "google.protobuf.BytesValue")
   533  }
   534  
   535  func init() { proto.RegisterFile("google/protobuf/wrappers.proto", fileDescriptor_5377b62bda767935) }
   536  
   537  var fileDescriptor_5377b62bda767935 = []byte{
   538  	// 285 bytes of a gzipped FileDescriptorProto
   539  	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4b, 0xcf, 0xcf, 0x4f,
   540  	0xcf, 0x49, 0xd5, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x2f, 0x2f, 0x4a, 0x2c,
   541  	0x28, 0x48, 0x2d, 0x2a, 0xd6, 0x03, 0x8b, 0x08, 0xf1, 0x43, 0xe4, 0xf5, 0x60, 0xf2, 0x4a, 0xca,
   542  	0x5c, 0xdc, 0x2e, 0xf9, 0xa5, 0x49, 0x39, 0xa9, 0x61, 0x89, 0x39, 0xa5, 0xa9, 0x42, 0x22, 0x5c,
   543  	0xac, 0x65, 0x20, 0x86, 0x04, 0xa3, 0x02, 0xa3, 0x06, 0x63, 0x10, 0x84, 0xa3, 0xa4, 0xc4, 0xc5,
   544  	0xe5, 0x96, 0x93, 0x9f, 0x58, 0x82, 0x45, 0x0d, 0x13, 0x92, 0x1a, 0xcf, 0xbc, 0x12, 0x33, 0x13,
   545  	0x2c, 0x6a, 0x98, 0x61, 0x6a, 0x94, 0xb9, 0xb8, 0x43, 0x71, 0x29, 0x62, 0x41, 0x35, 0xc8, 0xd8,
   546  	0x08, 0x8b, 0x1a, 0x56, 0x34, 0x83, 0xb0, 0x2a, 0xe2, 0x85, 0x29, 0x52, 0xe4, 0xe2, 0x74, 0xca,
   547  	0xcf, 0xcf, 0xc1, 0xa2, 0x84, 0x03, 0xc9, 0x9c, 0xe0, 0x92, 0xa2, 0xcc, 0xbc, 0x74, 0x2c, 0x8a,
   548  	0x38, 0x91, 0x1c, 0xe4, 0x54, 0x59, 0x92, 0x5a, 0x8c, 0x45, 0x0d, 0x0f, 0x54, 0x8d, 0x53, 0x3b,
   549  	0xe3, 0x8d, 0x87, 0x72, 0x0c, 0x1f, 0x1e, 0xca, 0x31, 0xfe, 0x78, 0x28, 0xc7, 0xd8, 0xf0, 0x48,
   550  	0x8e, 0x71, 0xc5, 0x23, 0x39, 0xc6, 0x13, 0x8f, 0xe4, 0x18, 0x2f, 0x3c, 0x92, 0x63, 0x7c, 0xf0,
   551  	0x48, 0x8e, 0xf1, 0xc5, 0x23, 0x39, 0x86, 0x0f, 0x20, 0xf1, 0xc7, 0x72, 0x8c, 0x27, 0x1e, 0xcb,
   552  	0x31, 0x72, 0x09, 0x27, 0xe7, 0xe7, 0xea, 0xa1, 0x45, 0x87, 0x13, 0x6f, 0x38, 0x34, 0xbe, 0x02,
   553  	0x40, 0x22, 0x01, 0x8c, 0x51, 0xac, 0x25, 0x95, 0x05, 0xa9, 0xc5, 0x3f, 0x18, 0x19, 0x17, 0x31,
   554  	0x31, 0xbb, 0x07, 0x38, 0xad, 0x62, 0x92, 0x73, 0x87, 0x68, 0x09, 0x80, 0x6a, 0xd1, 0x0b, 0x4f,
   555  	0xcd, 0xc9, 0xf1, 0xce, 0xcb, 0x2f, 0xcf, 0x0b, 0x01, 0xa9, 0x4c, 0x62, 0x03, 0x9b, 0x65, 0x0c,
   556  	0x08, 0x00, 0x00, 0xff, 0xff, 0x31, 0x55, 0x64, 0x90, 0x0a, 0x02, 0x00, 0x00,
   557  }
   558  
   559  func (this *DoubleValue) Compare(that interface{}) int {
   560  	if that == nil {
   561  		if this == nil {
   562  			return 0
   563  		}
   564  		return 1
   565  	}
   566  
   567  	that1, ok := that.(*DoubleValue)
   568  	if !ok {
   569  		that2, ok := that.(DoubleValue)
   570  		if ok {
   571  			that1 = &that2
   572  		} else {
   573  			return 1
   574  		}
   575  	}
   576  	if that1 == nil {
   577  		if this == nil {
   578  			return 0
   579  		}
   580  		return 1
   581  	} else if this == nil {
   582  		return -1
   583  	}
   584  	if this.Value != that1.Value {
   585  		if this.Value < that1.Value {
   586  			return -1
   587  		}
   588  		return 1
   589  	}
   590  	if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
   591  		return c
   592  	}
   593  	return 0
   594  }
   595  func (this *FloatValue) Compare(that interface{}) int {
   596  	if that == nil {
   597  		if this == nil {
   598  			return 0
   599  		}
   600  		return 1
   601  	}
   602  
   603  	that1, ok := that.(*FloatValue)
   604  	if !ok {
   605  		that2, ok := that.(FloatValue)
   606  		if ok {
   607  			that1 = &that2
   608  		} else {
   609  			return 1
   610  		}
   611  	}
   612  	if that1 == nil {
   613  		if this == nil {
   614  			return 0
   615  		}
   616  		return 1
   617  	} else if this == nil {
   618  		return -1
   619  	}
   620  	if this.Value != that1.Value {
   621  		if this.Value < that1.Value {
   622  			return -1
   623  		}
   624  		return 1
   625  	}
   626  	if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
   627  		return c
   628  	}
   629  	return 0
   630  }
   631  func (this *Int64Value) Compare(that interface{}) int {
   632  	if that == nil {
   633  		if this == nil {
   634  			return 0
   635  		}
   636  		return 1
   637  	}
   638  
   639  	that1, ok := that.(*Int64Value)
   640  	if !ok {
   641  		that2, ok := that.(Int64Value)
   642  		if ok {
   643  			that1 = &that2
   644  		} else {
   645  			return 1
   646  		}
   647  	}
   648  	if that1 == nil {
   649  		if this == nil {
   650  			return 0
   651  		}
   652  		return 1
   653  	} else if this == nil {
   654  		return -1
   655  	}
   656  	if this.Value != that1.Value {
   657  		if this.Value < that1.Value {
   658  			return -1
   659  		}
   660  		return 1
   661  	}
   662  	if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
   663  		return c
   664  	}
   665  	return 0
   666  }
   667  func (this *UInt64Value) Compare(that interface{}) int {
   668  	if that == nil {
   669  		if this == nil {
   670  			return 0
   671  		}
   672  		return 1
   673  	}
   674  
   675  	that1, ok := that.(*UInt64Value)
   676  	if !ok {
   677  		that2, ok := that.(UInt64Value)
   678  		if ok {
   679  			that1 = &that2
   680  		} else {
   681  			return 1
   682  		}
   683  	}
   684  	if that1 == nil {
   685  		if this == nil {
   686  			return 0
   687  		}
   688  		return 1
   689  	} else if this == nil {
   690  		return -1
   691  	}
   692  	if this.Value != that1.Value {
   693  		if this.Value < that1.Value {
   694  			return -1
   695  		}
   696  		return 1
   697  	}
   698  	if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
   699  		return c
   700  	}
   701  	return 0
   702  }
   703  func (this *Int32Value) Compare(that interface{}) int {
   704  	if that == nil {
   705  		if this == nil {
   706  			return 0
   707  		}
   708  		return 1
   709  	}
   710  
   711  	that1, ok := that.(*Int32Value)
   712  	if !ok {
   713  		that2, ok := that.(Int32Value)
   714  		if ok {
   715  			that1 = &that2
   716  		} else {
   717  			return 1
   718  		}
   719  	}
   720  	if that1 == nil {
   721  		if this == nil {
   722  			return 0
   723  		}
   724  		return 1
   725  	} else if this == nil {
   726  		return -1
   727  	}
   728  	if this.Value != that1.Value {
   729  		if this.Value < that1.Value {
   730  			return -1
   731  		}
   732  		return 1
   733  	}
   734  	if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
   735  		return c
   736  	}
   737  	return 0
   738  }
   739  func (this *UInt32Value) Compare(that interface{}) int {
   740  	if that == nil {
   741  		if this == nil {
   742  			return 0
   743  		}
   744  		return 1
   745  	}
   746  
   747  	that1, ok := that.(*UInt32Value)
   748  	if !ok {
   749  		that2, ok := that.(UInt32Value)
   750  		if ok {
   751  			that1 = &that2
   752  		} else {
   753  			return 1
   754  		}
   755  	}
   756  	if that1 == nil {
   757  		if this == nil {
   758  			return 0
   759  		}
   760  		return 1
   761  	} else if this == nil {
   762  		return -1
   763  	}
   764  	if this.Value != that1.Value {
   765  		if this.Value < that1.Value {
   766  			return -1
   767  		}
   768  		return 1
   769  	}
   770  	if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
   771  		return c
   772  	}
   773  	return 0
   774  }
   775  func (this *BoolValue) Compare(that interface{}) int {
   776  	if that == nil {
   777  		if this == nil {
   778  			return 0
   779  		}
   780  		return 1
   781  	}
   782  
   783  	that1, ok := that.(*BoolValue)
   784  	if !ok {
   785  		that2, ok := that.(BoolValue)
   786  		if ok {
   787  			that1 = &that2
   788  		} else {
   789  			return 1
   790  		}
   791  	}
   792  	if that1 == nil {
   793  		if this == nil {
   794  			return 0
   795  		}
   796  		return 1
   797  	} else if this == nil {
   798  		return -1
   799  	}
   800  	if this.Value != that1.Value {
   801  		if !this.Value {
   802  			return -1
   803  		}
   804  		return 1
   805  	}
   806  	if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
   807  		return c
   808  	}
   809  	return 0
   810  }
   811  func (this *StringValue) Compare(that interface{}) int {
   812  	if that == nil {
   813  		if this == nil {
   814  			return 0
   815  		}
   816  		return 1
   817  	}
   818  
   819  	that1, ok := that.(*StringValue)
   820  	if !ok {
   821  		that2, ok := that.(StringValue)
   822  		if ok {
   823  			that1 = &that2
   824  		} else {
   825  			return 1
   826  		}
   827  	}
   828  	if that1 == nil {
   829  		if this == nil {
   830  			return 0
   831  		}
   832  		return 1
   833  	} else if this == nil {
   834  		return -1
   835  	}
   836  	if this.Value != that1.Value {
   837  		if this.Value < that1.Value {
   838  			return -1
   839  		}
   840  		return 1
   841  	}
   842  	if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
   843  		return c
   844  	}
   845  	return 0
   846  }
   847  func (this *BytesValue) Compare(that interface{}) int {
   848  	if that == nil {
   849  		if this == nil {
   850  			return 0
   851  		}
   852  		return 1
   853  	}
   854  
   855  	that1, ok := that.(*BytesValue)
   856  	if !ok {
   857  		that2, ok := that.(BytesValue)
   858  		if ok {
   859  			that1 = &that2
   860  		} else {
   861  			return 1
   862  		}
   863  	}
   864  	if that1 == nil {
   865  		if this == nil {
   866  			return 0
   867  		}
   868  		return 1
   869  	} else if this == nil {
   870  		return -1
   871  	}
   872  	if c := bytes.Compare(this.Value, that1.Value); c != 0 {
   873  		return c
   874  	}
   875  	if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
   876  		return c
   877  	}
   878  	return 0
   879  }
   880  func (this *DoubleValue) Equal(that interface{}) bool {
   881  	if that == nil {
   882  		return this == nil
   883  	}
   884  
   885  	that1, ok := that.(*DoubleValue)
   886  	if !ok {
   887  		that2, ok := that.(DoubleValue)
   888  		if ok {
   889  			that1 = &that2
   890  		} else {
   891  			return false
   892  		}
   893  	}
   894  	if that1 == nil {
   895  		return this == nil
   896  	} else if this == nil {
   897  		return false
   898  	}
   899  	if this.Value != that1.Value {
   900  		return false
   901  	}
   902  	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
   903  		return false
   904  	}
   905  	return true
   906  }
   907  func (this *FloatValue) Equal(that interface{}) bool {
   908  	if that == nil {
   909  		return this == nil
   910  	}
   911  
   912  	that1, ok := that.(*FloatValue)
   913  	if !ok {
   914  		that2, ok := that.(FloatValue)
   915  		if ok {
   916  			that1 = &that2
   917  		} else {
   918  			return false
   919  		}
   920  	}
   921  	if that1 == nil {
   922  		return this == nil
   923  	} else if this == nil {
   924  		return false
   925  	}
   926  	if this.Value != that1.Value {
   927  		return false
   928  	}
   929  	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
   930  		return false
   931  	}
   932  	return true
   933  }
   934  func (this *Int64Value) Equal(that interface{}) bool {
   935  	if that == nil {
   936  		return this == nil
   937  	}
   938  
   939  	that1, ok := that.(*Int64Value)
   940  	if !ok {
   941  		that2, ok := that.(Int64Value)
   942  		if ok {
   943  			that1 = &that2
   944  		} else {
   945  			return false
   946  		}
   947  	}
   948  	if that1 == nil {
   949  		return this == nil
   950  	} else if this == nil {
   951  		return false
   952  	}
   953  	if this.Value != that1.Value {
   954  		return false
   955  	}
   956  	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
   957  		return false
   958  	}
   959  	return true
   960  }
   961  func (this *UInt64Value) Equal(that interface{}) bool {
   962  	if that == nil {
   963  		return this == nil
   964  	}
   965  
   966  	that1, ok := that.(*UInt64Value)
   967  	if !ok {
   968  		that2, ok := that.(UInt64Value)
   969  		if ok {
   970  			that1 = &that2
   971  		} else {
   972  			return false
   973  		}
   974  	}
   975  	if that1 == nil {
   976  		return this == nil
   977  	} else if this == nil {
   978  		return false
   979  	}
   980  	if this.Value != that1.Value {
   981  		return false
   982  	}
   983  	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
   984  		return false
   985  	}
   986  	return true
   987  }
   988  func (this *Int32Value) Equal(that interface{}) bool {
   989  	if that == nil {
   990  		return this == nil
   991  	}
   992  
   993  	that1, ok := that.(*Int32Value)
   994  	if !ok {
   995  		that2, ok := that.(Int32Value)
   996  		if ok {
   997  			that1 = &that2
   998  		} else {
   999  			return false
  1000  		}
  1001  	}
  1002  	if that1 == nil {
  1003  		return this == nil
  1004  	} else if this == nil {
  1005  		return false
  1006  	}
  1007  	if this.Value != that1.Value {
  1008  		return false
  1009  	}
  1010  	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
  1011  		return false
  1012  	}
  1013  	return true
  1014  }
  1015  func (this *UInt32Value) Equal(that interface{}) bool {
  1016  	if that == nil {
  1017  		return this == nil
  1018  	}
  1019  
  1020  	that1, ok := that.(*UInt32Value)
  1021  	if !ok {
  1022  		that2, ok := that.(UInt32Value)
  1023  		if ok {
  1024  			that1 = &that2
  1025  		} else {
  1026  			return false
  1027  		}
  1028  	}
  1029  	if that1 == nil {
  1030  		return this == nil
  1031  	} else if this == nil {
  1032  		return false
  1033  	}
  1034  	if this.Value != that1.Value {
  1035  		return false
  1036  	}
  1037  	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
  1038  		return false
  1039  	}
  1040  	return true
  1041  }
  1042  func (this *BoolValue) Equal(that interface{}) bool {
  1043  	if that == nil {
  1044  		return this == nil
  1045  	}
  1046  
  1047  	that1, ok := that.(*BoolValue)
  1048  	if !ok {
  1049  		that2, ok := that.(BoolValue)
  1050  		if ok {
  1051  			that1 = &that2
  1052  		} else {
  1053  			return false
  1054  		}
  1055  	}
  1056  	if that1 == nil {
  1057  		return this == nil
  1058  	} else if this == nil {
  1059  		return false
  1060  	}
  1061  	if this.Value != that1.Value {
  1062  		return false
  1063  	}
  1064  	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
  1065  		return false
  1066  	}
  1067  	return true
  1068  }
  1069  func (this *StringValue) Equal(that interface{}) bool {
  1070  	if that == nil {
  1071  		return this == nil
  1072  	}
  1073  
  1074  	that1, ok := that.(*StringValue)
  1075  	if !ok {
  1076  		that2, ok := that.(StringValue)
  1077  		if ok {
  1078  			that1 = &that2
  1079  		} else {
  1080  			return false
  1081  		}
  1082  	}
  1083  	if that1 == nil {
  1084  		return this == nil
  1085  	} else if this == nil {
  1086  		return false
  1087  	}
  1088  	if this.Value != that1.Value {
  1089  		return false
  1090  	}
  1091  	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
  1092  		return false
  1093  	}
  1094  	return true
  1095  }
  1096  func (this *BytesValue) Equal(that interface{}) bool {
  1097  	if that == nil {
  1098  		return this == nil
  1099  	}
  1100  
  1101  	that1, ok := that.(*BytesValue)
  1102  	if !ok {
  1103  		that2, ok := that.(BytesValue)
  1104  		if ok {
  1105  			that1 = &that2
  1106  		} else {
  1107  			return false
  1108  		}
  1109  	}
  1110  	if that1 == nil {
  1111  		return this == nil
  1112  	} else if this == nil {
  1113  		return false
  1114  	}
  1115  	if !bytes.Equal(this.Value, that1.Value) {
  1116  		return false
  1117  	}
  1118  	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
  1119  		return false
  1120  	}
  1121  	return true
  1122  }
  1123  func (this *DoubleValue) GoString() string {
  1124  	if this == nil {
  1125  		return "nil"
  1126  	}
  1127  	s := make([]string, 0, 5)
  1128  	s = append(s, "&types.DoubleValue{")
  1129  	s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
  1130  	if this.XXX_unrecognized != nil {
  1131  		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
  1132  	}
  1133  	s = append(s, "}")
  1134  	return strings.Join(s, "")
  1135  }
  1136  func (this *FloatValue) GoString() string {
  1137  	if this == nil {
  1138  		return "nil"
  1139  	}
  1140  	s := make([]string, 0, 5)
  1141  	s = append(s, "&types.FloatValue{")
  1142  	s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
  1143  	if this.XXX_unrecognized != nil {
  1144  		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
  1145  	}
  1146  	s = append(s, "}")
  1147  	return strings.Join(s, "")
  1148  }
  1149  func (this *Int64Value) GoString() string {
  1150  	if this == nil {
  1151  		return "nil"
  1152  	}
  1153  	s := make([]string, 0, 5)
  1154  	s = append(s, "&types.Int64Value{")
  1155  	s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
  1156  	if this.XXX_unrecognized != nil {
  1157  		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
  1158  	}
  1159  	s = append(s, "}")
  1160  	return strings.Join(s, "")
  1161  }
  1162  func (this *UInt64Value) GoString() string {
  1163  	if this == nil {
  1164  		return "nil"
  1165  	}
  1166  	s := make([]string, 0, 5)
  1167  	s = append(s, "&types.UInt64Value{")
  1168  	s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
  1169  	if this.XXX_unrecognized != nil {
  1170  		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
  1171  	}
  1172  	s = append(s, "}")
  1173  	return strings.Join(s, "")
  1174  }
  1175  func (this *Int32Value) GoString() string {
  1176  	if this == nil {
  1177  		return "nil"
  1178  	}
  1179  	s := make([]string, 0, 5)
  1180  	s = append(s, "&types.Int32Value{")
  1181  	s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
  1182  	if this.XXX_unrecognized != nil {
  1183  		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
  1184  	}
  1185  	s = append(s, "}")
  1186  	return strings.Join(s, "")
  1187  }
  1188  func (this *UInt32Value) GoString() string {
  1189  	if this == nil {
  1190  		return "nil"
  1191  	}
  1192  	s := make([]string, 0, 5)
  1193  	s = append(s, "&types.UInt32Value{")
  1194  	s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
  1195  	if this.XXX_unrecognized != nil {
  1196  		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
  1197  	}
  1198  	s = append(s, "}")
  1199  	return strings.Join(s, "")
  1200  }
  1201  func (this *BoolValue) GoString() string {
  1202  	if this == nil {
  1203  		return "nil"
  1204  	}
  1205  	s := make([]string, 0, 5)
  1206  	s = append(s, "&types.BoolValue{")
  1207  	s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
  1208  	if this.XXX_unrecognized != nil {
  1209  		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
  1210  	}
  1211  	s = append(s, "}")
  1212  	return strings.Join(s, "")
  1213  }
  1214  func (this *StringValue) GoString() string {
  1215  	if this == nil {
  1216  		return "nil"
  1217  	}
  1218  	s := make([]string, 0, 5)
  1219  	s = append(s, "&types.StringValue{")
  1220  	s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
  1221  	if this.XXX_unrecognized != nil {
  1222  		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
  1223  	}
  1224  	s = append(s, "}")
  1225  	return strings.Join(s, "")
  1226  }
  1227  func (this *BytesValue) GoString() string {
  1228  	if this == nil {
  1229  		return "nil"
  1230  	}
  1231  	s := make([]string, 0, 5)
  1232  	s = append(s, "&types.BytesValue{")
  1233  	s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
  1234  	if this.XXX_unrecognized != nil {
  1235  		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
  1236  	}
  1237  	s = append(s, "}")
  1238  	return strings.Join(s, "")
  1239  }
  1240  func valueToGoStringWrappers(v interface{}, typ string) string {
  1241  	rv := reflect.ValueOf(v)
  1242  	if rv.IsNil() {
  1243  		return "nil"
  1244  	}
  1245  	pv := reflect.Indirect(rv).Interface()
  1246  	return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
  1247  }
  1248  func (m *DoubleValue) Marshal() (dAtA []byte, err error) {
  1249  	size := m.Size()
  1250  	dAtA = make([]byte, size)
  1251  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1252  	if err != nil {
  1253  		return nil, err
  1254  	}
  1255  	return dAtA[:n], nil
  1256  }
  1257  
  1258  func (m *DoubleValue) MarshalTo(dAtA []byte) (int, error) {
  1259  	size := m.Size()
  1260  	return m.MarshalToSizedBuffer(dAtA[:size])
  1261  }
  1262  
  1263  func (m *DoubleValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1264  	i := len(dAtA)
  1265  	_ = i
  1266  	var l int
  1267  	_ = l
  1268  	if m.XXX_unrecognized != nil {
  1269  		i -= len(m.XXX_unrecognized)
  1270  		copy(dAtA[i:], m.XXX_unrecognized)
  1271  	}
  1272  	if m.Value != 0 {
  1273  		i -= 8
  1274  		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Value))))
  1275  		i--
  1276  		dAtA[i] = 0x9
  1277  	}
  1278  	return len(dAtA) - i, nil
  1279  }
  1280  
  1281  func (m *FloatValue) Marshal() (dAtA []byte, err error) {
  1282  	size := m.Size()
  1283  	dAtA = make([]byte, size)
  1284  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1285  	if err != nil {
  1286  		return nil, err
  1287  	}
  1288  	return dAtA[:n], nil
  1289  }
  1290  
  1291  func (m *FloatValue) MarshalTo(dAtA []byte) (int, error) {
  1292  	size := m.Size()
  1293  	return m.MarshalToSizedBuffer(dAtA[:size])
  1294  }
  1295  
  1296  func (m *FloatValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1297  	i := len(dAtA)
  1298  	_ = i
  1299  	var l int
  1300  	_ = l
  1301  	if m.XXX_unrecognized != nil {
  1302  		i -= len(m.XXX_unrecognized)
  1303  		copy(dAtA[i:], m.XXX_unrecognized)
  1304  	}
  1305  	if m.Value != 0 {
  1306  		i -= 4
  1307  		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Value))))
  1308  		i--
  1309  		dAtA[i] = 0xd
  1310  	}
  1311  	return len(dAtA) - i, nil
  1312  }
  1313  
  1314  func (m *Int64Value) Marshal() (dAtA []byte, err error) {
  1315  	size := m.Size()
  1316  	dAtA = make([]byte, size)
  1317  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1318  	if err != nil {
  1319  		return nil, err
  1320  	}
  1321  	return dAtA[:n], nil
  1322  }
  1323  
  1324  func (m *Int64Value) MarshalTo(dAtA []byte) (int, error) {
  1325  	size := m.Size()
  1326  	return m.MarshalToSizedBuffer(dAtA[:size])
  1327  }
  1328  
  1329  func (m *Int64Value) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1330  	i := len(dAtA)
  1331  	_ = i
  1332  	var l int
  1333  	_ = l
  1334  	if m.XXX_unrecognized != nil {
  1335  		i -= len(m.XXX_unrecognized)
  1336  		copy(dAtA[i:], m.XXX_unrecognized)
  1337  	}
  1338  	if m.Value != 0 {
  1339  		i = encodeVarintWrappers(dAtA, i, uint64(m.Value))
  1340  		i--
  1341  		dAtA[i] = 0x8
  1342  	}
  1343  	return len(dAtA) - i, nil
  1344  }
  1345  
  1346  func (m *UInt64Value) Marshal() (dAtA []byte, err error) {
  1347  	size := m.Size()
  1348  	dAtA = make([]byte, size)
  1349  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1350  	if err != nil {
  1351  		return nil, err
  1352  	}
  1353  	return dAtA[:n], nil
  1354  }
  1355  
  1356  func (m *UInt64Value) MarshalTo(dAtA []byte) (int, error) {
  1357  	size := m.Size()
  1358  	return m.MarshalToSizedBuffer(dAtA[:size])
  1359  }
  1360  
  1361  func (m *UInt64Value) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1362  	i := len(dAtA)
  1363  	_ = i
  1364  	var l int
  1365  	_ = l
  1366  	if m.XXX_unrecognized != nil {
  1367  		i -= len(m.XXX_unrecognized)
  1368  		copy(dAtA[i:], m.XXX_unrecognized)
  1369  	}
  1370  	if m.Value != 0 {
  1371  		i = encodeVarintWrappers(dAtA, i, uint64(m.Value))
  1372  		i--
  1373  		dAtA[i] = 0x8
  1374  	}
  1375  	return len(dAtA) - i, nil
  1376  }
  1377  
  1378  func (m *Int32Value) Marshal() (dAtA []byte, err error) {
  1379  	size := m.Size()
  1380  	dAtA = make([]byte, size)
  1381  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1382  	if err != nil {
  1383  		return nil, err
  1384  	}
  1385  	return dAtA[:n], nil
  1386  }
  1387  
  1388  func (m *Int32Value) MarshalTo(dAtA []byte) (int, error) {
  1389  	size := m.Size()
  1390  	return m.MarshalToSizedBuffer(dAtA[:size])
  1391  }
  1392  
  1393  func (m *Int32Value) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1394  	i := len(dAtA)
  1395  	_ = i
  1396  	var l int
  1397  	_ = l
  1398  	if m.XXX_unrecognized != nil {
  1399  		i -= len(m.XXX_unrecognized)
  1400  		copy(dAtA[i:], m.XXX_unrecognized)
  1401  	}
  1402  	if m.Value != 0 {
  1403  		i = encodeVarintWrappers(dAtA, i, uint64(m.Value))
  1404  		i--
  1405  		dAtA[i] = 0x8
  1406  	}
  1407  	return len(dAtA) - i, nil
  1408  }
  1409  
  1410  func (m *UInt32Value) Marshal() (dAtA []byte, err error) {
  1411  	size := m.Size()
  1412  	dAtA = make([]byte, size)
  1413  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1414  	if err != nil {
  1415  		return nil, err
  1416  	}
  1417  	return dAtA[:n], nil
  1418  }
  1419  
  1420  func (m *UInt32Value) MarshalTo(dAtA []byte) (int, error) {
  1421  	size := m.Size()
  1422  	return m.MarshalToSizedBuffer(dAtA[:size])
  1423  }
  1424  
  1425  func (m *UInt32Value) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1426  	i := len(dAtA)
  1427  	_ = i
  1428  	var l int
  1429  	_ = l
  1430  	if m.XXX_unrecognized != nil {
  1431  		i -= len(m.XXX_unrecognized)
  1432  		copy(dAtA[i:], m.XXX_unrecognized)
  1433  	}
  1434  	if m.Value != 0 {
  1435  		i = encodeVarintWrappers(dAtA, i, uint64(m.Value))
  1436  		i--
  1437  		dAtA[i] = 0x8
  1438  	}
  1439  	return len(dAtA) - i, nil
  1440  }
  1441  
  1442  func (m *BoolValue) Marshal() (dAtA []byte, err error) {
  1443  	size := m.Size()
  1444  	dAtA = make([]byte, size)
  1445  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1446  	if err != nil {
  1447  		return nil, err
  1448  	}
  1449  	return dAtA[:n], nil
  1450  }
  1451  
  1452  func (m *BoolValue) MarshalTo(dAtA []byte) (int, error) {
  1453  	size := m.Size()
  1454  	return m.MarshalToSizedBuffer(dAtA[:size])
  1455  }
  1456  
  1457  func (m *BoolValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1458  	i := len(dAtA)
  1459  	_ = i
  1460  	var l int
  1461  	_ = l
  1462  	if m.XXX_unrecognized != nil {
  1463  		i -= len(m.XXX_unrecognized)
  1464  		copy(dAtA[i:], m.XXX_unrecognized)
  1465  	}
  1466  	if m.Value {
  1467  		i--
  1468  		if m.Value {
  1469  			dAtA[i] = 1
  1470  		} else {
  1471  			dAtA[i] = 0
  1472  		}
  1473  		i--
  1474  		dAtA[i] = 0x8
  1475  	}
  1476  	return len(dAtA) - i, nil
  1477  }
  1478  
  1479  func (m *StringValue) Marshal() (dAtA []byte, err error) {
  1480  	size := m.Size()
  1481  	dAtA = make([]byte, size)
  1482  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1483  	if err != nil {
  1484  		return nil, err
  1485  	}
  1486  	return dAtA[:n], nil
  1487  }
  1488  
  1489  func (m *StringValue) MarshalTo(dAtA []byte) (int, error) {
  1490  	size := m.Size()
  1491  	return m.MarshalToSizedBuffer(dAtA[:size])
  1492  }
  1493  
  1494  func (m *StringValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1495  	i := len(dAtA)
  1496  	_ = i
  1497  	var l int
  1498  	_ = l
  1499  	if m.XXX_unrecognized != nil {
  1500  		i -= len(m.XXX_unrecognized)
  1501  		copy(dAtA[i:], m.XXX_unrecognized)
  1502  	}
  1503  	if len(m.Value) > 0 {
  1504  		i -= len(m.Value)
  1505  		copy(dAtA[i:], m.Value)
  1506  		i = encodeVarintWrappers(dAtA, i, uint64(len(m.Value)))
  1507  		i--
  1508  		dAtA[i] = 0xa
  1509  	}
  1510  	return len(dAtA) - i, nil
  1511  }
  1512  
  1513  func (m *BytesValue) Marshal() (dAtA []byte, err error) {
  1514  	size := m.Size()
  1515  	dAtA = make([]byte, size)
  1516  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1517  	if err != nil {
  1518  		return nil, err
  1519  	}
  1520  	return dAtA[:n], nil
  1521  }
  1522  
  1523  func (m *BytesValue) MarshalTo(dAtA []byte) (int, error) {
  1524  	size := m.Size()
  1525  	return m.MarshalToSizedBuffer(dAtA[:size])
  1526  }
  1527  
  1528  func (m *BytesValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1529  	i := len(dAtA)
  1530  	_ = i
  1531  	var l int
  1532  	_ = l
  1533  	if m.XXX_unrecognized != nil {
  1534  		i -= len(m.XXX_unrecognized)
  1535  		copy(dAtA[i:], m.XXX_unrecognized)
  1536  	}
  1537  	if len(m.Value) > 0 {
  1538  		i -= len(m.Value)
  1539  		copy(dAtA[i:], m.Value)
  1540  		i = encodeVarintWrappers(dAtA, i, uint64(len(m.Value)))
  1541  		i--
  1542  		dAtA[i] = 0xa
  1543  	}
  1544  	return len(dAtA) - i, nil
  1545  }
  1546  
  1547  func encodeVarintWrappers(dAtA []byte, offset int, v uint64) int {
  1548  	offset -= sovWrappers(v)
  1549  	base := offset
  1550  	for v >= 1<<7 {
  1551  		dAtA[offset] = uint8(v&0x7f | 0x80)
  1552  		v >>= 7
  1553  		offset++
  1554  	}
  1555  	dAtA[offset] = uint8(v)
  1556  	return base
  1557  }
  1558  func NewPopulatedDoubleValue(r randyWrappers, easy bool) *DoubleValue {
  1559  	this := &DoubleValue{}
  1560  	this.Value = float64(r.Float64())
  1561  	if r.Intn(2) == 0 {
  1562  		this.Value *= -1
  1563  	}
  1564  	if !easy && r.Intn(10) != 0 {
  1565  		this.XXX_unrecognized = randUnrecognizedWrappers(r, 2)
  1566  	}
  1567  	return this
  1568  }
  1569  
  1570  func NewPopulatedFloatValue(r randyWrappers, easy bool) *FloatValue {
  1571  	this := &FloatValue{}
  1572  	this.Value = float32(r.Float32())
  1573  	if r.Intn(2) == 0 {
  1574  		this.Value *= -1
  1575  	}
  1576  	if !easy && r.Intn(10) != 0 {
  1577  		this.XXX_unrecognized = randUnrecognizedWrappers(r, 2)
  1578  	}
  1579  	return this
  1580  }
  1581  
  1582  func NewPopulatedInt64Value(r randyWrappers, easy bool) *Int64Value {
  1583  	this := &Int64Value{}
  1584  	this.Value = int64(r.Int63())
  1585  	if r.Intn(2) == 0 {
  1586  		this.Value *= -1
  1587  	}
  1588  	if !easy && r.Intn(10) != 0 {
  1589  		this.XXX_unrecognized = randUnrecognizedWrappers(r, 2)
  1590  	}
  1591  	return this
  1592  }
  1593  
  1594  func NewPopulatedUInt64Value(r randyWrappers, easy bool) *UInt64Value {
  1595  	this := &UInt64Value{}
  1596  	this.Value = uint64(uint64(r.Uint32()))
  1597  	if !easy && r.Intn(10) != 0 {
  1598  		this.XXX_unrecognized = randUnrecognizedWrappers(r, 2)
  1599  	}
  1600  	return this
  1601  }
  1602  
  1603  func NewPopulatedInt32Value(r randyWrappers, easy bool) *Int32Value {
  1604  	this := &Int32Value{}
  1605  	this.Value = int32(r.Int31())
  1606  	if r.Intn(2) == 0 {
  1607  		this.Value *= -1
  1608  	}
  1609  	if !easy && r.Intn(10) != 0 {
  1610  		this.XXX_unrecognized = randUnrecognizedWrappers(r, 2)
  1611  	}
  1612  	return this
  1613  }
  1614  
  1615  func NewPopulatedUInt32Value(r randyWrappers, easy bool) *UInt32Value {
  1616  	this := &UInt32Value{}
  1617  	this.Value = uint32(r.Uint32())
  1618  	if !easy && r.Intn(10) != 0 {
  1619  		this.XXX_unrecognized = randUnrecognizedWrappers(r, 2)
  1620  	}
  1621  	return this
  1622  }
  1623  
  1624  func NewPopulatedBoolValue(r randyWrappers, easy bool) *BoolValue {
  1625  	this := &BoolValue{}
  1626  	this.Value = bool(bool(r.Intn(2) == 0))
  1627  	if !easy && r.Intn(10) != 0 {
  1628  		this.XXX_unrecognized = randUnrecognizedWrappers(r, 2)
  1629  	}
  1630  	return this
  1631  }
  1632  
  1633  func NewPopulatedStringValue(r randyWrappers, easy bool) *StringValue {
  1634  	this := &StringValue{}
  1635  	this.Value = string(randStringWrappers(r))
  1636  	if !easy && r.Intn(10) != 0 {
  1637  		this.XXX_unrecognized = randUnrecognizedWrappers(r, 2)
  1638  	}
  1639  	return this
  1640  }
  1641  
  1642  func NewPopulatedBytesValue(r randyWrappers, easy bool) *BytesValue {
  1643  	this := &BytesValue{}
  1644  	v1 := r.Intn(100)
  1645  	this.Value = make([]byte, v1)
  1646  	for i := 0; i < v1; i++ {
  1647  		this.Value[i] = byte(r.Intn(256))
  1648  	}
  1649  	if !easy && r.Intn(10) != 0 {
  1650  		this.XXX_unrecognized = randUnrecognizedWrappers(r, 2)
  1651  	}
  1652  	return this
  1653  }
  1654  
  1655  type randyWrappers interface {
  1656  	Float32() float32
  1657  	Float64() float64
  1658  	Int63() int64
  1659  	Int31() int32
  1660  	Uint32() uint32
  1661  	Intn(n int) int
  1662  }
  1663  
  1664  func randUTF8RuneWrappers(r randyWrappers) rune {
  1665  	ru := r.Intn(62)
  1666  	if ru < 10 {
  1667  		return rune(ru + 48)
  1668  	} else if ru < 36 {
  1669  		return rune(ru + 55)
  1670  	}
  1671  	return rune(ru + 61)
  1672  }
  1673  func randStringWrappers(r randyWrappers) string {
  1674  	v2 := r.Intn(100)
  1675  	tmps := make([]rune, v2)
  1676  	for i := 0; i < v2; i++ {
  1677  		tmps[i] = randUTF8RuneWrappers(r)
  1678  	}
  1679  	return string(tmps)
  1680  }
  1681  func randUnrecognizedWrappers(r randyWrappers, maxFieldNumber int) (dAtA []byte) {
  1682  	l := r.Intn(5)
  1683  	for i := 0; i < l; i++ {
  1684  		wire := r.Intn(4)
  1685  		if wire == 3 {
  1686  			wire = 5
  1687  		}
  1688  		fieldNumber := maxFieldNumber + r.Intn(100)
  1689  		dAtA = randFieldWrappers(dAtA, r, fieldNumber, wire)
  1690  	}
  1691  	return dAtA
  1692  }
  1693  func randFieldWrappers(dAtA []byte, r randyWrappers, fieldNumber int, wire int) []byte {
  1694  	key := uint32(fieldNumber)<<3 | uint32(wire)
  1695  	switch wire {
  1696  	case 0:
  1697  		dAtA = encodeVarintPopulateWrappers(dAtA, uint64(key))
  1698  		v3 := r.Int63()
  1699  		if r.Intn(2) == 0 {
  1700  			v3 *= -1
  1701  		}
  1702  		dAtA = encodeVarintPopulateWrappers(dAtA, uint64(v3))
  1703  	case 1:
  1704  		dAtA = encodeVarintPopulateWrappers(dAtA, uint64(key))
  1705  		dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
  1706  	case 2:
  1707  		dAtA = encodeVarintPopulateWrappers(dAtA, uint64(key))
  1708  		ll := r.Intn(100)
  1709  		dAtA = encodeVarintPopulateWrappers(dAtA, uint64(ll))
  1710  		for j := 0; j < ll; j++ {
  1711  			dAtA = append(dAtA, byte(r.Intn(256)))
  1712  		}
  1713  	default:
  1714  		dAtA = encodeVarintPopulateWrappers(dAtA, uint64(key))
  1715  		dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
  1716  	}
  1717  	return dAtA
  1718  }
  1719  func encodeVarintPopulateWrappers(dAtA []byte, v uint64) []byte {
  1720  	for v >= 1<<7 {
  1721  		dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80))
  1722  		v >>= 7
  1723  	}
  1724  	dAtA = append(dAtA, uint8(v))
  1725  	return dAtA
  1726  }
  1727  func (m *DoubleValue) Size() (n int) {
  1728  	if m == nil {
  1729  		return 0
  1730  	}
  1731  	var l int
  1732  	_ = l
  1733  	if m.Value != 0 {
  1734  		n += 9
  1735  	}
  1736  	if m.XXX_unrecognized != nil {
  1737  		n += len(m.XXX_unrecognized)
  1738  	}
  1739  	return n
  1740  }
  1741  
  1742  func (m *FloatValue) Size() (n int) {
  1743  	if m == nil {
  1744  		return 0
  1745  	}
  1746  	var l int
  1747  	_ = l
  1748  	if m.Value != 0 {
  1749  		n += 5
  1750  	}
  1751  	if m.XXX_unrecognized != nil {
  1752  		n += len(m.XXX_unrecognized)
  1753  	}
  1754  	return n
  1755  }
  1756  
  1757  func (m *Int64Value) Size() (n int) {
  1758  	if m == nil {
  1759  		return 0
  1760  	}
  1761  	var l int
  1762  	_ = l
  1763  	if m.Value != 0 {
  1764  		n += 1 + sovWrappers(uint64(m.Value))
  1765  	}
  1766  	if m.XXX_unrecognized != nil {
  1767  		n += len(m.XXX_unrecognized)
  1768  	}
  1769  	return n
  1770  }
  1771  
  1772  func (m *UInt64Value) Size() (n int) {
  1773  	if m == nil {
  1774  		return 0
  1775  	}
  1776  	var l int
  1777  	_ = l
  1778  	if m.Value != 0 {
  1779  		n += 1 + sovWrappers(uint64(m.Value))
  1780  	}
  1781  	if m.XXX_unrecognized != nil {
  1782  		n += len(m.XXX_unrecognized)
  1783  	}
  1784  	return n
  1785  }
  1786  
  1787  func (m *Int32Value) Size() (n int) {
  1788  	if m == nil {
  1789  		return 0
  1790  	}
  1791  	var l int
  1792  	_ = l
  1793  	if m.Value != 0 {
  1794  		n += 1 + sovWrappers(uint64(m.Value))
  1795  	}
  1796  	if m.XXX_unrecognized != nil {
  1797  		n += len(m.XXX_unrecognized)
  1798  	}
  1799  	return n
  1800  }
  1801  
  1802  func (m *UInt32Value) Size() (n int) {
  1803  	if m == nil {
  1804  		return 0
  1805  	}
  1806  	var l int
  1807  	_ = l
  1808  	if m.Value != 0 {
  1809  		n += 1 + sovWrappers(uint64(m.Value))
  1810  	}
  1811  	if m.XXX_unrecognized != nil {
  1812  		n += len(m.XXX_unrecognized)
  1813  	}
  1814  	return n
  1815  }
  1816  
  1817  func (m *BoolValue) Size() (n int) {
  1818  	if m == nil {
  1819  		return 0
  1820  	}
  1821  	var l int
  1822  	_ = l
  1823  	if m.Value {
  1824  		n += 2
  1825  	}
  1826  	if m.XXX_unrecognized != nil {
  1827  		n += len(m.XXX_unrecognized)
  1828  	}
  1829  	return n
  1830  }
  1831  
  1832  func (m *StringValue) Size() (n int) {
  1833  	if m == nil {
  1834  		return 0
  1835  	}
  1836  	var l int
  1837  	_ = l
  1838  	l = len(m.Value)
  1839  	if l > 0 {
  1840  		n += 1 + l + sovWrappers(uint64(l))
  1841  	}
  1842  	if m.XXX_unrecognized != nil {
  1843  		n += len(m.XXX_unrecognized)
  1844  	}
  1845  	return n
  1846  }
  1847  
  1848  func (m *BytesValue) Size() (n int) {
  1849  	if m == nil {
  1850  		return 0
  1851  	}
  1852  	var l int
  1853  	_ = l
  1854  	l = len(m.Value)
  1855  	if l > 0 {
  1856  		n += 1 + l + sovWrappers(uint64(l))
  1857  	}
  1858  	if m.XXX_unrecognized != nil {
  1859  		n += len(m.XXX_unrecognized)
  1860  	}
  1861  	return n
  1862  }
  1863  
  1864  func sovWrappers(x uint64) (n int) {
  1865  	return (math_bits.Len64(x|1) + 6) / 7
  1866  }
  1867  func sozWrappers(x uint64) (n int) {
  1868  	return sovWrappers(uint64((x << 1) ^ uint64((int64(x) >> 63))))
  1869  }
  1870  func (this *DoubleValue) String() string {
  1871  	if this == nil {
  1872  		return "nil"
  1873  	}
  1874  	s := strings.Join([]string{`&DoubleValue{`,
  1875  		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
  1876  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  1877  		`}`,
  1878  	}, "")
  1879  	return s
  1880  }
  1881  func (this *FloatValue) String() string {
  1882  	if this == nil {
  1883  		return "nil"
  1884  	}
  1885  	s := strings.Join([]string{`&FloatValue{`,
  1886  		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
  1887  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  1888  		`}`,
  1889  	}, "")
  1890  	return s
  1891  }
  1892  func (this *Int64Value) String() string {
  1893  	if this == nil {
  1894  		return "nil"
  1895  	}
  1896  	s := strings.Join([]string{`&Int64Value{`,
  1897  		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
  1898  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  1899  		`}`,
  1900  	}, "")
  1901  	return s
  1902  }
  1903  func (this *UInt64Value) String() string {
  1904  	if this == nil {
  1905  		return "nil"
  1906  	}
  1907  	s := strings.Join([]string{`&UInt64Value{`,
  1908  		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
  1909  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  1910  		`}`,
  1911  	}, "")
  1912  	return s
  1913  }
  1914  func (this *Int32Value) String() string {
  1915  	if this == nil {
  1916  		return "nil"
  1917  	}
  1918  	s := strings.Join([]string{`&Int32Value{`,
  1919  		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
  1920  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  1921  		`}`,
  1922  	}, "")
  1923  	return s
  1924  }
  1925  func (this *UInt32Value) String() string {
  1926  	if this == nil {
  1927  		return "nil"
  1928  	}
  1929  	s := strings.Join([]string{`&UInt32Value{`,
  1930  		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
  1931  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  1932  		`}`,
  1933  	}, "")
  1934  	return s
  1935  }
  1936  func (this *BoolValue) String() string {
  1937  	if this == nil {
  1938  		return "nil"
  1939  	}
  1940  	s := strings.Join([]string{`&BoolValue{`,
  1941  		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
  1942  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  1943  		`}`,
  1944  	}, "")
  1945  	return s
  1946  }
  1947  func (this *StringValue) String() string {
  1948  	if this == nil {
  1949  		return "nil"
  1950  	}
  1951  	s := strings.Join([]string{`&StringValue{`,
  1952  		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
  1953  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  1954  		`}`,
  1955  	}, "")
  1956  	return s
  1957  }
  1958  func (this *BytesValue) String() string {
  1959  	if this == nil {
  1960  		return "nil"
  1961  	}
  1962  	s := strings.Join([]string{`&BytesValue{`,
  1963  		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
  1964  		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
  1965  		`}`,
  1966  	}, "")
  1967  	return s
  1968  }
  1969  func valueToStringWrappers(v interface{}) string {
  1970  	rv := reflect.ValueOf(v)
  1971  	if rv.IsNil() {
  1972  		return "nil"
  1973  	}
  1974  	pv := reflect.Indirect(rv).Interface()
  1975  	return fmt.Sprintf("*%v", pv)
  1976  }
  1977  func (m *DoubleValue) Unmarshal(dAtA []byte) error {
  1978  	l := len(dAtA)
  1979  	iNdEx := 0
  1980  	for iNdEx < l {
  1981  		preIndex := iNdEx
  1982  		var wire uint64
  1983  		for shift := uint(0); ; shift += 7 {
  1984  			if shift >= 64 {
  1985  				return ErrIntOverflowWrappers
  1986  			}
  1987  			if iNdEx >= l {
  1988  				return io.ErrUnexpectedEOF
  1989  			}
  1990  			b := dAtA[iNdEx]
  1991  			iNdEx++
  1992  			wire |= uint64(b&0x7F) << shift
  1993  			if b < 0x80 {
  1994  				break
  1995  			}
  1996  		}
  1997  		fieldNum := int32(wire >> 3)
  1998  		wireType := int(wire & 0x7)
  1999  		if wireType == 4 {
  2000  			return fmt.Errorf("proto: DoubleValue: wiretype end group for non-group")
  2001  		}
  2002  		if fieldNum <= 0 {
  2003  			return fmt.Errorf("proto: DoubleValue: illegal tag %d (wire type %d)", fieldNum, wire)
  2004  		}
  2005  		switch fieldNum {
  2006  		case 1:
  2007  			if wireType != 1 {
  2008  				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
  2009  			}
  2010  			var v uint64
  2011  			if (iNdEx + 8) > l {
  2012  				return io.ErrUnexpectedEOF
  2013  			}
  2014  			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
  2015  			iNdEx += 8
  2016  			m.Value = float64(math.Float64frombits(v))
  2017  		default:
  2018  			iNdEx = preIndex
  2019  			skippy, err := skipWrappers(dAtA[iNdEx:])
  2020  			if err != nil {
  2021  				return err
  2022  			}
  2023  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  2024  				return ErrInvalidLengthWrappers
  2025  			}
  2026  			if (iNdEx + skippy) > l {
  2027  				return io.ErrUnexpectedEOF
  2028  			}
  2029  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  2030  			iNdEx += skippy
  2031  		}
  2032  	}
  2033  
  2034  	if iNdEx > l {
  2035  		return io.ErrUnexpectedEOF
  2036  	}
  2037  	return nil
  2038  }
  2039  func (m *FloatValue) Unmarshal(dAtA []byte) error {
  2040  	l := len(dAtA)
  2041  	iNdEx := 0
  2042  	for iNdEx < l {
  2043  		preIndex := iNdEx
  2044  		var wire uint64
  2045  		for shift := uint(0); ; shift += 7 {
  2046  			if shift >= 64 {
  2047  				return ErrIntOverflowWrappers
  2048  			}
  2049  			if iNdEx >= l {
  2050  				return io.ErrUnexpectedEOF
  2051  			}
  2052  			b := dAtA[iNdEx]
  2053  			iNdEx++
  2054  			wire |= uint64(b&0x7F) << shift
  2055  			if b < 0x80 {
  2056  				break
  2057  			}
  2058  		}
  2059  		fieldNum := int32(wire >> 3)
  2060  		wireType := int(wire & 0x7)
  2061  		if wireType == 4 {
  2062  			return fmt.Errorf("proto: FloatValue: wiretype end group for non-group")
  2063  		}
  2064  		if fieldNum <= 0 {
  2065  			return fmt.Errorf("proto: FloatValue: illegal tag %d (wire type %d)", fieldNum, wire)
  2066  		}
  2067  		switch fieldNum {
  2068  		case 1:
  2069  			if wireType != 5 {
  2070  				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
  2071  			}
  2072  			var v uint32
  2073  			if (iNdEx + 4) > l {
  2074  				return io.ErrUnexpectedEOF
  2075  			}
  2076  			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
  2077  			iNdEx += 4
  2078  			m.Value = float32(math.Float32frombits(v))
  2079  		default:
  2080  			iNdEx = preIndex
  2081  			skippy, err := skipWrappers(dAtA[iNdEx:])
  2082  			if err != nil {
  2083  				return err
  2084  			}
  2085  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  2086  				return ErrInvalidLengthWrappers
  2087  			}
  2088  			if (iNdEx + skippy) > l {
  2089  				return io.ErrUnexpectedEOF
  2090  			}
  2091  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  2092  			iNdEx += skippy
  2093  		}
  2094  	}
  2095  
  2096  	if iNdEx > l {
  2097  		return io.ErrUnexpectedEOF
  2098  	}
  2099  	return nil
  2100  }
  2101  func (m *Int64Value) Unmarshal(dAtA []byte) error {
  2102  	l := len(dAtA)
  2103  	iNdEx := 0
  2104  	for iNdEx < l {
  2105  		preIndex := iNdEx
  2106  		var wire uint64
  2107  		for shift := uint(0); ; shift += 7 {
  2108  			if shift >= 64 {
  2109  				return ErrIntOverflowWrappers
  2110  			}
  2111  			if iNdEx >= l {
  2112  				return io.ErrUnexpectedEOF
  2113  			}
  2114  			b := dAtA[iNdEx]
  2115  			iNdEx++
  2116  			wire |= uint64(b&0x7F) << shift
  2117  			if b < 0x80 {
  2118  				break
  2119  			}
  2120  		}
  2121  		fieldNum := int32(wire >> 3)
  2122  		wireType := int(wire & 0x7)
  2123  		if wireType == 4 {
  2124  			return fmt.Errorf("proto: Int64Value: wiretype end group for non-group")
  2125  		}
  2126  		if fieldNum <= 0 {
  2127  			return fmt.Errorf("proto: Int64Value: illegal tag %d (wire type %d)", fieldNum, wire)
  2128  		}
  2129  		switch fieldNum {
  2130  		case 1:
  2131  			if wireType != 0 {
  2132  				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
  2133  			}
  2134  			m.Value = 0
  2135  			for shift := uint(0); ; shift += 7 {
  2136  				if shift >= 64 {
  2137  					return ErrIntOverflowWrappers
  2138  				}
  2139  				if iNdEx >= l {
  2140  					return io.ErrUnexpectedEOF
  2141  				}
  2142  				b := dAtA[iNdEx]
  2143  				iNdEx++
  2144  				m.Value |= int64(b&0x7F) << shift
  2145  				if b < 0x80 {
  2146  					break
  2147  				}
  2148  			}
  2149  		default:
  2150  			iNdEx = preIndex
  2151  			skippy, err := skipWrappers(dAtA[iNdEx:])
  2152  			if err != nil {
  2153  				return err
  2154  			}
  2155  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  2156  				return ErrInvalidLengthWrappers
  2157  			}
  2158  			if (iNdEx + skippy) > l {
  2159  				return io.ErrUnexpectedEOF
  2160  			}
  2161  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  2162  			iNdEx += skippy
  2163  		}
  2164  	}
  2165  
  2166  	if iNdEx > l {
  2167  		return io.ErrUnexpectedEOF
  2168  	}
  2169  	return nil
  2170  }
  2171  func (m *UInt64Value) Unmarshal(dAtA []byte) error {
  2172  	l := len(dAtA)
  2173  	iNdEx := 0
  2174  	for iNdEx < l {
  2175  		preIndex := iNdEx
  2176  		var wire uint64
  2177  		for shift := uint(0); ; shift += 7 {
  2178  			if shift >= 64 {
  2179  				return ErrIntOverflowWrappers
  2180  			}
  2181  			if iNdEx >= l {
  2182  				return io.ErrUnexpectedEOF
  2183  			}
  2184  			b := dAtA[iNdEx]
  2185  			iNdEx++
  2186  			wire |= uint64(b&0x7F) << shift
  2187  			if b < 0x80 {
  2188  				break
  2189  			}
  2190  		}
  2191  		fieldNum := int32(wire >> 3)
  2192  		wireType := int(wire & 0x7)
  2193  		if wireType == 4 {
  2194  			return fmt.Errorf("proto: UInt64Value: wiretype end group for non-group")
  2195  		}
  2196  		if fieldNum <= 0 {
  2197  			return fmt.Errorf("proto: UInt64Value: illegal tag %d (wire type %d)", fieldNum, wire)
  2198  		}
  2199  		switch fieldNum {
  2200  		case 1:
  2201  			if wireType != 0 {
  2202  				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
  2203  			}
  2204  			m.Value = 0
  2205  			for shift := uint(0); ; shift += 7 {
  2206  				if shift >= 64 {
  2207  					return ErrIntOverflowWrappers
  2208  				}
  2209  				if iNdEx >= l {
  2210  					return io.ErrUnexpectedEOF
  2211  				}
  2212  				b := dAtA[iNdEx]
  2213  				iNdEx++
  2214  				m.Value |= uint64(b&0x7F) << shift
  2215  				if b < 0x80 {
  2216  					break
  2217  				}
  2218  			}
  2219  		default:
  2220  			iNdEx = preIndex
  2221  			skippy, err := skipWrappers(dAtA[iNdEx:])
  2222  			if err != nil {
  2223  				return err
  2224  			}
  2225  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  2226  				return ErrInvalidLengthWrappers
  2227  			}
  2228  			if (iNdEx + skippy) > l {
  2229  				return io.ErrUnexpectedEOF
  2230  			}
  2231  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  2232  			iNdEx += skippy
  2233  		}
  2234  	}
  2235  
  2236  	if iNdEx > l {
  2237  		return io.ErrUnexpectedEOF
  2238  	}
  2239  	return nil
  2240  }
  2241  func (m *Int32Value) Unmarshal(dAtA []byte) error {
  2242  	l := len(dAtA)
  2243  	iNdEx := 0
  2244  	for iNdEx < l {
  2245  		preIndex := iNdEx
  2246  		var wire uint64
  2247  		for shift := uint(0); ; shift += 7 {
  2248  			if shift >= 64 {
  2249  				return ErrIntOverflowWrappers
  2250  			}
  2251  			if iNdEx >= l {
  2252  				return io.ErrUnexpectedEOF
  2253  			}
  2254  			b := dAtA[iNdEx]
  2255  			iNdEx++
  2256  			wire |= uint64(b&0x7F) << shift
  2257  			if b < 0x80 {
  2258  				break
  2259  			}
  2260  		}
  2261  		fieldNum := int32(wire >> 3)
  2262  		wireType := int(wire & 0x7)
  2263  		if wireType == 4 {
  2264  			return fmt.Errorf("proto: Int32Value: wiretype end group for non-group")
  2265  		}
  2266  		if fieldNum <= 0 {
  2267  			return fmt.Errorf("proto: Int32Value: illegal tag %d (wire type %d)", fieldNum, wire)
  2268  		}
  2269  		switch fieldNum {
  2270  		case 1:
  2271  			if wireType != 0 {
  2272  				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
  2273  			}
  2274  			m.Value = 0
  2275  			for shift := uint(0); ; shift += 7 {
  2276  				if shift >= 64 {
  2277  					return ErrIntOverflowWrappers
  2278  				}
  2279  				if iNdEx >= l {
  2280  					return io.ErrUnexpectedEOF
  2281  				}
  2282  				b := dAtA[iNdEx]
  2283  				iNdEx++
  2284  				m.Value |= int32(b&0x7F) << shift
  2285  				if b < 0x80 {
  2286  					break
  2287  				}
  2288  			}
  2289  		default:
  2290  			iNdEx = preIndex
  2291  			skippy, err := skipWrappers(dAtA[iNdEx:])
  2292  			if err != nil {
  2293  				return err
  2294  			}
  2295  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  2296  				return ErrInvalidLengthWrappers
  2297  			}
  2298  			if (iNdEx + skippy) > l {
  2299  				return io.ErrUnexpectedEOF
  2300  			}
  2301  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  2302  			iNdEx += skippy
  2303  		}
  2304  	}
  2305  
  2306  	if iNdEx > l {
  2307  		return io.ErrUnexpectedEOF
  2308  	}
  2309  	return nil
  2310  }
  2311  func (m *UInt32Value) Unmarshal(dAtA []byte) error {
  2312  	l := len(dAtA)
  2313  	iNdEx := 0
  2314  	for iNdEx < l {
  2315  		preIndex := iNdEx
  2316  		var wire uint64
  2317  		for shift := uint(0); ; shift += 7 {
  2318  			if shift >= 64 {
  2319  				return ErrIntOverflowWrappers
  2320  			}
  2321  			if iNdEx >= l {
  2322  				return io.ErrUnexpectedEOF
  2323  			}
  2324  			b := dAtA[iNdEx]
  2325  			iNdEx++
  2326  			wire |= uint64(b&0x7F) << shift
  2327  			if b < 0x80 {
  2328  				break
  2329  			}
  2330  		}
  2331  		fieldNum := int32(wire >> 3)
  2332  		wireType := int(wire & 0x7)
  2333  		if wireType == 4 {
  2334  			return fmt.Errorf("proto: UInt32Value: wiretype end group for non-group")
  2335  		}
  2336  		if fieldNum <= 0 {
  2337  			return fmt.Errorf("proto: UInt32Value: illegal tag %d (wire type %d)", fieldNum, wire)
  2338  		}
  2339  		switch fieldNum {
  2340  		case 1:
  2341  			if wireType != 0 {
  2342  				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
  2343  			}
  2344  			m.Value = 0
  2345  			for shift := uint(0); ; shift += 7 {
  2346  				if shift >= 64 {
  2347  					return ErrIntOverflowWrappers
  2348  				}
  2349  				if iNdEx >= l {
  2350  					return io.ErrUnexpectedEOF
  2351  				}
  2352  				b := dAtA[iNdEx]
  2353  				iNdEx++
  2354  				m.Value |= uint32(b&0x7F) << shift
  2355  				if b < 0x80 {
  2356  					break
  2357  				}
  2358  			}
  2359  		default:
  2360  			iNdEx = preIndex
  2361  			skippy, err := skipWrappers(dAtA[iNdEx:])
  2362  			if err != nil {
  2363  				return err
  2364  			}
  2365  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  2366  				return ErrInvalidLengthWrappers
  2367  			}
  2368  			if (iNdEx + skippy) > l {
  2369  				return io.ErrUnexpectedEOF
  2370  			}
  2371  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  2372  			iNdEx += skippy
  2373  		}
  2374  	}
  2375  
  2376  	if iNdEx > l {
  2377  		return io.ErrUnexpectedEOF
  2378  	}
  2379  	return nil
  2380  }
  2381  func (m *BoolValue) Unmarshal(dAtA []byte) error {
  2382  	l := len(dAtA)
  2383  	iNdEx := 0
  2384  	for iNdEx < l {
  2385  		preIndex := iNdEx
  2386  		var wire uint64
  2387  		for shift := uint(0); ; shift += 7 {
  2388  			if shift >= 64 {
  2389  				return ErrIntOverflowWrappers
  2390  			}
  2391  			if iNdEx >= l {
  2392  				return io.ErrUnexpectedEOF
  2393  			}
  2394  			b := dAtA[iNdEx]
  2395  			iNdEx++
  2396  			wire |= uint64(b&0x7F) << shift
  2397  			if b < 0x80 {
  2398  				break
  2399  			}
  2400  		}
  2401  		fieldNum := int32(wire >> 3)
  2402  		wireType := int(wire & 0x7)
  2403  		if wireType == 4 {
  2404  			return fmt.Errorf("proto: BoolValue: wiretype end group for non-group")
  2405  		}
  2406  		if fieldNum <= 0 {
  2407  			return fmt.Errorf("proto: BoolValue: illegal tag %d (wire type %d)", fieldNum, wire)
  2408  		}
  2409  		switch fieldNum {
  2410  		case 1:
  2411  			if wireType != 0 {
  2412  				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
  2413  			}
  2414  			var v int
  2415  			for shift := uint(0); ; shift += 7 {
  2416  				if shift >= 64 {
  2417  					return ErrIntOverflowWrappers
  2418  				}
  2419  				if iNdEx >= l {
  2420  					return io.ErrUnexpectedEOF
  2421  				}
  2422  				b := dAtA[iNdEx]
  2423  				iNdEx++
  2424  				v |= int(b&0x7F) << shift
  2425  				if b < 0x80 {
  2426  					break
  2427  				}
  2428  			}
  2429  			m.Value = bool(v != 0)
  2430  		default:
  2431  			iNdEx = preIndex
  2432  			skippy, err := skipWrappers(dAtA[iNdEx:])
  2433  			if err != nil {
  2434  				return err
  2435  			}
  2436  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  2437  				return ErrInvalidLengthWrappers
  2438  			}
  2439  			if (iNdEx + skippy) > l {
  2440  				return io.ErrUnexpectedEOF
  2441  			}
  2442  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  2443  			iNdEx += skippy
  2444  		}
  2445  	}
  2446  
  2447  	if iNdEx > l {
  2448  		return io.ErrUnexpectedEOF
  2449  	}
  2450  	return nil
  2451  }
  2452  func (m *StringValue) Unmarshal(dAtA []byte) error {
  2453  	l := len(dAtA)
  2454  	iNdEx := 0
  2455  	for iNdEx < l {
  2456  		preIndex := iNdEx
  2457  		var wire uint64
  2458  		for shift := uint(0); ; shift += 7 {
  2459  			if shift >= 64 {
  2460  				return ErrIntOverflowWrappers
  2461  			}
  2462  			if iNdEx >= l {
  2463  				return io.ErrUnexpectedEOF
  2464  			}
  2465  			b := dAtA[iNdEx]
  2466  			iNdEx++
  2467  			wire |= uint64(b&0x7F) << shift
  2468  			if b < 0x80 {
  2469  				break
  2470  			}
  2471  		}
  2472  		fieldNum := int32(wire >> 3)
  2473  		wireType := int(wire & 0x7)
  2474  		if wireType == 4 {
  2475  			return fmt.Errorf("proto: StringValue: wiretype end group for non-group")
  2476  		}
  2477  		if fieldNum <= 0 {
  2478  			return fmt.Errorf("proto: StringValue: illegal tag %d (wire type %d)", fieldNum, wire)
  2479  		}
  2480  		switch fieldNum {
  2481  		case 1:
  2482  			if wireType != 2 {
  2483  				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
  2484  			}
  2485  			var stringLen uint64
  2486  			for shift := uint(0); ; shift += 7 {
  2487  				if shift >= 64 {
  2488  					return ErrIntOverflowWrappers
  2489  				}
  2490  				if iNdEx >= l {
  2491  					return io.ErrUnexpectedEOF
  2492  				}
  2493  				b := dAtA[iNdEx]
  2494  				iNdEx++
  2495  				stringLen |= uint64(b&0x7F) << shift
  2496  				if b < 0x80 {
  2497  					break
  2498  				}
  2499  			}
  2500  			intStringLen := int(stringLen)
  2501  			if intStringLen < 0 {
  2502  				return ErrInvalidLengthWrappers
  2503  			}
  2504  			postIndex := iNdEx + intStringLen
  2505  			if postIndex < 0 {
  2506  				return ErrInvalidLengthWrappers
  2507  			}
  2508  			if postIndex > l {
  2509  				return io.ErrUnexpectedEOF
  2510  			}
  2511  			m.Value = string(dAtA[iNdEx:postIndex])
  2512  			iNdEx = postIndex
  2513  		default:
  2514  			iNdEx = preIndex
  2515  			skippy, err := skipWrappers(dAtA[iNdEx:])
  2516  			if err != nil {
  2517  				return err
  2518  			}
  2519  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  2520  				return ErrInvalidLengthWrappers
  2521  			}
  2522  			if (iNdEx + skippy) > l {
  2523  				return io.ErrUnexpectedEOF
  2524  			}
  2525  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  2526  			iNdEx += skippy
  2527  		}
  2528  	}
  2529  
  2530  	if iNdEx > l {
  2531  		return io.ErrUnexpectedEOF
  2532  	}
  2533  	return nil
  2534  }
  2535  func (m *BytesValue) Unmarshal(dAtA []byte) error {
  2536  	l := len(dAtA)
  2537  	iNdEx := 0
  2538  	for iNdEx < l {
  2539  		preIndex := iNdEx
  2540  		var wire uint64
  2541  		for shift := uint(0); ; shift += 7 {
  2542  			if shift >= 64 {
  2543  				return ErrIntOverflowWrappers
  2544  			}
  2545  			if iNdEx >= l {
  2546  				return io.ErrUnexpectedEOF
  2547  			}
  2548  			b := dAtA[iNdEx]
  2549  			iNdEx++
  2550  			wire |= uint64(b&0x7F) << shift
  2551  			if b < 0x80 {
  2552  				break
  2553  			}
  2554  		}
  2555  		fieldNum := int32(wire >> 3)
  2556  		wireType := int(wire & 0x7)
  2557  		if wireType == 4 {
  2558  			return fmt.Errorf("proto: BytesValue: wiretype end group for non-group")
  2559  		}
  2560  		if fieldNum <= 0 {
  2561  			return fmt.Errorf("proto: BytesValue: illegal tag %d (wire type %d)", fieldNum, wire)
  2562  		}
  2563  		switch fieldNum {
  2564  		case 1:
  2565  			if wireType != 2 {
  2566  				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
  2567  			}
  2568  			var byteLen int
  2569  			for shift := uint(0); ; shift += 7 {
  2570  				if shift >= 64 {
  2571  					return ErrIntOverflowWrappers
  2572  				}
  2573  				if iNdEx >= l {
  2574  					return io.ErrUnexpectedEOF
  2575  				}
  2576  				b := dAtA[iNdEx]
  2577  				iNdEx++
  2578  				byteLen |= int(b&0x7F) << shift
  2579  				if b < 0x80 {
  2580  					break
  2581  				}
  2582  			}
  2583  			if byteLen < 0 {
  2584  				return ErrInvalidLengthWrappers
  2585  			}
  2586  			postIndex := iNdEx + byteLen
  2587  			if postIndex < 0 {
  2588  				return ErrInvalidLengthWrappers
  2589  			}
  2590  			if postIndex > l {
  2591  				return io.ErrUnexpectedEOF
  2592  			}
  2593  			m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...)
  2594  			if m.Value == nil {
  2595  				m.Value = []byte{}
  2596  			}
  2597  			iNdEx = postIndex
  2598  		default:
  2599  			iNdEx = preIndex
  2600  			skippy, err := skipWrappers(dAtA[iNdEx:])
  2601  			if err != nil {
  2602  				return err
  2603  			}
  2604  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  2605  				return ErrInvalidLengthWrappers
  2606  			}
  2607  			if (iNdEx + skippy) > l {
  2608  				return io.ErrUnexpectedEOF
  2609  			}
  2610  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  2611  			iNdEx += skippy
  2612  		}
  2613  	}
  2614  
  2615  	if iNdEx > l {
  2616  		return io.ErrUnexpectedEOF
  2617  	}
  2618  	return nil
  2619  }
  2620  func skipWrappers(dAtA []byte) (n int, err error) {
  2621  	l := len(dAtA)
  2622  	iNdEx := 0
  2623  	depth := 0
  2624  	for iNdEx < l {
  2625  		var wire uint64
  2626  		for shift := uint(0); ; shift += 7 {
  2627  			if shift >= 64 {
  2628  				return 0, ErrIntOverflowWrappers
  2629  			}
  2630  			if iNdEx >= l {
  2631  				return 0, io.ErrUnexpectedEOF
  2632  			}
  2633  			b := dAtA[iNdEx]
  2634  			iNdEx++
  2635  			wire |= (uint64(b) & 0x7F) << shift
  2636  			if b < 0x80 {
  2637  				break
  2638  			}
  2639  		}
  2640  		wireType := int(wire & 0x7)
  2641  		switch wireType {
  2642  		case 0:
  2643  			for shift := uint(0); ; shift += 7 {
  2644  				if shift >= 64 {
  2645  					return 0, ErrIntOverflowWrappers
  2646  				}
  2647  				if iNdEx >= l {
  2648  					return 0, io.ErrUnexpectedEOF
  2649  				}
  2650  				iNdEx++
  2651  				if dAtA[iNdEx-1] < 0x80 {
  2652  					break
  2653  				}
  2654  			}
  2655  		case 1:
  2656  			iNdEx += 8
  2657  		case 2:
  2658  			var length int
  2659  			for shift := uint(0); ; shift += 7 {
  2660  				if shift >= 64 {
  2661  					return 0, ErrIntOverflowWrappers
  2662  				}
  2663  				if iNdEx >= l {
  2664  					return 0, io.ErrUnexpectedEOF
  2665  				}
  2666  				b := dAtA[iNdEx]
  2667  				iNdEx++
  2668  				length |= (int(b) & 0x7F) << shift
  2669  				if b < 0x80 {
  2670  					break
  2671  				}
  2672  			}
  2673  			if length < 0 {
  2674  				return 0, ErrInvalidLengthWrappers
  2675  			}
  2676  			iNdEx += length
  2677  		case 3:
  2678  			depth++
  2679  		case 4:
  2680  			if depth == 0 {
  2681  				return 0, ErrUnexpectedEndOfGroupWrappers
  2682  			}
  2683  			depth--
  2684  		case 5:
  2685  			iNdEx += 4
  2686  		default:
  2687  			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
  2688  		}
  2689  		if iNdEx < 0 {
  2690  			return 0, ErrInvalidLengthWrappers
  2691  		}
  2692  		if depth == 0 {
  2693  			return iNdEx, nil
  2694  		}
  2695  	}
  2696  	return 0, io.ErrUnexpectedEOF
  2697  }
  2698  
  2699  var (
  2700  	ErrInvalidLengthWrappers        = fmt.Errorf("proto: negative length found during unmarshaling")
  2701  	ErrIntOverflowWrappers          = fmt.Errorf("proto: integer overflow")
  2702  	ErrUnexpectedEndOfGroupWrappers = fmt.Errorf("proto: unexpected end of group")
  2703  )
  2704  

View as plain text