cmd/bpa-operator/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 package wrappers
   5
   6 import (
   7         fmt "fmt"
   8         proto "github.com/golang/protobuf/proto"
   9         math "math"
  10 )
  11
  12 // Reference imports to suppress errors if they are not otherwise used.
  13 var _ = proto.Marshal
  14 var _ = fmt.Errorf
  15 var _ = math.Inf
  16
  17 // This is a compile-time assertion to ensure that this generated file
  18 // is compatible with the proto package it is being compiled against.
  19 // A compilation error at this line likely means your copy of the
  20 // proto package needs to be updated.
  21 const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
  22
  23 // Wrapper message for `double`.
  24 //
  25 // The JSON representation for `DoubleValue` is JSON number.
  26 type DoubleValue struct {
  27         // The double value.
  28         Value                float64  `protobuf:"fixed64,1,opt,name=value,proto3" json:"value,omitempty"`
  29         XXX_NoUnkeyedLiteral struct{} `json:"-"`
  30         XXX_unrecognized     []byte   `json:"-"`
  31         XXX_sizecache        int32    `json:"-"`
  32 }
  33
  34 func (m *DoubleValue) Reset()         { *m = DoubleValue{} }
  35 func (m *DoubleValue) String() string { return proto.CompactTextString(m) }
  36 func (*DoubleValue) ProtoMessage()    {}
  37 func (*DoubleValue) Descriptor() ([]byte, []int) {
  38         return fileDescriptor_5377b62bda767935, []int{0}
  39 }
  40
  41 func (*DoubleValue) XXX_WellKnownType() string { return "DoubleValue" }
  42
  43 func (m *DoubleValue) XXX_Unmarshal(b []byte) error {
  44         return xxx_messageInfo_DoubleValue.Unmarshal(m, b)
  45 }
  46 func (m *DoubleValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  47         return xxx_messageInfo_DoubleValue.Marshal(b, m, deterministic)
  48 }
  49 func (m *DoubleValue) XXX_Merge(src proto.Message) {
  50         xxx_messageInfo_DoubleValue.Merge(m, src)
  51 }
  52 func (m *DoubleValue) XXX_Size() int {
  53         return xxx_messageInfo_DoubleValue.Size(m)
  54 }
  55 func (m *DoubleValue) XXX_DiscardUnknown() {
  56         xxx_messageInfo_DoubleValue.DiscardUnknown(m)
  57 }
  58
  59 var xxx_messageInfo_DoubleValue proto.InternalMessageInfo
  60
  61 func (m *DoubleValue) GetValue() float64 {
  62         if m != nil {
  63                 return m.Value
  64         }
  65         return 0
  66 }
  67
  68 // Wrapper message for `float`.
  69 //
  70 // The JSON representation for `FloatValue` is JSON number.
  71 type FloatValue struct {
  72         // The float value.
  73         Value                float32  `protobuf:"fixed32,1,opt,name=value,proto3" json:"value,omitempty"`
  74         XXX_NoUnkeyedLiteral struct{} `json:"-"`
  75         XXX_unrecognized     []byte   `json:"-"`
  76         XXX_sizecache        int32    `json:"-"`
  77 }
  78
  79 func (m *FloatValue) Reset()         { *m = FloatValue{} }
  80 func (m *FloatValue) String() string { return proto.CompactTextString(m) }
  81 func (*FloatValue) ProtoMessage()    {}
  82 func (*FloatValue) Descriptor() ([]byte, []int) {
  83         return fileDescriptor_5377b62bda767935, []int{1}
  84 }
  85
  86 func (*FloatValue) XXX_WellKnownType() string { return "FloatValue" }
  87
  88 func (m *FloatValue) XXX_Unmarshal(b []byte) error {
  89         return xxx_messageInfo_FloatValue.Unmarshal(m, b)
  90 }
  91 func (m *FloatValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  92         return xxx_messageInfo_FloatValue.Marshal(b, m, deterministic)
  93 }
  94 func (m *FloatValue) XXX_Merge(src proto.Message) {
  95         xxx_messageInfo_FloatValue.Merge(m, src)
  96 }
  97 func (m *FloatValue) XXX_Size() int {
  98         return xxx_messageInfo_FloatValue.Size(m)
  99 }
 100 func (m *FloatValue) XXX_DiscardUnknown() {
 101         xxx_messageInfo_FloatValue.DiscardUnknown(m)
 102 }
 103
 104 var xxx_messageInfo_FloatValue proto.InternalMessageInfo
 105
 106 func (m *FloatValue) GetValue() float32 {
 107         if m != nil {
 108                 return m.Value
 109         }
 110         return 0
 111 }
 112
 113 // Wrapper message for `int64`.
 114 //
 115 // The JSON representation for `Int64Value` is JSON string.
 116 type Int64Value struct {
 117         // The int64 value.
 118         Value                int64    `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
 119         XXX_NoUnkeyedLiteral struct{} `json:"-"`
 120         XXX_unrecognized     []byte   `json:"-"`
 121         XXX_sizecache        int32    `json:"-"`
 122 }
 123
 124 func (m *Int64Value) Reset()         { *m = Int64Value{} }
 125 func (m *Int64Value) String() string { return proto.CompactTextString(m) }
 126 func (*Int64Value) ProtoMessage()    {}
 127 func (*Int64Value) Descriptor() ([]byte, []int) {
 128         return fileDescriptor_5377b62bda767935, []int{2}
 129 }
 130
 131 func (*Int64Value) XXX_WellKnownType() string { return "Int64Value" }
 132
 133 func (m *Int64Value) XXX_Unmarshal(b []byte) error {
 134         return xxx_messageInfo_Int64Value.Unmarshal(m, b)
 135 }
 136 func (m *Int64Value) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 137         return xxx_messageInfo_Int64Value.Marshal(b, m, deterministic)
 138 }
 139 func (m *Int64Value) XXX_Merge(src proto.Message) {
 140         xxx_messageInfo_Int64Value.Merge(m, src)
 141 }
 142 func (m *Int64Value) XXX_Size() int {
 143         return xxx_messageInfo_Int64Value.Size(m)
 144 }
 145 func (m *Int64Value) XXX_DiscardUnknown() {
 146         xxx_messageInfo_Int64Value.DiscardUnknown(m)
 147 }
 148
 149 var xxx_messageInfo_Int64Value proto.InternalMessageInfo
 150
 151 func (m *Int64Value) GetValue() int64 {
 152         if m != nil {
 153                 return m.Value
 154         }
 155         return 0
 156 }
 157
 158 // Wrapper message for `uint64`.
 159 //
 160 // The JSON representation for `UInt64Value` is JSON string.
 161 type UInt64Value struct {
 162         // The uint64 value.
 163         Value                uint64   `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
 164         XXX_NoUnkeyedLiteral struct{} `json:"-"`
 165         XXX_unrecognized     []byte   `json:"-"`
 166         XXX_sizecache        int32    `json:"-"`
 167 }
 168
 169 func (m *UInt64Value) Reset()         { *m = UInt64Value{} }
 170 func (m *UInt64Value) String() string { return proto.CompactTextString(m) }
 171 func (*UInt64Value) ProtoMessage()    {}
 172 func (*UInt64Value) Descriptor() ([]byte, []int) {
 173         return fileDescriptor_5377b62bda767935, []int{3}
 174 }
 175
 176 func (*UInt64Value) XXX_WellKnownType() string { return "UInt64Value" }
 177
 178 func (m *UInt64Value) XXX_Unmarshal(b []byte) error {
 179         return xxx_messageInfo_UInt64Value.Unmarshal(m, b)
 180 }
 181 func (m *UInt64Value) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 182         return xxx_messageInfo_UInt64Value.Marshal(b, m, deterministic)
 183 }
 184 func (m *UInt64Value) XXX_Merge(src proto.Message) {
 185         xxx_messageInfo_UInt64Value.Merge(m, src)
 186 }
 187 func (m *UInt64Value) XXX_Size() int {
 188         return xxx_messageInfo_UInt64Value.Size(m)
 189 }
 190 func (m *UInt64Value) XXX_DiscardUnknown() {
 191         xxx_messageInfo_UInt64Value.DiscardUnknown(m)
 192 }
 193
 194 var xxx_messageInfo_UInt64Value proto.InternalMessageInfo
 195
 196 func (m *UInt64Value) GetValue() uint64 {
 197         if m != nil {
 198                 return m.Value
 199         }
 200         return 0
 201 }
 202
 203 // Wrapper message for `int32`.
 204 //
 205 // The JSON representation for `Int32Value` is JSON number.
 206 type Int32Value struct {
 207         // The int32 value.
 208         Value                int32    `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
 209         XXX_NoUnkeyedLiteral struct{} `json:"-"`
 210         XXX_unrecognized     []byte   `json:"-"`
 211         XXX_sizecache        int32    `json:"-"`
 212 }
 213
 214 func (m *Int32Value) Reset()         { *m = Int32Value{} }
 215 func (m *Int32Value) String() string { return proto.CompactTextString(m) }
 216 func (*Int32Value) ProtoMessage()    {}
 217 func (*Int32Value) Descriptor() ([]byte, []int) {
 218         return fileDescriptor_5377b62bda767935, []int{4}
 219 }
 220
 221 func (*Int32Value) XXX_WellKnownType() string { return "Int32Value" }
 222
 223 func (m *Int32Value) XXX_Unmarshal(b []byte) error {
 224         return xxx_messageInfo_Int32Value.Unmarshal(m, b)
 225 }
 226 func (m *Int32Value) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 227         return xxx_messageInfo_Int32Value.Marshal(b, m, deterministic)
 228 }
 229 func (m *Int32Value) XXX_Merge(src proto.Message) {
 230         xxx_messageInfo_Int32Value.Merge(m, src)
 231 }
 232 func (m *Int32Value) XXX_Size() int {
 233         return xxx_messageInfo_Int32Value.Size(m)
 234 }
 235 func (m *Int32Value) XXX_DiscardUnknown() {
 236         xxx_messageInfo_Int32Value.DiscardUnknown(m)
 237 }
 238
 239 var xxx_messageInfo_Int32Value proto.InternalMessageInfo
 240
 241 func (m *Int32Value) GetValue() int32 {
 242         if m != nil {
 243                 return m.Value
 244         }
 245         return 0
 246 }
 247
 248 // Wrapper message for `uint32`.
 249 //
 250 // The JSON representation for `UInt32Value` is JSON number.
 251 type UInt32Value struct {
 252         // The uint32 value.
 253         Value                uint32   `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
 254         XXX_NoUnkeyedLiteral struct{} `json:"-"`
 255         XXX_unrecognized     []byte   `json:"-"`
 256         XXX_sizecache        int32    `json:"-"`
 257 }
 258
 259 func (m *UInt32Value) Reset()         { *m = UInt32Value{} }
 260 func (m *UInt32Value) String() string { return proto.CompactTextString(m) }
 261 func (*UInt32Value) ProtoMessage()    {}
 262 func (*UInt32Value) Descriptor() ([]byte, []int) {
 263         return fileDescriptor_5377b62bda767935, []int{5}
 264 }
 265
 266 func (*UInt32Value) XXX_WellKnownType() string { return "UInt32Value" }
 267
 268 func (m *UInt32Value) XXX_Unmarshal(b []byte) error {
 269         return xxx_messageInfo_UInt32Value.Unmarshal(m, b)
 270 }
 271 func (m *UInt32Value) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 272         return xxx_messageInfo_UInt32Value.Marshal(b, m, deterministic)
 273 }
 274 func (m *UInt32Value) XXX_Merge(src proto.Message) {
 275         xxx_messageInfo_UInt32Value.Merge(m, src)
 276 }
 277 func (m *UInt32Value) XXX_Size() int {
 278         return xxx_messageInfo_UInt32Value.Size(m)
 279 }
 280 func (m *UInt32Value) XXX_DiscardUnknown() {
 281         xxx_messageInfo_UInt32Value.DiscardUnknown(m)
 282 }
 283
 284 var xxx_messageInfo_UInt32Value proto.InternalMessageInfo
 285
 286 func (m *UInt32Value) GetValue() uint32 {
 287         if m != nil {
 288                 return m.Value
 289         }
 290         return 0
 291 }
 292
 293 // Wrapper message for `bool`.
 294 //
 295 // The JSON representation for `BoolValue` is JSON `true` and `false`.
 296 type BoolValue struct {
 297         // The bool value.
 298         Value                bool     `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
 299         XXX_NoUnkeyedLiteral struct{} `json:"-"`
 300         XXX_unrecognized     []byte   `json:"-"`
 301         XXX_sizecache        int32    `json:"-"`
 302 }
 303
 304 func (m *BoolValue) Reset()         { *m = BoolValue{} }
 305 func (m *BoolValue) String() string { return proto.CompactTextString(m) }
 306 func (*BoolValue) ProtoMessage()    {}
 307 func (*BoolValue) Descriptor() ([]byte, []int) {
 308         return fileDescriptor_5377b62bda767935, []int{6}
 309 }
 310
 311 func (*BoolValue) XXX_WellKnownType() string { return "BoolValue" }
 312
 313 func (m *BoolValue) XXX_Unmarshal(b []byte) error {
 314         return xxx_messageInfo_BoolValue.Unmarshal(m, b)
 315 }
 316 func (m *BoolValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 317         return xxx_messageInfo_BoolValue.Marshal(b, m, deterministic)
 318 }
 319 func (m *BoolValue) XXX_Merge(src proto.Message) {
 320         xxx_messageInfo_BoolValue.Merge(m, src)
 321 }
 322 func (m *BoolValue) XXX_Size() int {
 323         return xxx_messageInfo_BoolValue.Size(m)
 324 }
 325 func (m *BoolValue) XXX_DiscardUnknown() {
 326         xxx_messageInfo_BoolValue.DiscardUnknown(m)
 327 }
 328
 329 var xxx_messageInfo_BoolValue proto.InternalMessageInfo
 330
 331 func (m *BoolValue) GetValue() bool {
 332         if m != nil {
 333                 return m.Value
 334         }
 335         return false
 336 }
 337
 338 // Wrapper message for `string`.
 339 //
 340 // The JSON representation for `StringValue` is JSON string.
 341 type StringValue struct {
 342         // The string value.
 343         Value                string   `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
 344         XXX_NoUnkeyedLiteral struct{} `json:"-"`
 345         XXX_unrecognized     []byte   `json:"-"`
 346         XXX_sizecache        int32    `json:"-"`
 347 }
 348
 349 func (m *StringValue) Reset()         { *m = StringValue{} }
 350 func (m *StringValue) String() string { return proto.CompactTextString(m) }
 351 func (*StringValue) ProtoMessage()    {}
 352 func (*StringValue) Descriptor() ([]byte, []int) {
 353         return fileDescriptor_5377b62bda767935, []int{7}
 354 }
 355
 356 func (*StringValue) XXX_WellKnownType() string { return "StringValue" }
 357
 358 func (m *StringValue) XXX_Unmarshal(b []byte) error {
 359         return xxx_messageInfo_StringValue.Unmarshal(m, b)
 360 }
 361 func (m *StringValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 362         return xxx_messageInfo_StringValue.Marshal(b, m, deterministic)
 363 }
 364 func (m *StringValue) XXX_Merge(src proto.Message) {
 365         xxx_messageInfo_StringValue.Merge(m, src)
 366 }
 367 func (m *StringValue) XXX_Size() int {
 368         return xxx_messageInfo_StringValue.Size(m)
 369 }
 370 func (m *StringValue) XXX_DiscardUnknown() {
 371         xxx_messageInfo_StringValue.DiscardUnknown(m)
 372 }
 373
 374 var xxx_messageInfo_StringValue proto.InternalMessageInfo
 375
 376 func (m *StringValue) GetValue() string {
 377         if m != nil {
 378                 return m.Value
 379         }
 380         return ""
 381 }
 382
 383 // Wrapper message for `bytes`.
 384 //
 385 // The JSON representation for `BytesValue` is JSON string.
 386 type BytesValue struct {
 387         // The bytes value.
 388         Value                []byte   `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
 389         XXX_NoUnkeyedLiteral struct{} `json:"-"`
 390         XXX_unrecognized     []byte   `json:"-"`
 391         XXX_sizecache        int32    `json:"-"`
 392 }
 393
 394 func (m *BytesValue) Reset()         { *m = BytesValue{} }
 395 func (m *BytesValue) String() string { return proto.CompactTextString(m) }
 396 func (*BytesValue) ProtoMessage()    {}
 397 func (*BytesValue) Descriptor() ([]byte, []int) {
 398         return fileDescriptor_5377b62bda767935, []int{8}
 399 }
 400
 401 func (*BytesValue) XXX_WellKnownType() string { return "BytesValue" }
 402
 403 func (m *BytesValue) XXX_Unmarshal(b []byte) error {
 404         return xxx_messageInfo_BytesValue.Unmarshal(m, b)
 405 }
 406 func (m *BytesValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 407         return xxx_messageInfo_BytesValue.Marshal(b, m, deterministic)
 408 }
 409 func (m *BytesValue) XXX_Merge(src proto.Message) {
 410         xxx_messageInfo_BytesValue.Merge(m, src)
 411 }
 412 func (m *BytesValue) XXX_Size() int {
 413         return xxx_messageInfo_BytesValue.Size(m)
 414 }
 415 func (m *BytesValue) XXX_DiscardUnknown() {
 416         xxx_messageInfo_BytesValue.DiscardUnknown(m)
 417 }
 418
 419 var xxx_messageInfo_BytesValue proto.InternalMessageInfo
 420
 421 func (m *BytesValue) GetValue() []byte {
 422         if m != nil {
 423                 return m.Value
 424         }
 425         return nil
 426 }
 427
 428 func init() {
 429         proto.RegisterType((*DoubleValue)(nil), "google.protobuf.DoubleValue")
 430         proto.RegisterType((*FloatValue)(nil), "google.protobuf.FloatValue")
 431         proto.RegisterType((*Int64Value)(nil), "google.protobuf.Int64Value")
 432         proto.RegisterType((*UInt64Value)(nil), "google.protobuf.UInt64Value")
 433         proto.RegisterType((*Int32Value)(nil), "google.protobuf.Int32Value")
 434         proto.RegisterType((*UInt32Value)(nil), "google.protobuf.UInt32Value")
 435         proto.RegisterType((*BoolValue)(nil), "google.protobuf.BoolValue")
 436         proto.RegisterType((*StringValue)(nil), "google.protobuf.StringValue")
 437         proto.RegisterType((*BytesValue)(nil), "google.protobuf.BytesValue")
 438 }
 439
 440 func init() { proto.RegisterFile("google/protobuf/wrappers.proto", fileDescriptor_5377b62bda767935) }
 441
 442 var fileDescriptor_5377b62bda767935 = []byte{
 443         // 259 bytes of a gzipped FileDescriptorProto
 444         0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4b, 0xcf, 0xcf, 0x4f,
 445         0xcf, 0x49, 0xd5, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x2f, 0x2f, 0x4a, 0x2c,
 446         0x28, 0x48, 0x2d, 0x2a, 0xd6, 0x03, 0x8b, 0x08, 0xf1, 0x43, 0xe4, 0xf5, 0x60, 0xf2, 0x4a, 0xca,
 447         0x5c, 0xdc, 0x2e, 0xf9, 0xa5, 0x49, 0x39, 0xa9, 0x61, 0x89, 0x39, 0xa5, 0xa9, 0x42, 0x22, 0x5c,
 448         0xac, 0x65, 0x20, 0x86, 0x04, 0xa3, 0x02, 0xa3, 0x06, 0x63, 0x10, 0x84, 0xa3, 0xa4, 0xc4, 0xc5,
 449         0xe5, 0x96, 0x93, 0x9f, 0x58, 0x82, 0x45, 0x0d, 0x13, 0x92, 0x1a, 0xcf, 0xbc, 0x12, 0x33, 0x13,
 450         0x2c, 0x6a, 0x98, 0x61, 0x6a, 0x94, 0xb9, 0xb8, 0x43, 0x71, 0x29, 0x62, 0x41, 0x35, 0xc8, 0xd8,
 451         0x08, 0x8b, 0x1a, 0x56, 0x34, 0x83, 0xb0, 0x2a, 0xe2, 0x85, 0x29, 0x52, 0xe4, 0xe2, 0x74, 0xca,
 452         0xcf, 0xcf, 0xc1, 0xa2, 0x84, 0x03, 0xc9, 0x9c, 0xe0, 0x92, 0xa2, 0xcc, 0xbc, 0x74, 0x2c, 0x8a,
 453         0x38, 0x91, 0x1c, 0xe4, 0x54, 0x59, 0x92, 0x5a, 0x8c, 0x45, 0x0d, 0x0f, 0x54, 0x8d, 0x53, 0x0d,
 454         0x97, 0x70, 0x72, 0x7e, 0xae, 0x1e, 0x5a, 0xe8, 0x3a, 0xf1, 0x86, 0x43, 0x83, 0x3f, 0x00, 0x24,
 455         0x12, 0xc0, 0x18, 0xa5, 0x95, 0x9e, 0x59, 0x92, 0x51, 0x9a, 0xa4, 0x97, 0x9c, 0x9f, 0xab, 0x9f,
 456         0x9e, 0x9f, 0x93, 0x98, 0x97, 0x8e, 0x88, 0xaa, 0x82, 0x92, 0xca, 0x82, 0xd4, 0x62, 0x78, 0x8c,
 457         0xfd, 0x60, 0x64, 0x5c, 0xc4, 0xc4, 0xec, 0x1e, 0xe0, 0xb4, 0x8a, 0x49, 0xce, 0x1d, 0x62, 0x6e,
 458         0x00, 0x54, 0xa9, 0x5e, 0x78, 0x6a, 0x4e, 0x8e, 0x77, 0x5e, 0x7e, 0x79, 0x5e, 0x08, 0x48, 0x4b,
 459         0x12, 0x1b, 0xd8, 0x0c, 0x63, 0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0x19, 0x6c, 0xb9, 0xb8, 0xfe,
 460         0x01, 0x00, 0x00,
 461 }