vendor/github.com/golang/protobuf/ptypes/wrappers/wrappers.pb.go

   1 // Code generated by protoc-gen-go. DO NOT EDIT.
   2 // source: google/protobuf/wrappers.proto
   3
   4 /*
   5 Package wrappers is a generated protocol buffer package.
   6
   7 It is generated from these files:
   8         google/protobuf/wrappers.proto
   9
  10 It has these top-level messages:
  11         DoubleValue
  12         FloatValue
  13         Int64Value
  14         UInt64Value
  15         Int32Value
  16         UInt32Value
  17         BoolValue
  18         StringValue
  19         BytesValue
  20 */
  21 package wrappers
  22
  23 import proto "github.com/golang/protobuf/proto"
  24 import fmt "fmt"
  25 import math "math"
  26
  27 // Reference imports to suppress errors if they are not otherwise used.
  28 var _ = proto.Marshal
  29 var _ = fmt.Errorf
  30 var _ = math.Inf
  31
  32 // This is a compile-time assertion to ensure that this generated file
  33 // is compatible with the proto package it is being compiled against.
  34 // A compilation error at this line likely means your copy of the
  35 // proto package needs to be updated.
  36 const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
  37
  38 // Wrapper message for `double`.
  39 //
  40 // The JSON representation for `DoubleValue` is JSON number.
  41 type DoubleValue struct {
  42         // The double value.
  43         Value float64 `protobuf:"fixed64,1,opt,name=value" json:"value,omitempty"`
  44 }
  45
  46 func (m *DoubleValue) Reset()                    { *m = DoubleValue{} }
  47 func (m *DoubleValue) String() string            { return proto.CompactTextString(m) }
  48 func (*DoubleValue) ProtoMessage()               {}
  49 func (*DoubleValue) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
  50 func (*DoubleValue) XXX_WellKnownType() string   { return "DoubleValue" }
  51
  52 func (m *DoubleValue) GetValue() float64 {
  53         if m != nil {
  54                 return m.Value
  55         }
  56         return 0
  57 }
  58
  59 // Wrapper message for `float`.
  60 //
  61 // The JSON representation for `FloatValue` is JSON number.
  62 type FloatValue struct {
  63         // The float value.
  64         Value float32 `protobuf:"fixed32,1,opt,name=value" json:"value,omitempty"`
  65 }
  66
  67 func (m *FloatValue) Reset()                    { *m = FloatValue{} }
  68 func (m *FloatValue) String() string            { return proto.CompactTextString(m) }
  69 func (*FloatValue) ProtoMessage()               {}
  70 func (*FloatValue) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
  71 func (*FloatValue) XXX_WellKnownType() string   { return "FloatValue" }
  72
  73 func (m *FloatValue) GetValue() float32 {
  74         if m != nil {
  75                 return m.Value
  76         }
  77         return 0
  78 }
  79
  80 // Wrapper message for `int64`.
  81 //
  82 // The JSON representation for `Int64Value` is JSON string.
  83 type Int64Value struct {
  84         // The int64 value.
  85         Value int64 `protobuf:"varint,1,opt,name=value" json:"value,omitempty"`
  86 }
  87
  88 func (m *Int64Value) Reset()                    { *m = Int64Value{} }
  89 func (m *Int64Value) String() string            { return proto.CompactTextString(m) }
  90 func (*Int64Value) ProtoMessage()               {}
  91 func (*Int64Value) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
  92 func (*Int64Value) XXX_WellKnownType() string   { return "Int64Value" }
  93
  94 func (m *Int64Value) GetValue() int64 {
  95         if m != nil {
  96                 return m.Value
  97         }
  98         return 0
  99 }
 100
 101 // Wrapper message for `uint64`.
 102 //
 103 // The JSON representation for `UInt64Value` is JSON string.
 104 type UInt64Value struct {
 105         // The uint64 value.
 106         Value uint64 `protobuf:"varint,1,opt,name=value" json:"value,omitempty"`
 107 }
 108
 109 func (m *UInt64Value) Reset()                    { *m = UInt64Value{} }
 110 func (m *UInt64Value) String() string            { return proto.CompactTextString(m) }
 111 func (*UInt64Value) ProtoMessage()               {}
 112 func (*UInt64Value) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
 113 func (*UInt64Value) XXX_WellKnownType() string   { return "UInt64Value" }
 114
 115 func (m *UInt64Value) GetValue() uint64 {
 116         if m != nil {
 117                 return m.Value
 118         }
 119         return 0
 120 }
 121
 122 // Wrapper message for `int32`.
 123 //
 124 // The JSON representation for `Int32Value` is JSON number.
 125 type Int32Value struct {
 126         // The int32 value.
 127         Value int32 `protobuf:"varint,1,opt,name=value" json:"value,omitempty"`
 128 }
 129
 130 func (m *Int32Value) Reset()                    { *m = Int32Value{} }
 131 func (m *Int32Value) String() string            { return proto.CompactTextString(m) }
 132 func (*Int32Value) ProtoMessage()               {}
 133 func (*Int32Value) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
 134 func (*Int32Value) XXX_WellKnownType() string   { return "Int32Value" }
 135
 136 func (m *Int32Value) GetValue() int32 {
 137         if m != nil {
 138                 return m.Value
 139         }
 140         return 0
 141 }
 142
 143 // Wrapper message for `uint32`.
 144 //
 145 // The JSON representation for `UInt32Value` is JSON number.
 146 type UInt32Value struct {
 147         // The uint32 value.
 148         Value uint32 `protobuf:"varint,1,opt,name=value" json:"value,omitempty"`
 149 }
 150
 151 func (m *UInt32Value) Reset()                    { *m = UInt32Value{} }
 152 func (m *UInt32Value) String() string            { return proto.CompactTextString(m) }
 153 func (*UInt32Value) ProtoMessage()               {}
 154 func (*UInt32Value) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }
 155 func (*UInt32Value) XXX_WellKnownType() string   { return "UInt32Value" }
 156
 157 func (m *UInt32Value) GetValue() uint32 {
 158         if m != nil {
 159                 return m.Value
 160         }
 161         return 0
 162 }
 163
 164 // Wrapper message for `bool`.
 165 //
 166 // The JSON representation for `BoolValue` is JSON `true` and `false`.
 167 type BoolValue struct {
 168         // The bool value.
 169         Value bool `protobuf:"varint,1,opt,name=value" json:"value,omitempty"`
 170 }
 171
 172 func (m *BoolValue) Reset()                    { *m = BoolValue{} }
 173 func (m *BoolValue) String() string            { return proto.CompactTextString(m) }
 174 func (*BoolValue) ProtoMessage()               {}
 175 func (*BoolValue) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }
 176 func (*BoolValue) XXX_WellKnownType() string   { return "BoolValue" }
 177
 178 func (m *BoolValue) GetValue() bool {
 179         if m != nil {
 180                 return m.Value
 181         }
 182         return false
 183 }
 184
 185 // Wrapper message for `string`.
 186 //
 187 // The JSON representation for `StringValue` is JSON string.
 188 type StringValue struct {
 189         // The string value.
 190         Value string `protobuf:"bytes,1,opt,name=value" json:"value,omitempty"`
 191 }
 192
 193 func (m *StringValue) Reset()                    { *m = StringValue{} }
 194 func (m *StringValue) String() string            { return proto.CompactTextString(m) }
 195 func (*StringValue) ProtoMessage()               {}
 196 func (*StringValue) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
 197 func (*StringValue) XXX_WellKnownType() string   { return "StringValue" }
 198
 199 func (m *StringValue) GetValue() string {
 200         if m != nil {
 201                 return m.Value
 202         }
 203         return ""
 204 }
 205
 206 // Wrapper message for `bytes`.
 207 //
 208 // The JSON representation for `BytesValue` is JSON string.
 209 type BytesValue struct {
 210         // The bytes value.
 211         Value []byte `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
 212 }
 213
 214 func (m *BytesValue) Reset()                    { *m = BytesValue{} }
 215 func (m *BytesValue) String() string            { return proto.CompactTextString(m) }
 216 func (*BytesValue) ProtoMessage()               {}
 217 func (*BytesValue) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} }
 218 func (*BytesValue) XXX_WellKnownType() string   { return "BytesValue" }
 219
 220 func (m *BytesValue) GetValue() []byte {
 221         if m != nil {
 222                 return m.Value
 223         }
 224         return nil
 225 }
 226
 227 func init() {
 228         proto.RegisterType((*DoubleValue)(nil), "google.protobuf.DoubleValue")
 229         proto.RegisterType((*FloatValue)(nil), "google.protobuf.FloatValue")
 230         proto.RegisterType((*Int64Value)(nil), "google.protobuf.Int64Value")
 231         proto.RegisterType((*UInt64Value)(nil), "google.protobuf.UInt64Value")
 232         proto.RegisterType((*Int32Value)(nil), "google.protobuf.Int32Value")
 233         proto.RegisterType((*UInt32Value)(nil), "google.protobuf.UInt32Value")
 234         proto.RegisterType((*BoolValue)(nil), "google.protobuf.BoolValue")
 235         proto.RegisterType((*StringValue)(nil), "google.protobuf.StringValue")
 236         proto.RegisterType((*BytesValue)(nil), "google.protobuf.BytesValue")
 237 }
 238
 239 func init() { proto.RegisterFile("google/protobuf/wrappers.proto", fileDescriptor0) }
 240
 241 var fileDescriptor0 = []byte{
 242         // 259 bytes of a gzipped FileDescriptorProto
 243         0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4b, 0xcf, 0xcf, 0x4f,
 244         0xcf, 0x49, 0xd5, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x2f, 0x2f, 0x4a, 0x2c,
 245         0x28, 0x48, 0x2d, 0x2a, 0xd6, 0x03, 0x8b, 0x08, 0xf1, 0x43, 0xe4, 0xf5, 0x60, 0xf2, 0x4a, 0xca,
 246         0x5c, 0xdc, 0x2e, 0xf9, 0xa5, 0x49, 0x39, 0xa9, 0x61, 0x89, 0x39, 0xa5, 0xa9, 0x42, 0x22, 0x5c,
 247         0xac, 0x65, 0x20, 0x86, 0x04, 0xa3, 0x02, 0xa3, 0x06, 0x63, 0x10, 0x84, 0xa3, 0xa4, 0xc4, 0xc5,
 248         0xe5, 0x96, 0x93, 0x9f, 0x58, 0x82, 0x45, 0x0d, 0x13, 0x92, 0x1a, 0xcf, 0xbc, 0x12, 0x33, 0x13,
 249         0x2c, 0x6a, 0x98, 0x61, 0x6a, 0x94, 0xb9, 0xb8, 0x43, 0x71, 0x29, 0x62, 0x41, 0x35, 0xc8, 0xd8,
 250         0x08, 0x8b, 0x1a, 0x56, 0x34, 0x83, 0xb0, 0x2a, 0xe2, 0x85, 0x29, 0x52, 0xe4, 0xe2, 0x74, 0xca,
 251         0xcf, 0xcf, 0xc1, 0xa2, 0x84, 0x03, 0xc9, 0x9c, 0xe0, 0x92, 0xa2, 0xcc, 0xbc, 0x74, 0x2c, 0x8a,
 252         0x38, 0x91, 0x1c, 0xe4, 0x54, 0x59, 0x92, 0x5a, 0x8c, 0x45, 0x0d, 0x0f, 0x54, 0x8d, 0x53, 0x0d,
 253         0x97, 0x70, 0x72, 0x7e, 0xae, 0x1e, 0x5a, 0xe8, 0x3a, 0xf1, 0x86, 0x43, 0x83, 0x3f, 0x00, 0x24,
 254         0x12, 0xc0, 0x18, 0xa5, 0x95, 0x9e, 0x59, 0x92, 0x51, 0x9a, 0xa4, 0x97, 0x9c, 0x9f, 0xab, 0x9f,
 255         0x9e, 0x9f, 0x93, 0x98, 0x97, 0x8e, 0x88, 0xaa, 0x82, 0x92, 0xca, 0x82, 0xd4, 0x62, 0x78, 0x8c,
 256         0xfd, 0x60, 0x64, 0x5c, 0xc4, 0xc4, 0xec, 0x1e, 0xe0, 0xb4, 0x8a, 0x49, 0xce, 0x1d, 0x62, 0x6e,
 257         0x00, 0x54, 0xa9, 0x5e, 0x78, 0x6a, 0x4e, 0x8e, 0x77, 0x5e, 0x7e, 0x79, 0x5e, 0x08, 0x48, 0x4b,
 258         0x12, 0x1b, 0xd8, 0x0c, 0x63, 0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0x19, 0x6c, 0xb9, 0xb8, 0xfe,
 259         0x01, 0x00, 0x00,
 260 }