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

   1 // Code generated by protoc-gen-go. DO NOT EDIT.
   2 // source: google/protobuf/struct.proto
   3
   4 /*
   5 Package structpb is a generated protocol buffer package.
   6
   7 It is generated from these files:
   8         google/protobuf/struct.proto
   9
  10 It has these top-level messages:
  11         Struct
  12         Value
  13         ListValue
  14 */
  15 package structpb
  16
  17 import proto "github.com/golang/protobuf/proto"
  18 import fmt "fmt"
  19 import math "math"
  20
  21 // Reference imports to suppress errors if they are not otherwise used.
  22 var _ = proto.Marshal
  23 var _ = fmt.Errorf
  24 var _ = math.Inf
  25
  26 // This is a compile-time assertion to ensure that this generated file
  27 // is compatible with the proto package it is being compiled against.
  28 // A compilation error at this line likely means your copy of the
  29 // proto package needs to be updated.
  30 const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
  31
  32 // `NullValue` is a singleton enumeration to represent the null value for the
  33 // `Value` type union.
  34 //
  35 //  The JSON representation for `NullValue` is JSON `null`.
  36 type NullValue int32
  37
  38 const (
  39         // Null value.
  40         NullValue_NULL_VALUE NullValue = 0
  41 )
  42
  43 var NullValue_name = map[int32]string{
  44         0: "NULL_VALUE",
  45 }
  46 var NullValue_value = map[string]int32{
  47         "NULL_VALUE": 0,
  48 }
  49
  50 func (x NullValue) String() string {
  51         return proto.EnumName(NullValue_name, int32(x))
  52 }
  53 func (NullValue) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
  54 func (NullValue) XXX_WellKnownType() string       { return "NullValue" }
  55
  56 // `Struct` represents a structured data value, consisting of fields
  57 // which map to dynamically typed values. In some languages, `Struct`
  58 // might be supported by a native representation. For example, in
  59 // scripting languages like JS a struct is represented as an
  60 // object. The details of that representation are described together
  61 // with the proto support for the language.
  62 //
  63 // The JSON representation for `Struct` is JSON object.
  64 type Struct struct {
  65         // Unordered map of dynamically typed values.
  66         Fields map[string]*Value `protobuf:"bytes,1,rep,name=fields" json:"fields,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
  67 }
  68
  69 func (m *Struct) Reset()                    { *m = Struct{} }
  70 func (m *Struct) String() string            { return proto.CompactTextString(m) }
  71 func (*Struct) ProtoMessage()               {}
  72 func (*Struct) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
  73 func (*Struct) XXX_WellKnownType() string   { return "Struct" }
  74
  75 func (m *Struct) GetFields() map[string]*Value {
  76         if m != nil {
  77                 return m.Fields
  78         }
  79         return nil
  80 }
  81
  82 // `Value` represents a dynamically typed value which can be either
  83 // null, a number, a string, a boolean, a recursive struct value, or a
  84 // list of values. A producer of value is expected to set one of that
  85 // variants, absence of any variant indicates an error.
  86 //
  87 // The JSON representation for `Value` is JSON value.
  88 type Value struct {
  89         // The kind of value.
  90         //
  91         // Types that are valid to be assigned to Kind:
  92         //      *Value_NullValue
  93         //      *Value_NumberValue
  94         //      *Value_StringValue
  95         //      *Value_BoolValue
  96         //      *Value_StructValue
  97         //      *Value_ListValue
  98         Kind isValue_Kind `protobuf_oneof:"kind"`
  99 }
 100
 101 func (m *Value) Reset()                    { *m = Value{} }
 102 func (m *Value) String() string            { return proto.CompactTextString(m) }
 103 func (*Value) ProtoMessage()               {}
 104 func (*Value) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
 105 func (*Value) XXX_WellKnownType() string   { return "Value" }
 106
 107 type isValue_Kind interface {
 108         isValue_Kind()
 109 }
 110
 111 type Value_NullValue struct {
 112         NullValue NullValue `protobuf:"varint,1,opt,name=null_value,json=nullValue,enum=google.protobuf.NullValue,oneof"`
 113 }
 114 type Value_NumberValue struct {
 115         NumberValue float64 `protobuf:"fixed64,2,opt,name=number_value,json=numberValue,oneof"`
 116 }
 117 type Value_StringValue struct {
 118         StringValue string `protobuf:"bytes,3,opt,name=string_value,json=stringValue,oneof"`
 119 }
 120 type Value_BoolValue struct {
 121         BoolValue bool `protobuf:"varint,4,opt,name=bool_value,json=boolValue,oneof"`
 122 }
 123 type Value_StructValue struct {
 124         StructValue *Struct `protobuf:"bytes,5,opt,name=struct_value,json=structValue,oneof"`
 125 }
 126 type Value_ListValue struct {
 127         ListValue *ListValue `protobuf:"bytes,6,opt,name=list_value,json=listValue,oneof"`
 128 }
 129
 130 func (*Value_NullValue) isValue_Kind()   {}
 131 func (*Value_NumberValue) isValue_Kind() {}
 132 func (*Value_StringValue) isValue_Kind() {}
 133 func (*Value_BoolValue) isValue_Kind()   {}
 134 func (*Value_StructValue) isValue_Kind() {}
 135 func (*Value_ListValue) isValue_Kind()   {}
 136
 137 func (m *Value) GetKind() isValue_Kind {
 138         if m != nil {
 139                 return m.Kind
 140         }
 141         return nil
 142 }
 143
 144 func (m *Value) GetNullValue() NullValue {
 145         if x, ok := m.GetKind().(*Value_NullValue); ok {
 146                 return x.NullValue
 147         }
 148         return NullValue_NULL_VALUE
 149 }
 150
 151 func (m *Value) GetNumberValue() float64 {
 152         if x, ok := m.GetKind().(*Value_NumberValue); ok {
 153                 return x.NumberValue
 154         }
 155         return 0
 156 }
 157
 158 func (m *Value) GetStringValue() string {
 159         if x, ok := m.GetKind().(*Value_StringValue); ok {
 160                 return x.StringValue
 161         }
 162         return ""
 163 }
 164
 165 func (m *Value) GetBoolValue() bool {
 166         if x, ok := m.GetKind().(*Value_BoolValue); ok {
 167                 return x.BoolValue
 168         }
 169         return false
 170 }
 171
 172 func (m *Value) GetStructValue() *Struct {
 173         if x, ok := m.GetKind().(*Value_StructValue); ok {
 174                 return x.StructValue
 175         }
 176         return nil
 177 }
 178
 179 func (m *Value) GetListValue() *ListValue {
 180         if x, ok := m.GetKind().(*Value_ListValue); ok {
 181                 return x.ListValue
 182         }
 183         return nil
 184 }
 185
 186 // XXX_OneofFuncs is for the internal use of the proto package.
 187 func (*Value) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
 188         return _Value_OneofMarshaler, _Value_OneofUnmarshaler, _Value_OneofSizer, []interface{}{
 189                 (*Value_NullValue)(nil),
 190                 (*Value_NumberValue)(nil),
 191                 (*Value_StringValue)(nil),
 192                 (*Value_BoolValue)(nil),
 193                 (*Value_StructValue)(nil),
 194                 (*Value_ListValue)(nil),
 195         }
 196 }
 197
 198 func _Value_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
 199         m := msg.(*Value)
 200         // kind
 201         switch x := m.Kind.(type) {
 202         case *Value_NullValue:
 203                 b.EncodeVarint(1<<3 | proto.WireVarint)
 204                 b.EncodeVarint(uint64(x.NullValue))
 205         case *Value_NumberValue:
 206                 b.EncodeVarint(2<<3 | proto.WireFixed64)
 207                 b.EncodeFixed64(math.Float64bits(x.NumberValue))
 208         case *Value_StringValue:
 209                 b.EncodeVarint(3<<3 | proto.WireBytes)
 210                 b.EncodeStringBytes(x.StringValue)
 211         case *Value_BoolValue:
 212                 t := uint64(0)
 213                 if x.BoolValue {
 214                         t = 1
 215                 }
 216                 b.EncodeVarint(4<<3 | proto.WireVarint)
 217                 b.EncodeVarint(t)
 218         case *Value_StructValue:
 219                 b.EncodeVarint(5<<3 | proto.WireBytes)
 220                 if err := b.EncodeMessage(x.StructValue); err != nil {
 221                         return err
 222                 }
 223         case *Value_ListValue:
 224                 b.EncodeVarint(6<<3 | proto.WireBytes)
 225                 if err := b.EncodeMessage(x.ListValue); err != nil {
 226                         return err
 227                 }
 228         case nil:
 229         default:
 230                 return fmt.Errorf("Value.Kind has unexpected type %T", x)
 231         }
 232         return nil
 233 }
 234
 235 func _Value_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
 236         m := msg.(*Value)
 237         switch tag {
 238         case 1: // kind.null_value
 239                 if wire != proto.WireVarint {
 240                         return true, proto.ErrInternalBadWireType
 241                 }
 242                 x, err := b.DecodeVarint()
 243                 m.Kind = &Value_NullValue{NullValue(x)}
 244                 return true, err
 245         case 2: // kind.number_value
 246                 if wire != proto.WireFixed64 {
 247                         return true, proto.ErrInternalBadWireType
 248                 }
 249                 x, err := b.DecodeFixed64()
 250                 m.Kind = &Value_NumberValue{math.Float64frombits(x)}
 251                 return true, err
 252         case 3: // kind.string_value
 253                 if wire != proto.WireBytes {
 254                         return true, proto.ErrInternalBadWireType
 255                 }
 256                 x, err := b.DecodeStringBytes()
 257                 m.Kind = &Value_StringValue{x}
 258                 return true, err
 259         case 4: // kind.bool_value
 260                 if wire != proto.WireVarint {
 261                         return true, proto.ErrInternalBadWireType
 262                 }
 263                 x, err := b.DecodeVarint()
 264                 m.Kind = &Value_BoolValue{x != 0}
 265                 return true, err
 266         case 5: // kind.struct_value
 267                 if wire != proto.WireBytes {
 268                         return true, proto.ErrInternalBadWireType
 269                 }
 270                 msg := new(Struct)
 271                 err := b.DecodeMessage(msg)
 272                 m.Kind = &Value_StructValue{msg}
 273                 return true, err
 274         case 6: // kind.list_value
 275                 if wire != proto.WireBytes {
 276                         return true, proto.ErrInternalBadWireType
 277                 }
 278                 msg := new(ListValue)
 279                 err := b.DecodeMessage(msg)
 280                 m.Kind = &Value_ListValue{msg}
 281                 return true, err
 282         default:
 283                 return false, nil
 284         }
 285 }
 286
 287 func _Value_OneofSizer(msg proto.Message) (n int) {
 288         m := msg.(*Value)
 289         // kind
 290         switch x := m.Kind.(type) {
 291         case *Value_NullValue:
 292                 n += proto.SizeVarint(1<<3 | proto.WireVarint)
 293                 n += proto.SizeVarint(uint64(x.NullValue))
 294         case *Value_NumberValue:
 295                 n += proto.SizeVarint(2<<3 | proto.WireFixed64)
 296                 n += 8
 297         case *Value_StringValue:
 298                 n += proto.SizeVarint(3<<3 | proto.WireBytes)
 299                 n += proto.SizeVarint(uint64(len(x.StringValue)))
 300                 n += len(x.StringValue)
 301         case *Value_BoolValue:
 302                 n += proto.SizeVarint(4<<3 | proto.WireVarint)
 303                 n += 1
 304         case *Value_StructValue:
 305                 s := proto.Size(x.StructValue)
 306                 n += proto.SizeVarint(5<<3 | proto.WireBytes)
 307                 n += proto.SizeVarint(uint64(s))
 308                 n += s
 309         case *Value_ListValue:
 310                 s := proto.Size(x.ListValue)
 311                 n += proto.SizeVarint(6<<3 | proto.WireBytes)
 312                 n += proto.SizeVarint(uint64(s))
 313                 n += s
 314         case nil:
 315         default:
 316                 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
 317         }
 318         return n
 319 }
 320
 321 // `ListValue` is a wrapper around a repeated field of values.
 322 //
 323 // The JSON representation for `ListValue` is JSON array.
 324 type ListValue struct {
 325         // Repeated field of dynamically typed values.
 326         Values []*Value `protobuf:"bytes,1,rep,name=values" json:"values,omitempty"`
 327 }
 328
 329 func (m *ListValue) Reset()                    { *m = ListValue{} }
 330 func (m *ListValue) String() string            { return proto.CompactTextString(m) }
 331 func (*ListValue) ProtoMessage()               {}
 332 func (*ListValue) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
 333 func (*ListValue) XXX_WellKnownType() string   { return "ListValue" }
 334
 335 func (m *ListValue) GetValues() []*Value {
 336         if m != nil {
 337                 return m.Values
 338         }
 339         return nil
 340 }
 341
 342 func init() {
 343         proto.RegisterType((*Struct)(nil), "google.protobuf.Struct")
 344         proto.RegisterType((*Value)(nil), "google.protobuf.Value")
 345         proto.RegisterType((*ListValue)(nil), "google.protobuf.ListValue")
 346         proto.RegisterEnum("google.protobuf.NullValue", NullValue_name, NullValue_value)
 347 }
 348
 349 func init() { proto.RegisterFile("google/protobuf/struct.proto", fileDescriptor0) }
 350
 351 var fileDescriptor0 = []byte{
 352         // 417 bytes of a gzipped FileDescriptorProto
 353         0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x92, 0x41, 0x8b, 0xd3, 0x40,
 354         0x14, 0xc7, 0x3b, 0xc9, 0x36, 0x98, 0x17, 0x59, 0x97, 0x11, 0xb4, 0xac, 0xa2, 0xa1, 0x7b, 0x09,
 355         0x22, 0x29, 0xd6, 0x8b, 0x18, 0x2f, 0x06, 0xd6, 0x5d, 0x30, 0x2c, 0x31, 0xba, 0x15, 0xbc, 0x94,
 356         0x26, 0x4d, 0x63, 0xe8, 0x74, 0x26, 0x24, 0x33, 0x4a, 0x8f, 0x7e, 0x0b, 0xcf, 0x1e, 0x3d, 0xfa,
 357         0xe9, 0x3c, 0xca, 0xcc, 0x24, 0xa9, 0xb4, 0xf4, 0x94, 0xbc, 0xf7, 0x7e, 0xef, 0x3f, 0xef, 0xff,
 358         0x66, 0xe0, 0x71, 0xc1, 0x58, 0x41, 0xf2, 0x49, 0x55, 0x33, 0xce, 0x52, 0xb1, 0x9a, 0x34, 0xbc,
 359         0x16, 0x19, 0xf7, 0x55, 0x8c, 0xef, 0xe9, 0xaa, 0xdf, 0x55, 0xc7, 0x3f, 0x11, 0x58, 0x1f, 0x15,
 360         0x81, 0x03, 0xb0, 0x56, 0x65, 0x4e, 0x96, 0xcd, 0x08, 0xb9, 0xa6, 0xe7, 0x4c, 0x2f, 0xfc, 0x3d,
 361         0xd8, 0xd7, 0xa0, 0xff, 0x4e, 0x51, 0x97, 0x94, 0xd7, 0xdb, 0xa4, 0x6d, 0x39, 0xff, 0x00, 0xce,
 362         0x7f, 0x69, 0x7c, 0x06, 0xe6, 0x3a, 0xdf, 0x8e, 0x90, 0x8b, 0x3c, 0x3b, 0x91, 0xbf, 0xf8, 0x39,
 363         0x0c, 0xbf, 0x2d, 0x88, 0xc8, 0x47, 0x86, 0x8b, 0x3c, 0x67, 0xfa, 0xe0, 0x40, 0x7c, 0x26, 0xab,
 364         0x89, 0x86, 0x5e, 0x1b, 0xaf, 0xd0, 0xf8, 0x8f, 0x01, 0x43, 0x95, 0xc4, 0x01, 0x00, 0x15, 0x84,
 365         0xcc, 0xb5, 0x80, 0x14, 0x3d, 0x9d, 0x9e, 0x1f, 0x08, 0xdc, 0x08, 0x42, 0x14, 0x7f, 0x3d, 0x48,
 366         0x6c, 0xda, 0x05, 0xf8, 0x02, 0xee, 0x52, 0xb1, 0x49, 0xf3, 0x7a, 0xbe, 0x3b, 0x1f, 0x5d, 0x0f,
 367         0x12, 0x47, 0x67, 0x7b, 0xa8, 0xe1, 0x75, 0x49, 0x8b, 0x16, 0x32, 0xe5, 0xe0, 0x12, 0xd2, 0x59,
 368         0x0d, 0x3d, 0x05, 0x48, 0x19, 0xeb, 0xc6, 0x38, 0x71, 0x91, 0x77, 0x47, 0x1e, 0x25, 0x73, 0x1a,
 369         0x78, 0xa3, 0x54, 0x44, 0xc6, 0x5b, 0x64, 0xa8, 0xac, 0x3e, 0x3c, 0xb2, 0xc7, 0x56, 0x5e, 0x64,
 370         0xbc, 0x77, 0x49, 0xca, 0xa6, 0xeb, 0xb5, 0x54, 0xef, 0xa1, 0xcb, 0xa8, 0x6c, 0x78, 0xef, 0x92,
 371         0x74, 0x41, 0x68, 0xc1, 0xc9, 0xba, 0xa4, 0xcb, 0x71, 0x00, 0x76, 0x4f, 0x60, 0x1f, 0x2c, 0x25,
 372         0xd6, 0xdd, 0xe8, 0xb1, 0xa5, 0xb7, 0xd4, 0xb3, 0x47, 0x60, 0xf7, 0x4b, 0xc4, 0xa7, 0x00, 0x37,
 373         0xb7, 0x51, 0x34, 0x9f, 0xbd, 0x8d, 0x6e, 0x2f, 0xcf, 0x06, 0xe1, 0x0f, 0x04, 0xf7, 0x33, 0xb6,
 374         0xd9, 0x97, 0x08, 0x1d, 0xed, 0x26, 0x96, 0x71, 0x8c, 0xbe, 0xbc, 0x28, 0x4a, 0xfe, 0x55, 0xa4,
 375         0x7e, 0xc6, 0x36, 0x93, 0x82, 0x91, 0x05, 0x2d, 0x76, 0x4f, 0xb1, 0xe2, 0xdb, 0x2a, 0x6f, 0xda,
 376         0x17, 0x19, 0xe8, 0x4f, 0x95, 0xfe, 0x45, 0xe8, 0x97, 0x61, 0x5e, 0xc5, 0xe1, 0x6f, 0xe3, 0xc9,
 377         0x95, 0x16, 0x8f, 0xbb, 0xf9, 0x3e, 0xe7, 0x84, 0xbc, 0xa7, 0xec, 0x3b, 0xfd, 0x24, 0x3b, 0x53,
 378         0x4b, 0x49, 0xbd, 0xfc, 0x17, 0x00, 0x00, 0xff, 0xff, 0xe8, 0x1b, 0x59, 0xf8, 0xe5, 0x02, 0x00,
 379         0x00,
 380 }