1// Code generated by protoc-gen-gogo. DO NOT EDIT. 2// source: google/protobuf/empty.proto 3 4package types 5 6import ( 7 bytes "bytes" 8 fmt "fmt" 9 proto "github.com/gogo/protobuf/proto" 10 io "io" 11 math "math" 12 math_bits "math/bits" 13 reflect "reflect" 14 strings "strings" 15) 16 17// Reference imports to suppress errors if they are not otherwise used. 18var _ = proto.Marshal 19var _ = fmt.Errorf 20var _ = math.Inf 21 22// This is a compile-time assertion to ensure that this generated file 23// is compatible with the proto package it is being compiled against. 24// A compilation error at this line likely means your copy of the 25// proto package needs to be updated. 26const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package 27 28// A generic empty message that you can re-use to avoid defining duplicated 29// empty messages in your APIs. A typical example is to use it as the request 30// or the response type of an API method. For instance: 31// 32// service Foo { 33// rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty); 34// } 35// 36// The JSON representation for `Empty` is empty JSON object `{}`. 37type Empty struct { 38 XXX_NoUnkeyedLiteral struct{} `json:"-"` 39 XXX_unrecognized []byte `json:"-"` 40 XXX_sizecache int32 `json:"-"` 41} 42 43func (m *Empty) Reset() { *m = Empty{} } 44func (*Empty) ProtoMessage() {} 45func (*Empty) Descriptor() ([]byte, []int) { 46 return fileDescriptor_900544acb223d5b8, []int{0} 47} 48func (*Empty) XXX_WellKnownType() string { return "Empty" } 49func (m *Empty) XXX_Unmarshal(b []byte) error { 50 return m.Unmarshal(b) 51} 52func (m *Empty) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 53 if deterministic { 54 return xxx_messageInfo_Empty.Marshal(b, m, deterministic) 55 } else { 56 b = b[:cap(b)] 57 n, err := m.MarshalToSizedBuffer(b) 58 if err != nil { 59 return nil, err 60 } 61 return b[:n], nil 62 } 63} 64func (m *Empty) XXX_Merge(src proto.Message) { 65 xxx_messageInfo_Empty.Merge(m, src) 66} 67func (m *Empty) XXX_Size() int { 68 return m.Size() 69} 70func (m *Empty) XXX_DiscardUnknown() { 71 xxx_messageInfo_Empty.DiscardUnknown(m) 72} 73 74var xxx_messageInfo_Empty proto.InternalMessageInfo 75 76func (*Empty) XXX_MessageName() string { 77 return "google.protobuf.Empty" 78} 79func init() { 80 proto.RegisterType((*Empty)(nil), "google.protobuf.Empty") 81} 82 83func init() { proto.RegisterFile("google/protobuf/empty.proto", fileDescriptor_900544acb223d5b8) } 84 85var fileDescriptor_900544acb223d5b8 = []byte{ 86 // 176 bytes of a gzipped FileDescriptorProto 87 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4e, 0xcf, 0xcf, 0x4f, 88 0xcf, 0x49, 0xd5, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x4f, 0xcd, 0x2d, 0x28, 89 0xa9, 0xd4, 0x03, 0x73, 0x85, 0xf8, 0x21, 0x92, 0x7a, 0x30, 0x49, 0x25, 0x76, 0x2e, 0x56, 0x57, 90 0x90, 0xbc, 0x53, 0x0b, 0xe3, 0x8d, 0x87, 0x72, 0x0c, 0x1f, 0x1e, 0xca, 0x31, 0xfe, 0x78, 0x28, 91 0xc7, 0xd8, 0xf0, 0x48, 0x8e, 0x71, 0xc5, 0x23, 0x39, 0xc6, 0x13, 0x8f, 0xe4, 0x18, 0x2f, 0x3c, 92 0x92, 0x63, 0x7c, 0xf0, 0x48, 0x8e, 0xf1, 0xc5, 0x23, 0x39, 0x86, 0x0f, 0x20, 0xf1, 0xc7, 0x72, 93 0x8c, 0x27, 0x1e, 0xcb, 0x31, 0x72, 0x09, 0x27, 0xe7, 0xe7, 0xea, 0xa1, 0x19, 0xe8, 0xc4, 0x05, 94 0x36, 0x2e, 0x00, 0xc4, 0x0d, 0x60, 0x8c, 0x62, 0x2d, 0xa9, 0x2c, 0x48, 0x2d, 0xfe, 0xc1, 0xc8, 95 0xb8, 0x88, 0x89, 0xd9, 0x3d, 0xc0, 0x69, 0x15, 0x93, 0x9c, 0x3b, 0x44, 0x7d, 0x00, 0x54, 0xbd, 96 0x5e, 0x78, 0x6a, 0x4e, 0x8e, 0x77, 0x5e, 0x7e, 0x79, 0x5e, 0x08, 0x48, 0x65, 0x12, 0x1b, 0xd8, 97 0x20, 0x63, 0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0x21, 0xbe, 0xb6, 0x31, 0xc6, 0x00, 0x00, 0x00, 98} 99 100func (this *Empty) Compare(that interface{}) int { 101 if that == nil { 102 if this == nil { 103 return 0 104 } 105 return 1 106 } 107 108 that1, ok := that.(*Empty) 109 if !ok { 110 that2, ok := that.(Empty) 111 if ok { 112 that1 = &that2 113 } else { 114 return 1 115 } 116 } 117 if that1 == nil { 118 if this == nil { 119 return 0 120 } 121 return 1 122 } else if this == nil { 123 return -1 124 } 125 if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 { 126 return c 127 } 128 return 0 129} 130func (this *Empty) Equal(that interface{}) bool { 131 if that == nil { 132 return this == nil 133 } 134 135 that1, ok := that.(*Empty) 136 if !ok { 137 that2, ok := that.(Empty) 138 if ok { 139 that1 = &that2 140 } else { 141 return false 142 } 143 } 144 if that1 == nil { 145 return this == nil 146 } else if this == nil { 147 return false 148 } 149 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 150 return false 151 } 152 return true 153} 154func (this *Empty) GoString() string { 155 if this == nil { 156 return "nil" 157 } 158 s := make([]string, 0, 4) 159 s = append(s, "&types.Empty{") 160 if this.XXX_unrecognized != nil { 161 s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") 162 } 163 s = append(s, "}") 164 return strings.Join(s, "") 165} 166func valueToGoStringEmpty(v interface{}, typ string) string { 167 rv := reflect.ValueOf(v) 168 if rv.IsNil() { 169 return "nil" 170 } 171 pv := reflect.Indirect(rv).Interface() 172 return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) 173} 174func (m *Empty) Marshal() (dAtA []byte, err error) { 175 size := m.Size() 176 dAtA = make([]byte, size) 177 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 178 if err != nil { 179 return nil, err 180 } 181 return dAtA[:n], nil 182} 183 184func (m *Empty) MarshalTo(dAtA []byte) (int, error) { 185 size := m.Size() 186 return m.MarshalToSizedBuffer(dAtA[:size]) 187} 188 189func (m *Empty) MarshalToSizedBuffer(dAtA []byte) (int, error) { 190 i := len(dAtA) 191 _ = i 192 var l int 193 _ = l 194 if m.XXX_unrecognized != nil { 195 i -= len(m.XXX_unrecognized) 196 copy(dAtA[i:], m.XXX_unrecognized) 197 } 198 return len(dAtA) - i, nil 199} 200 201func encodeVarintEmpty(dAtA []byte, offset int, v uint64) int { 202 offset -= sovEmpty(v) 203 base := offset 204 for v >= 1<<7 { 205 dAtA[offset] = uint8(v&0x7f | 0x80) 206 v >>= 7 207 offset++ 208 } 209 dAtA[offset] = uint8(v) 210 return base 211} 212func NewPopulatedEmpty(r randyEmpty, easy bool) *Empty { 213 this := &Empty{} 214 if !easy && r.Intn(10) != 0 { 215 this.XXX_unrecognized = randUnrecognizedEmpty(r, 1) 216 } 217 return this 218} 219 220type randyEmpty interface { 221 Float32() float32 222 Float64() float64 223 Int63() int64 224 Int31() int32 225 Uint32() uint32 226 Intn(n int) int 227} 228 229func randUTF8RuneEmpty(r randyEmpty) rune { 230 ru := r.Intn(62) 231 if ru < 10 { 232 return rune(ru + 48) 233 } else if ru < 36 { 234 return rune(ru + 55) 235 } 236 return rune(ru + 61) 237} 238func randStringEmpty(r randyEmpty) string { 239 v1 := r.Intn(100) 240 tmps := make([]rune, v1) 241 for i := 0; i < v1; i++ { 242 tmps[i] = randUTF8RuneEmpty(r) 243 } 244 return string(tmps) 245} 246func randUnrecognizedEmpty(r randyEmpty, maxFieldNumber int) (dAtA []byte) { 247 l := r.Intn(5) 248 for i := 0; i < l; i++ { 249 wire := r.Intn(4) 250 if wire == 3 { 251 wire = 5 252 } 253 fieldNumber := maxFieldNumber + r.Intn(100) 254 dAtA = randFieldEmpty(dAtA, r, fieldNumber, wire) 255 } 256 return dAtA 257} 258func randFieldEmpty(dAtA []byte, r randyEmpty, fieldNumber int, wire int) []byte { 259 key := uint32(fieldNumber)<<3 | uint32(wire) 260 switch wire { 261 case 0: 262 dAtA = encodeVarintPopulateEmpty(dAtA, uint64(key)) 263 v2 := r.Int63() 264 if r.Intn(2) == 0 { 265 v2 *= -1 266 } 267 dAtA = encodeVarintPopulateEmpty(dAtA, uint64(v2)) 268 case 1: 269 dAtA = encodeVarintPopulateEmpty(dAtA, uint64(key)) 270 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))) 271 case 2: 272 dAtA = encodeVarintPopulateEmpty(dAtA, uint64(key)) 273 ll := r.Intn(100) 274 dAtA = encodeVarintPopulateEmpty(dAtA, uint64(ll)) 275 for j := 0; j < ll; j++ { 276 dAtA = append(dAtA, byte(r.Intn(256))) 277 } 278 default: 279 dAtA = encodeVarintPopulateEmpty(dAtA, uint64(key)) 280 dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) 281 } 282 return dAtA 283} 284func encodeVarintPopulateEmpty(dAtA []byte, v uint64) []byte { 285 for v >= 1<<7 { 286 dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80)) 287 v >>= 7 288 } 289 dAtA = append(dAtA, uint8(v)) 290 return dAtA 291} 292func (m *Empty) Size() (n int) { 293 if m == nil { 294 return 0 295 } 296 var l int 297 _ = l 298 if m.XXX_unrecognized != nil { 299 n += len(m.XXX_unrecognized) 300 } 301 return n 302} 303 304func sovEmpty(x uint64) (n int) { 305 return (math_bits.Len64(x|1) + 6) / 7 306} 307func sozEmpty(x uint64) (n int) { 308 return sovEmpty(uint64((x << 1) ^ uint64((int64(x) >> 63)))) 309} 310func (this *Empty) String() string { 311 if this == nil { 312 return "nil" 313 } 314 s := strings.Join([]string{`&Empty{`, 315 `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, 316 `}`, 317 }, "") 318 return s 319} 320func valueToStringEmpty(v interface{}) string { 321 rv := reflect.ValueOf(v) 322 if rv.IsNil() { 323 return "nil" 324 } 325 pv := reflect.Indirect(rv).Interface() 326 return fmt.Sprintf("*%v", pv) 327} 328func (m *Empty) Unmarshal(dAtA []byte) error { 329 l := len(dAtA) 330 iNdEx := 0 331 for iNdEx < l { 332 preIndex := iNdEx 333 var wire uint64 334 for shift := uint(0); ; shift += 7 { 335 if shift >= 64 { 336 return ErrIntOverflowEmpty 337 } 338 if iNdEx >= l { 339 return io.ErrUnexpectedEOF 340 } 341 b := dAtA[iNdEx] 342 iNdEx++ 343 wire |= uint64(b&0x7F) << shift 344 if b < 0x80 { 345 break 346 } 347 } 348 fieldNum := int32(wire >> 3) 349 wireType := int(wire & 0x7) 350 if wireType == 4 { 351 return fmt.Errorf("proto: Empty: wiretype end group for non-group") 352 } 353 if fieldNum <= 0 { 354 return fmt.Errorf("proto: Empty: illegal tag %d (wire type %d)", fieldNum, wire) 355 } 356 switch fieldNum { 357 default: 358 iNdEx = preIndex 359 skippy, err := skipEmpty(dAtA[iNdEx:]) 360 if err != nil { 361 return err 362 } 363 if (skippy < 0) || (iNdEx+skippy) < 0 { 364 return ErrInvalidLengthEmpty 365 } 366 if (iNdEx + skippy) > l { 367 return io.ErrUnexpectedEOF 368 } 369 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 370 iNdEx += skippy 371 } 372 } 373 374 if iNdEx > l { 375 return io.ErrUnexpectedEOF 376 } 377 return nil 378} 379func skipEmpty(dAtA []byte) (n int, err error) { 380 l := len(dAtA) 381 iNdEx := 0 382 depth := 0 383 for iNdEx < l { 384 var wire uint64 385 for shift := uint(0); ; shift += 7 { 386 if shift >= 64 { 387 return 0, ErrIntOverflowEmpty 388 } 389 if iNdEx >= l { 390 return 0, io.ErrUnexpectedEOF 391 } 392 b := dAtA[iNdEx] 393 iNdEx++ 394 wire |= (uint64(b) & 0x7F) << shift 395 if b < 0x80 { 396 break 397 } 398 } 399 wireType := int(wire & 0x7) 400 switch wireType { 401 case 0: 402 for shift := uint(0); ; shift += 7 { 403 if shift >= 64 { 404 return 0, ErrIntOverflowEmpty 405 } 406 if iNdEx >= l { 407 return 0, io.ErrUnexpectedEOF 408 } 409 iNdEx++ 410 if dAtA[iNdEx-1] < 0x80 { 411 break 412 } 413 } 414 case 1: 415 iNdEx += 8 416 case 2: 417 var length int 418 for shift := uint(0); ; shift += 7 { 419 if shift >= 64 { 420 return 0, ErrIntOverflowEmpty 421 } 422 if iNdEx >= l { 423 return 0, io.ErrUnexpectedEOF 424 } 425 b := dAtA[iNdEx] 426 iNdEx++ 427 length |= (int(b) & 0x7F) << shift 428 if b < 0x80 { 429 break 430 } 431 } 432 if length < 0 { 433 return 0, ErrInvalidLengthEmpty 434 } 435 iNdEx += length 436 case 3: 437 depth++ 438 case 4: 439 if depth == 0 { 440 return 0, ErrUnexpectedEndOfGroupEmpty 441 } 442 depth-- 443 case 5: 444 iNdEx += 4 445 default: 446 return 0, fmt.Errorf("proto: illegal wireType %d", wireType) 447 } 448 if iNdEx < 0 { 449 return 0, ErrInvalidLengthEmpty 450 } 451 if depth == 0 { 452 return iNdEx, nil 453 } 454 } 455 return 0, io.ErrUnexpectedEOF 456} 457 458var ( 459 ErrInvalidLengthEmpty = fmt.Errorf("proto: negative length found during unmarshaling") 460 ErrIntOverflowEmpty = fmt.Errorf("proto: integer overflow") 461 ErrUnexpectedEndOfGroupEmpty = fmt.Errorf("proto: unexpected end of group") 462) 463