decode_value.go (9481B)
1 package msgpack 2 3 import ( 4 "fmt" 5 "io" 6 "math" 7 8 "github.com/google/uuid" 9 ) 10 11 type ErrInvalidHeader struct { 12 name string 13 got []byte 14 } 15 16 func (err *ErrInvalidHeader) Error() string { 17 return fmt.Sprintf("msgpack: invalid %s header; got: %v", err.name, err.got) 18 } 19 20 type ErrUnexpectedEOF struct{} 21 22 func (err *ErrUnexpectedEOF) Error() string { 23 return "msgpack: unexpected EOF" 24 } 25 26 func (err *ErrUnexpectedEOF) Unwrap() error { 27 return io.EOF 28 } 29 30 func (d *Decoder) NextIsNil() (bool, error) { 31 if d.length == d.cursor { 32 n, err := d.r.Read(d.buf) 33 if err != nil { 34 return false, err 35 } 36 d.cursor = 0 37 d.length = n 38 } 39 return d.buf[d.cursor] == 0xc0, nil 40 } 41 42 func (d *Decoder) Nil() error { 43 p, err := d.readByte() 44 if err != nil { 45 return err 46 } 47 if p != 0xc0 { 48 return &ErrInvalidHeader{"nil", []byte{p}} 49 } 50 return nil 51 } 52 53 func (d *Decoder) Bool(v *bool) error { 54 p, err := d.readByte() 55 if err != nil { 56 return err 57 } 58 switch p { 59 case 0xc2: 60 *v = true 61 case 0xc3: 62 *v = false 63 default: 64 return &ErrInvalidHeader{"bool", []byte{p}} 65 } 66 return nil 67 } 68 69 func (d *Decoder) Int(v *int) error { 70 sign, err := d.readByte() 71 if err != nil { 72 return err 73 } 74 75 switch sign { 76 case 0xcc: 77 n, err := d.readByte() 78 if err != nil { 79 return err 80 } 81 *v = int(uint8(n)) 82 case 0xcd: 83 n, err := d.deserialize16() 84 if err != nil { 85 return err 86 } 87 *v = int(uint16(n)) 88 case 0xce: 89 n, err := d.deserialize32() 90 if err != nil { 91 return err 92 } 93 *v = int(uint32(n)) 94 case 0xcf: 95 n, err := d.deserialize64() 96 if err != nil { 97 return err 98 } 99 *v = int(uint64(n)) 100 case 0xd0: 101 n, err := d.readByte() 102 if err != nil { 103 return err 104 } 105 *v = int(int8(n)) 106 case 0xd1: 107 n, err := d.deserialize16() 108 if err != nil { 109 return err 110 } 111 *v = int(int16(n)) 112 case 0xd2: 113 n, err := d.deserialize32() 114 if err != nil { 115 return err 116 } 117 *v = int(int32(n)) 118 case 0xd3: 119 n, err := d.deserialize64() 120 if err != nil { 121 return err 122 } 123 *v = int(int64(n)) 124 default: 125 if sign>>7 == 0 || sign>>5 == 7 { 126 *v = int(int8(sign)) 127 return nil 128 } 129 return &ErrInvalidHeader{"int", []byte{sign}} 130 } 131 return nil 132 } 133 134 func (d *Decoder) Int8(v *int8) error { 135 sign, err := d.readByte() 136 if err != nil { 137 return err 138 } 139 if sign != 0xd0 { 140 return &ErrInvalidHeader{"int8", []byte{sign}} 141 } 142 n, err := d.readByte() 143 if err != nil { 144 return err 145 } 146 *v = int8(n) 147 return nil 148 } 149 150 func (d *Decoder) Int16(v *int16) error { 151 sign, err := d.readByte() 152 if err != nil { 153 return err 154 } 155 if sign != 0xd1 { 156 return &ErrInvalidHeader{"int8", []byte{sign}} 157 } 158 n, err := d.deserialize16() 159 if err != nil { 160 return err 161 } 162 *v = int16(n) 163 return nil 164 } 165 166 func (d *Decoder) Int32(v *int32) error { 167 sign, err := d.readByte() 168 if err != nil { 169 return err 170 } 171 if sign != 0xd2 { 172 return &ErrInvalidHeader{"int8", []byte{sign}} 173 } 174 n, err := d.deserialize32() 175 if err != nil { 176 return err 177 } 178 *v = int32(n) 179 return nil 180 } 181 182 func (d *Decoder) Int64(v *int64) error { 183 sign, err := d.readByte() 184 if err != nil { 185 return err 186 } 187 if sign != 0xd3 { 188 return &ErrInvalidHeader{"int8", []byte{sign}} 189 } 190 n, err := d.deserialize64() 191 if err != nil { 192 return err 193 } 194 *v = int64(n) 195 return nil 196 } 197 198 func (d *Decoder) Uint(v *uint) error { 199 sign, err := d.readByte() 200 if err != nil { 201 return err 202 } 203 204 switch sign { 205 case 0xcc: 206 n, err := d.readByte() 207 if err != nil { 208 return err 209 } 210 *v = uint(n) 211 case 0xcd: 212 n, err := d.deserialize16() 213 if err != nil { 214 return err 215 } 216 *v = uint(n) 217 case 0xce: 218 n, err := d.deserialize32() 219 if err != nil { 220 return err 221 } 222 *v = uint(n) 223 case 0xcf: 224 n, err := d.deserialize64() 225 if err != nil { 226 return err 227 } 228 *v = uint(n) 229 default: 230 if sign>>7 == 0 { 231 *v = uint(sign) 232 return nil 233 } 234 return &ErrInvalidHeader{"uint", []byte{sign}} 235 } 236 return nil 237 } 238 239 func (d *Decoder) Uint8(v *uint8) error { 240 sign, err := d.readByte() 241 if err != nil { 242 return err 243 } 244 if sign != 0xcc { 245 return &ErrInvalidHeader{"uint8", []byte{sign}} 246 } 247 n, err := d.readByte() 248 if err != nil { 249 return err 250 } 251 *v = uint8(n) 252 return nil 253 } 254 255 func (d *Decoder) Uint16(v *uint16) error { 256 sign, err := d.readByte() 257 if err != nil { 258 return err 259 } 260 if sign != 0xcd { 261 return &ErrInvalidHeader{"uint16", []byte{sign}} 262 } 263 n, err := d.deserialize16() 264 if err != nil { 265 return err 266 } 267 *v = uint16(n) 268 return nil 269 } 270 271 func (d *Decoder) Uint32(v *uint32) error { 272 sign, err := d.readByte() 273 if err != nil { 274 return err 275 } 276 if sign != 0xce { 277 return &ErrInvalidHeader{"uint32", []byte{sign}} 278 } 279 n, err := d.deserialize32() 280 if err != nil { 281 return err 282 } 283 *v = uint32(n) 284 return nil 285 } 286 287 func (d *Decoder) Uint64(v *uint64) error { 288 sign, err := d.readByte() 289 if err != nil { 290 return err 291 } 292 if sign != 0xcf { 293 return &ErrInvalidHeader{"uint64", []byte{sign}} 294 } 295 n, err := d.deserialize64() 296 if err != nil { 297 return err 298 } 299 *v = uint64(n) 300 return nil 301 } 302 303 func (d *Decoder) Float32(v *float32) error { 304 sign, err := d.readByte() 305 if err != nil { 306 return err 307 } 308 if sign != 0xca { 309 return &ErrInvalidHeader{"float32", []byte{sign}} 310 } 311 n, err := d.deserialize32() 312 if err != nil { 313 return err 314 } 315 *v = math.Float32frombits(n) 316 return nil 317 } 318 319 func (d *Decoder) Float64(v *float64) error { 320 sign, err := d.readByte() 321 if err != nil { 322 return err 323 } 324 if sign != 0xcb { 325 return &ErrInvalidHeader{"float64", []byte{sign}} 326 } 327 n, err := d.deserialize64() 328 if err != nil { 329 return err 330 } 331 *v = math.Float64frombits(n) 332 return nil 333 } 334 335 func (d *Decoder) String(v *string) error { 336 sign, err := d.readByte() 337 if err != nil { 338 return err 339 } 340 341 var n int 342 switch sign { 343 case 0xd9: 344 p, err := d.readByte() 345 if err != nil { 346 return err 347 } 348 n = int(p) 349 case 0xda: 350 p, err := d.deserialize16() 351 if err != nil { 352 return err 353 } 354 n = int(p) 355 case 0xdb: 356 p, err := d.deserialize32() 357 if err != nil { 358 return err 359 } 360 n = int(p) 361 default: 362 if sign>>5 != 5 { 363 return &ErrInvalidHeader{"string", []byte{sign}} 364 } 365 n = int(sign & 0x1f) 366 } 367 368 buf := make([]byte, n) 369 read, err := d.read(buf) 370 if err != nil && err != io.EOF { 371 return err 372 } 373 if read < n { 374 return &ErrUnexpectedEOF{} 375 } 376 377 *v = string(buf) 378 return nil 379 } 380 381 func (d *Decoder) Binary(v *[]byte) error { 382 sign, err := d.readByte() 383 if err != nil { 384 return err 385 } 386 387 var n int 388 switch sign { 389 case 0xc4: 390 p, err := d.readByte() 391 if err != nil { 392 return err 393 } 394 n = int(p) 395 case 0xc5: 396 p, err := d.deserialize16() 397 if err != nil { 398 return err 399 } 400 n = int(p) 401 case 0xc6: 402 p, err := d.deserialize32() 403 if err != nil { 404 return err 405 } 406 n = int(p) 407 default: 408 return &ErrInvalidHeader{"binary", []byte{sign}} 409 } 410 411 buf := make([]byte, n) 412 read, err := d.read(buf) 413 if err != nil && err != io.EOF { 414 return err 415 } 416 if read < n { 417 return &ErrUnexpectedEOF{} 418 } 419 420 *v = buf 421 return nil 422 } 423 424 func (d *Decoder) Array(v Array) error { 425 sign, err := d.readByte() 426 if err != nil { 427 return err 428 } 429 430 var n int 431 switch sign { 432 case 0xdc: 433 p, err := d.deserialize16() 434 if err != nil { 435 return err 436 } 437 n = int(p) 438 case 0xdd: 439 p, err := d.deserialize32() 440 if err != nil { 441 return err 442 } 443 n = int(p) 444 default: 445 if sign>>4 != 9 { 446 return &ErrInvalidHeader{"array", []byte{sign}} 447 } 448 n = int(sign & 0x0f) 449 } 450 451 err = v.DecodeMsgpackArray(d, n) 452 if err != nil { 453 return err 454 } 455 456 return nil 457 } 458 459 func (d *Decoder) Map(v Map) error { 460 sign, err := d.readByte() 461 if err != nil { 462 return err 463 } 464 465 var n int 466 switch sign { 467 case 0xde: 468 p, err := d.deserialize16() 469 if err != nil { 470 return err 471 } 472 n = int(p) 473 case 0xdf: 474 p, err := d.deserialize32() 475 if err != nil { 476 return err 477 } 478 n = int(p) 479 default: 480 if sign>>4 != 8 { 481 return &ErrInvalidHeader{"string", []byte{sign}} 482 } 483 n = int(sign & 0x0f) 484 } 485 486 err = v.DecodeMsgpackMap(d, n) 487 if err != nil { 488 return err 489 } 490 491 return nil 492 } 493 494 func (d *Decoder) UUID(v *uuid.UUID) error { 495 w := &UUID{} 496 497 err := d.Ext(w) 498 if err != nil { 499 return err 500 } 501 502 *v = w.UUID 503 return nil 504 } 505 506 func (d *Decoder) Ext(v Extension) error { 507 sign, err := d.readByte() 508 if err != nil { 509 return err 510 } 511 512 var n int 513 switch sign { 514 case 0xd4: 515 n = 1 516 case 0xd5: 517 n = 2 518 case 0xd6: 519 n = 4 520 case 0xd7: 521 n = 8 522 case 0xd8: 523 n = 16 524 case 0xc7: 525 p, err := d.readByte() 526 if err != nil { 527 return err 528 } 529 n = int(p) 530 case 0xc8: 531 p, err := d.deserialize16() 532 if err != nil { 533 return err 534 } 535 n = int(p) 536 case 0xc9: 537 p, err := d.deserialize32() 538 if err != nil { 539 return err 540 } 541 n = int(p) 542 } 543 544 typ, err := d.readByte() 545 if err != nil { 546 return err 547 } 548 549 return v.DecodeMsgpackExt(d, int8(typ), n) 550 } 551 552 func (d *Decoder) Raw(v []byte) error { 553 _, err := d.read(v) 554 return err 555 } 556 557 func (d *Decoder) deserialize16() (uint16, error) { 558 var p = make([]byte, 2) 559 n, err := d.read(p) 560 if n != 2 || err == io.EOF { 561 return 0, &ErrUnexpectedEOF{} 562 } 563 if err != nil { 564 return 0, err 565 } 566 return uint16(p[1]) | uint16(p[0])<<8, nil 567 } 568 569 func (d *Decoder) deserialize32() (uint32, error) { 570 var p = make([]byte, 4) 571 n, err := d.read(p) 572 if n != 4 || err == io.EOF { 573 return 0, &ErrUnexpectedEOF{} 574 } 575 if err != nil { 576 return 0, err 577 } 578 return uint32(p[3]) | uint32(p[2])<<8 | uint32(p[1])<<16 | 579 uint32(p[0])<<24, nil 580 } 581 582 func (d *Decoder) deserialize64() (uint64, error) { 583 var p = make([]byte, 8) 584 n, err := d.read(p) 585 if n != 8 || err == io.EOF { 586 return 0, &ErrUnexpectedEOF{} 587 } 588 if err != nil { 589 return 0, err 590 } 591 return uint64(p[7]) | uint64(p[6])<<8 | uint64(p[5])<<16 | 592 uint64(p[4])<<24 | uint64(p[3])<<32 | uint64(p[2])<<40 | 593 uint64(p[1])<<48 | uint64(p[0])<<56, nil 594 }