1// Code below generated from scalar_gen.go.tmpl 2package decode 3 4import ( 5 "fmt" 6 7 "github.com/wader/fq/pkg/bitio" 8 "github.com/wader/fq/pkg/scalar" 9) 10 11// Type BitBuf 12 13// TryFieldBitBufScalarFn tries to add a field, calls scalar functions and returns actual value as a BitBuf 14func (d *D) TryFieldBitBufScalarFn(name string, fn func(d *D) (scalar.S, error), sms ...scalar.Mapper) (*bitio.Buffer, error) { 15 v, err := d.TryFieldScalarFn(name, func(_ scalar.S) (scalar.S, error) { return fn(d) }, sms...) 16 if err != nil { 17 return nil, err 18 } 19 return v.ActualBitBuf(), err 20} 21 22// FieldBitBufScalarFn adds a field, calls scalar functions and returns actual value as a BitBuf 23func (d *D) FieldBitBufScalarFn(name string, fn func(d *D) scalar.S, sms ...scalar.Mapper) *bitio.Buffer { 24 v, err := d.TryFieldScalarFn(name, func(_ scalar.S) (scalar.S, error) { return fn(d), nil }, sms...) 25 if err != nil { 26 panic(IOError{Err: err, Name: name, Op: "BitBuf", Pos: d.Pos()}) 27 } 28 return v.ActualBitBuf() 29} 30 31// FieldBitBufFn adds a field, calls *bitio.Buffer decode function and returns actual value as a BitBuf 32func (d *D) FieldBitBufFn(name string, fn func(d *D) *bitio.Buffer, sms ...scalar.Mapper) *bitio.Buffer { 33 return d.FieldBitBufScalarFn(name, func(d *D) scalar.S { return scalar.S{Actual: fn(d)} }, sms...) 34} 35 36// TryFieldBitBufFn tries to add a field, calls *bitio.Buffer decode function and returns actual value as a BitBuf 37func (d *D) TryFieldBitBufFn(name string, fn func(d *D) (*bitio.Buffer, error), sms ...scalar.Mapper) (*bitio.Buffer, error) { 38 return d.TryFieldBitBufScalarFn(name, func(d *D) (scalar.S, error) { 39 v, err := fn(d) 40 return scalar.S{Actual: v}, err 41 }, sms...) 42} 43 44// TryFieldScalarBitBufFn tries to add a field, calls *bitio.Buffer decode function and returns scalar 45func (d *D) TryFieldScalarBitBufFn(name string, fn func(d *D) (*bitio.Buffer, error), sms ...scalar.Mapper) (*scalar.S, error) { 46 return d.TryFieldScalarFn(name, func(_ scalar.S) (scalar.S, error) { 47 v, err := fn(d) 48 return scalar.S{Actual: v}, err 49 }, sms...) 50} 51 52// FieldScalarBitBufFn tries to add a field, calls *bitio.Buffer decode function and returns scalar 53func (d *D) FieldScalarBitBufFn(name string, fn func(d *D) *bitio.Buffer, sms ...scalar.Mapper) *scalar.S { 54 v, err := d.TryFieldScalarBitBufFn(name, func(d *D) (*bitio.Buffer, error) { return fn(d), nil }, sms...) 55 if err != nil { 56 panic(IOError{Err: err, Name: name, Op: "BitBuf", Pos: d.Pos()}) 57 } 58 return v 59} 60 61// Type Bool 62 63// TryFieldBoolScalarFn tries to add a field, calls scalar functions and returns actual value as a Bool 64func (d *D) TryFieldBoolScalarFn(name string, fn func(d *D) (scalar.S, error), sms ...scalar.Mapper) (bool, error) { 65 v, err := d.TryFieldScalarFn(name, func(_ scalar.S) (scalar.S, error) { return fn(d) }, sms...) 66 if err != nil { 67 return false, err 68 } 69 return v.ActualBool(), err 70} 71 72// FieldBoolScalarFn adds a field, calls scalar functions and returns actual value as a Bool 73func (d *D) FieldBoolScalarFn(name string, fn func(d *D) scalar.S, sms ...scalar.Mapper) bool { 74 v, err := d.TryFieldScalarFn(name, func(_ scalar.S) (scalar.S, error) { return fn(d), nil }, sms...) 75 if err != nil { 76 panic(IOError{Err: err, Name: name, Op: "Bool", Pos: d.Pos()}) 77 } 78 return v.ActualBool() 79} 80 81// FieldBoolFn adds a field, calls bool decode function and returns actual value as a Bool 82func (d *D) FieldBoolFn(name string, fn func(d *D) bool, sms ...scalar.Mapper) bool { 83 return d.FieldBoolScalarFn(name, func(d *D) scalar.S { return scalar.S{Actual: fn(d)} }, sms...) 84} 85 86// TryFieldBoolFn tries to add a field, calls bool decode function and returns actual value as a Bool 87func (d *D) TryFieldBoolFn(name string, fn func(d *D) (bool, error), sms ...scalar.Mapper) (bool, error) { 88 return d.TryFieldBoolScalarFn(name, func(d *D) (scalar.S, error) { 89 v, err := fn(d) 90 return scalar.S{Actual: v}, err 91 }, sms...) 92} 93 94// TryFieldScalarBoolFn tries to add a field, calls bool decode function and returns scalar 95func (d *D) TryFieldScalarBoolFn(name string, fn func(d *D) (bool, error), sms ...scalar.Mapper) (*scalar.S, error) { 96 return d.TryFieldScalarFn(name, func(_ scalar.S) (scalar.S, error) { 97 v, err := fn(d) 98 return scalar.S{Actual: v}, err 99 }, sms...) 100} 101 102// FieldScalarBoolFn tries to add a field, calls bool decode function and returns scalar 103func (d *D) FieldScalarBoolFn(name string, fn func(d *D) bool, sms ...scalar.Mapper) *scalar.S { 104 v, err := d.TryFieldScalarBoolFn(name, func(d *D) (bool, error) { return fn(d), nil }, sms...) 105 if err != nil { 106 panic(IOError{Err: err, Name: name, Op: "Bool", Pos: d.Pos()}) 107 } 108 return v 109} 110 111// Type F 112 113// TryFieldFScalarFn tries to add a field, calls scalar functions and returns actual value as a F 114func (d *D) TryFieldFScalarFn(name string, fn func(d *D) (scalar.S, error), sms ...scalar.Mapper) (float64, error) { 115 v, err := d.TryFieldScalarFn(name, func(_ scalar.S) (scalar.S, error) { return fn(d) }, sms...) 116 if err != nil { 117 return 0, err 118 } 119 return v.ActualF(), err 120} 121 122// FieldFScalarFn adds a field, calls scalar functions and returns actual value as a F 123func (d *D) FieldFScalarFn(name string, fn func(d *D) scalar.S, sms ...scalar.Mapper) float64 { 124 v, err := d.TryFieldScalarFn(name, func(_ scalar.S) (scalar.S, error) { return fn(d), nil }, sms...) 125 if err != nil { 126 panic(IOError{Err: err, Name: name, Op: "F", Pos: d.Pos()}) 127 } 128 return v.ActualF() 129} 130 131// FieldFFn adds a field, calls float64 decode function and returns actual value as a F 132func (d *D) FieldFFn(name string, fn func(d *D) float64, sms ...scalar.Mapper) float64 { 133 return d.FieldFScalarFn(name, func(d *D) scalar.S { return scalar.S{Actual: fn(d)} }, sms...) 134} 135 136// TryFieldFFn tries to add a field, calls float64 decode function and returns actual value as a F 137func (d *D) TryFieldFFn(name string, fn func(d *D) (float64, error), sms ...scalar.Mapper) (float64, error) { 138 return d.TryFieldFScalarFn(name, func(d *D) (scalar.S, error) { 139 v, err := fn(d) 140 return scalar.S{Actual: v}, err 141 }, sms...) 142} 143 144// TryFieldScalarFFn tries to add a field, calls float64 decode function and returns scalar 145func (d *D) TryFieldScalarFFn(name string, fn func(d *D) (float64, error), sms ...scalar.Mapper) (*scalar.S, error) { 146 return d.TryFieldScalarFn(name, func(_ scalar.S) (scalar.S, error) { 147 v, err := fn(d) 148 return scalar.S{Actual: v}, err 149 }, sms...) 150} 151 152// FieldScalarFFn tries to add a field, calls float64 decode function and returns scalar 153func (d *D) FieldScalarFFn(name string, fn func(d *D) float64, sms ...scalar.Mapper) *scalar.S { 154 v, err := d.TryFieldScalarFFn(name, func(d *D) (float64, error) { return fn(d), nil }, sms...) 155 if err != nil { 156 panic(IOError{Err: err, Name: name, Op: "F", Pos: d.Pos()}) 157 } 158 return v 159} 160 161// Type S 162 163// TryFieldSScalarFn tries to add a field, calls scalar functions and returns actual value as a S 164func (d *D) TryFieldSScalarFn(name string, fn func(d *D) (scalar.S, error), sms ...scalar.Mapper) (int64, error) { 165 v, err := d.TryFieldScalarFn(name, func(_ scalar.S) (scalar.S, error) { return fn(d) }, sms...) 166 if err != nil { 167 return 0, err 168 } 169 return v.ActualS(), err 170} 171 172// FieldSScalarFn adds a field, calls scalar functions and returns actual value as a S 173func (d *D) FieldSScalarFn(name string, fn func(d *D) scalar.S, sms ...scalar.Mapper) int64 { 174 v, err := d.TryFieldScalarFn(name, func(_ scalar.S) (scalar.S, error) { return fn(d), nil }, sms...) 175 if err != nil { 176 panic(IOError{Err: err, Name: name, Op: "S", Pos: d.Pos()}) 177 } 178 return v.ActualS() 179} 180 181// FieldSFn adds a field, calls int64 decode function and returns actual value as a S 182func (d *D) FieldSFn(name string, fn func(d *D) int64, sms ...scalar.Mapper) int64 { 183 return d.FieldSScalarFn(name, func(d *D) scalar.S { return scalar.S{Actual: fn(d)} }, sms...) 184} 185 186// TryFieldSFn tries to add a field, calls int64 decode function and returns actual value as a S 187func (d *D) TryFieldSFn(name string, fn func(d *D) (int64, error), sms ...scalar.Mapper) (int64, error) { 188 return d.TryFieldSScalarFn(name, func(d *D) (scalar.S, error) { 189 v, err := fn(d) 190 return scalar.S{Actual: v}, err 191 }, sms...) 192} 193 194// TryFieldScalarSFn tries to add a field, calls int64 decode function and returns scalar 195func (d *D) TryFieldScalarSFn(name string, fn func(d *D) (int64, error), sms ...scalar.Mapper) (*scalar.S, error) { 196 return d.TryFieldScalarFn(name, func(_ scalar.S) (scalar.S, error) { 197 v, err := fn(d) 198 return scalar.S{Actual: v}, err 199 }, sms...) 200} 201 202// FieldScalarSFn tries to add a field, calls int64 decode function and returns scalar 203func (d *D) FieldScalarSFn(name string, fn func(d *D) int64, sms ...scalar.Mapper) *scalar.S { 204 v, err := d.TryFieldScalarSFn(name, func(d *D) (int64, error) { return fn(d), nil }, sms...) 205 if err != nil { 206 panic(IOError{Err: err, Name: name, Op: "S", Pos: d.Pos()}) 207 } 208 return v 209} 210 211// Type Str 212 213// TryFieldStrScalarFn tries to add a field, calls scalar functions and returns actual value as a Str 214func (d *D) TryFieldStrScalarFn(name string, fn func(d *D) (scalar.S, error), sms ...scalar.Mapper) (string, error) { 215 v, err := d.TryFieldScalarFn(name, func(_ scalar.S) (scalar.S, error) { return fn(d) }, sms...) 216 if err != nil { 217 return "", err 218 } 219 return v.ActualStr(), err 220} 221 222// FieldStrScalarFn adds a field, calls scalar functions and returns actual value as a Str 223func (d *D) FieldStrScalarFn(name string, fn func(d *D) scalar.S, sms ...scalar.Mapper) string { 224 v, err := d.TryFieldScalarFn(name, func(_ scalar.S) (scalar.S, error) { return fn(d), nil }, sms...) 225 if err != nil { 226 panic(IOError{Err: err, Name: name, Op: "Str", Pos: d.Pos()}) 227 } 228 return v.ActualStr() 229} 230 231// FieldStrFn adds a field, calls string decode function and returns actual value as a Str 232func (d *D) FieldStrFn(name string, fn func(d *D) string, sms ...scalar.Mapper) string { 233 return d.FieldStrScalarFn(name, func(d *D) scalar.S { return scalar.S{Actual: fn(d)} }, sms...) 234} 235 236// TryFieldStrFn tries to add a field, calls string decode function and returns actual value as a Str 237func (d *D) TryFieldStrFn(name string, fn func(d *D) (string, error), sms ...scalar.Mapper) (string, error) { 238 return d.TryFieldStrScalarFn(name, func(d *D) (scalar.S, error) { 239 v, err := fn(d) 240 return scalar.S{Actual: v}, err 241 }, sms...) 242} 243 244// TryFieldScalarStrFn tries to add a field, calls string decode function and returns scalar 245func (d *D) TryFieldScalarStrFn(name string, fn func(d *D) (string, error), sms ...scalar.Mapper) (*scalar.S, error) { 246 return d.TryFieldScalarFn(name, func(_ scalar.S) (scalar.S, error) { 247 v, err := fn(d) 248 return scalar.S{Actual: v}, err 249 }, sms...) 250} 251 252// FieldScalarStrFn tries to add a field, calls string decode function and returns scalar 253func (d *D) FieldScalarStrFn(name string, fn func(d *D) string, sms ...scalar.Mapper) *scalar.S { 254 v, err := d.TryFieldScalarStrFn(name, func(d *D) (string, error) { return fn(d), nil }, sms...) 255 if err != nil { 256 panic(IOError{Err: err, Name: name, Op: "Str", Pos: d.Pos()}) 257 } 258 return v 259} 260 261// Type U 262 263// TryFieldUScalarFn tries to add a field, calls scalar functions and returns actual value as a U 264func (d *D) TryFieldUScalarFn(name string, fn func(d *D) (scalar.S, error), sms ...scalar.Mapper) (uint64, error) { 265 v, err := d.TryFieldScalarFn(name, func(_ scalar.S) (scalar.S, error) { return fn(d) }, sms...) 266 if err != nil { 267 return 0, err 268 } 269 return v.ActualU(), err 270} 271 272// FieldUScalarFn adds a field, calls scalar functions and returns actual value as a U 273func (d *D) FieldUScalarFn(name string, fn func(d *D) scalar.S, sms ...scalar.Mapper) uint64 { 274 v, err := d.TryFieldScalarFn(name, func(_ scalar.S) (scalar.S, error) { return fn(d), nil }, sms...) 275 if err != nil { 276 panic(IOError{Err: err, Name: name, Op: "U", Pos: d.Pos()}) 277 } 278 return v.ActualU() 279} 280 281// FieldUFn adds a field, calls uint64 decode function and returns actual value as a U 282func (d *D) FieldUFn(name string, fn func(d *D) uint64, sms ...scalar.Mapper) uint64 { 283 return d.FieldUScalarFn(name, func(d *D) scalar.S { return scalar.S{Actual: fn(d)} }, sms...) 284} 285 286// TryFieldUFn tries to add a field, calls uint64 decode function and returns actual value as a U 287func (d *D) TryFieldUFn(name string, fn func(d *D) (uint64, error), sms ...scalar.Mapper) (uint64, error) { 288 return d.TryFieldUScalarFn(name, func(d *D) (scalar.S, error) { 289 v, err := fn(d) 290 return scalar.S{Actual: v}, err 291 }, sms...) 292} 293 294// TryFieldScalarUFn tries to add a field, calls uint64 decode function and returns scalar 295func (d *D) TryFieldScalarUFn(name string, fn func(d *D) (uint64, error), sms ...scalar.Mapper) (*scalar.S, error) { 296 return d.TryFieldScalarFn(name, func(_ scalar.S) (scalar.S, error) { 297 v, err := fn(d) 298 return scalar.S{Actual: v}, err 299 }, sms...) 300} 301 302// FieldScalarUFn tries to add a field, calls uint64 decode function and returns scalar 303func (d *D) FieldScalarUFn(name string, fn func(d *D) uint64, sms ...scalar.Mapper) *scalar.S { 304 v, err := d.TryFieldScalarUFn(name, func(d *D) (uint64, error) { return fn(d), nil }, sms...) 305 if err != nil { 306 panic(IOError{Err: err, Name: name, Op: "U", Pos: d.Pos()}) 307 } 308 return v 309} 310 311// Require/Assert/Validate Bool 312 313func requireBool(name string, s scalar.S, desc bool, fail bool, vs ...bool) (scalar.S, error) { 314 a := s.ActualBool() 315 for _, b := range vs { 316 if a == b { 317 if desc { 318 s.Description = "valid" 319 } 320 return s, nil 321 } 322 } 323 if desc { 324 s.Description = "invalid" 325 } 326 if fail { 327 return s, fmt.Errorf("failed to %s Bool", name) 328 } 329 return s, nil 330} 331 332// RequireBool that actual value is one of given bool values 333func (d *D) RequireBool(vs ...bool) scalar.Mapper { 334 return scalar.Fn(func(s scalar.S) (scalar.S, error) { return requireBool("require", s, false, true, vs...) }) 335} 336 337// AssertBool validate and asserts that actual value is one of given bool values 338func (d *D) AssertBool(vs ...bool) scalar.Mapper { 339 return scalar.Fn(func(s scalar.S) (scalar.S, error) { return requireBool("assert", s, true, !d.Options.Force, vs...) }) 340} 341 342// ValidateBool validates that actual value is one of given bool values 343func (d *D) ValidateBool(vs ...bool) scalar.Mapper { 344 return scalar.Fn(func(s scalar.S) (scalar.S, error) { return requireBool("validate", s, true, false, vs...) }) 345} 346 347// Require/Assert/Validate F 348 349func requireF(name string, s scalar.S, desc bool, fail bool, vs ...float64) (scalar.S, error) { 350 a := s.ActualF() 351 for _, b := range vs { 352 if a == b { 353 if desc { 354 s.Description = "valid" 355 } 356 return s, nil 357 } 358 } 359 if desc { 360 s.Description = "invalid" 361 } 362 if fail { 363 return s, fmt.Errorf("failed to %s F", name) 364 } 365 return s, nil 366} 367 368// RequireF that actual value is one of given float64 values 369func (d *D) RequireF(vs ...float64) scalar.Mapper { 370 return scalar.Fn(func(s scalar.S) (scalar.S, error) { return requireF("require", s, false, true, vs...) }) 371} 372 373// AssertF validate and asserts that actual value is one of given float64 values 374func (d *D) AssertF(vs ...float64) scalar.Mapper { 375 return scalar.Fn(func(s scalar.S) (scalar.S, error) { return requireF("assert", s, true, !d.Options.Force, vs...) }) 376} 377 378// ValidateF validates that actual value is one of given float64 values 379func (d *D) ValidateF(vs ...float64) scalar.Mapper { 380 return scalar.Fn(func(s scalar.S) (scalar.S, error) { return requireF("validate", s, true, false, vs...) }) 381} 382 383// Require/Assert/ValidatRange F 384 385func requireRangeF(name string, s scalar.S, desc bool, fail bool, start, end float64) (scalar.S, error) { 386 a := s.ActualF() 387 if a >= start && a <= end { 388 if desc { 389 s.Description = "valid" 390 } 391 return s, nil 392 } 393 if desc { 394 s.Description = "invalid" 395 } 396 if fail { 397 return s, fmt.Errorf("failed to %s F range %v-%v", name, start, end) 398 } 399 return s, nil 400} 401 402// RequireFRange require that actual value is in range 403func (d *D) RequireFRange(start, end float64) scalar.Mapper { 404 return scalar.Fn(func(s scalar.S) (scalar.S, error) { return requireRangeF("require", s, false, true, start, end) }) 405} 406 407// AssertFRange asserts that actual value is in range 408func (d *D) AssertFRange(start, end float64) scalar.Mapper { 409 return scalar.Fn(func(s scalar.S) (scalar.S, error) { 410 return requireRangeF("assert", s, true, !d.Options.Force, start, end) 411 }) 412} 413 414// ValidateFRange validates that actual value is in range 415func (d *D) ValidateFRange(start, end float64) scalar.Mapper { 416 return scalar.Fn(func(s scalar.S) (scalar.S, error) { return requireRangeF("validate", s, true, false, start, end) }) 417} 418 419// Require/Assert/Validate S 420 421func requireS(name string, s scalar.S, desc bool, fail bool, vs ...int64) (scalar.S, error) { 422 a := s.ActualS() 423 for _, b := range vs { 424 if a == b { 425 if desc { 426 s.Description = "valid" 427 } 428 return s, nil 429 } 430 } 431 if desc { 432 s.Description = "invalid" 433 } 434 if fail { 435 return s, fmt.Errorf("failed to %s S", name) 436 } 437 return s, nil 438} 439 440// RequireS that actual value is one of given int64 values 441func (d *D) RequireS(vs ...int64) scalar.Mapper { 442 return scalar.Fn(func(s scalar.S) (scalar.S, error) { return requireS("require", s, false, true, vs...) }) 443} 444 445// AssertS validate and asserts that actual value is one of given int64 values 446func (d *D) AssertS(vs ...int64) scalar.Mapper { 447 return scalar.Fn(func(s scalar.S) (scalar.S, error) { return requireS("assert", s, true, !d.Options.Force, vs...) }) 448} 449 450// ValidateS validates that actual value is one of given int64 values 451func (d *D) ValidateS(vs ...int64) scalar.Mapper { 452 return scalar.Fn(func(s scalar.S) (scalar.S, error) { return requireS("validate", s, true, false, vs...) }) 453} 454 455// Require/Assert/ValidatRange S 456 457func requireRangeS(name string, s scalar.S, desc bool, fail bool, start, end int64) (scalar.S, error) { 458 a := s.ActualS() 459 if a >= start && a <= end { 460 if desc { 461 s.Description = "valid" 462 } 463 return s, nil 464 } 465 if desc { 466 s.Description = "invalid" 467 } 468 if fail { 469 return s, fmt.Errorf("failed to %s S range %v-%v", name, start, end) 470 } 471 return s, nil 472} 473 474// RequireSRange require that actual value is in range 475func (d *D) RequireSRange(start, end int64) scalar.Mapper { 476 return scalar.Fn(func(s scalar.S) (scalar.S, error) { return requireRangeS("require", s, false, true, start, end) }) 477} 478 479// AssertSRange asserts that actual value is in range 480func (d *D) AssertSRange(start, end int64) scalar.Mapper { 481 return scalar.Fn(func(s scalar.S) (scalar.S, error) { 482 return requireRangeS("assert", s, true, !d.Options.Force, start, end) 483 }) 484} 485 486// ValidateSRange validates that actual value is in range 487func (d *D) ValidateSRange(start, end int64) scalar.Mapper { 488 return scalar.Fn(func(s scalar.S) (scalar.S, error) { return requireRangeS("validate", s, true, false, start, end) }) 489} 490 491// Require/Assert/Validate Str 492 493func requireStr(name string, s scalar.S, desc bool, fail bool, vs ...string) (scalar.S, error) { 494 a := s.ActualStr() 495 for _, b := range vs { 496 if a == b { 497 if desc { 498 s.Description = "valid" 499 } 500 return s, nil 501 } 502 } 503 if desc { 504 s.Description = "invalid" 505 } 506 if fail { 507 return s, fmt.Errorf("failed to %s Str", name) 508 } 509 return s, nil 510} 511 512// RequireStr that actual value is one of given string values 513func (d *D) RequireStr(vs ...string) scalar.Mapper { 514 return scalar.Fn(func(s scalar.S) (scalar.S, error) { return requireStr("require", s, false, true, vs...) }) 515} 516 517// AssertStr validate and asserts that actual value is one of given string values 518func (d *D) AssertStr(vs ...string) scalar.Mapper { 519 return scalar.Fn(func(s scalar.S) (scalar.S, error) { return requireStr("assert", s, true, !d.Options.Force, vs...) }) 520} 521 522// ValidateStr validates that actual value is one of given string values 523func (d *D) ValidateStr(vs ...string) scalar.Mapper { 524 return scalar.Fn(func(s scalar.S) (scalar.S, error) { return requireStr("validate", s, true, false, vs...) }) 525} 526 527// Require/Assert/ValidatRange Str 528 529func requireRangeStr(name string, s scalar.S, desc bool, fail bool, start, end string) (scalar.S, error) { 530 a := s.ActualStr() 531 if a >= start && a <= end { 532 if desc { 533 s.Description = "valid" 534 } 535 return s, nil 536 } 537 if desc { 538 s.Description = "invalid" 539 } 540 if fail { 541 return s, fmt.Errorf("failed to %s Str range %v-%v", name, start, end) 542 } 543 return s, nil 544} 545 546// RequireStrRange require that actual value is in range 547func (d *D) RequireStrRange(start, end string) scalar.Mapper { 548 return scalar.Fn(func(s scalar.S) (scalar.S, error) { return requireRangeStr("require", s, false, true, start, end) }) 549} 550 551// AssertStrRange asserts that actual value is in range 552func (d *D) AssertStrRange(start, end string) scalar.Mapper { 553 return scalar.Fn(func(s scalar.S) (scalar.S, error) { 554 return requireRangeStr("assert", s, true, !d.Options.Force, start, end) 555 }) 556} 557 558// ValidateStrRange validates that actual value is in range 559func (d *D) ValidateStrRange(start, end string) scalar.Mapper { 560 return scalar.Fn(func(s scalar.S) (scalar.S, error) { return requireRangeStr("validate", s, true, false, start, end) }) 561} 562 563// Require/Assert/Validate U 564 565func requireU(name string, s scalar.S, desc bool, fail bool, vs ...uint64) (scalar.S, error) { 566 a := s.ActualU() 567 for _, b := range vs { 568 if a == b { 569 if desc { 570 s.Description = "valid" 571 } 572 return s, nil 573 } 574 } 575 if desc { 576 s.Description = "invalid" 577 } 578 if fail { 579 return s, fmt.Errorf("failed to %s U", name) 580 } 581 return s, nil 582} 583 584// RequireU that actual value is one of given uint64 values 585func (d *D) RequireU(vs ...uint64) scalar.Mapper { 586 return scalar.Fn(func(s scalar.S) (scalar.S, error) { return requireU("require", s, false, true, vs...) }) 587} 588 589// AssertU validate and asserts that actual value is one of given uint64 values 590func (d *D) AssertU(vs ...uint64) scalar.Mapper { 591 return scalar.Fn(func(s scalar.S) (scalar.S, error) { return requireU("assert", s, true, !d.Options.Force, vs...) }) 592} 593 594// ValidateU validates that actual value is one of given uint64 values 595func (d *D) ValidateU(vs ...uint64) scalar.Mapper { 596 return scalar.Fn(func(s scalar.S) (scalar.S, error) { return requireU("validate", s, true, false, vs...) }) 597} 598 599// Require/Assert/ValidatRange U 600 601func requireRangeU(name string, s scalar.S, desc bool, fail bool, start, end uint64) (scalar.S, error) { 602 a := s.ActualU() 603 if a >= start && a <= end { 604 if desc { 605 s.Description = "valid" 606 } 607 return s, nil 608 } 609 if desc { 610 s.Description = "invalid" 611 } 612 if fail { 613 return s, fmt.Errorf("failed to %s U range %v-%v", name, start, end) 614 } 615 return s, nil 616} 617 618// RequireURange require that actual value is in range 619func (d *D) RequireURange(start, end uint64) scalar.Mapper { 620 return scalar.Fn(func(s scalar.S) (scalar.S, error) { return requireRangeU("require", s, false, true, start, end) }) 621} 622 623// AssertURange asserts that actual value is in range 624func (d *D) AssertURange(start, end uint64) scalar.Mapper { 625 return scalar.Fn(func(s scalar.S) (scalar.S, error) { 626 return requireRangeU("assert", s, true, !d.Options.Force, start, end) 627 }) 628} 629 630// ValidateURange validates that actual value is in range 631func (d *D) ValidateURange(start, end uint64) scalar.Mapper { 632 return scalar.Fn(func(s scalar.S) (scalar.S, error) { return requireRangeU("validate", s, true, false, start, end) }) 633} 634 635// Reader RawLen 636 637// TryRawLen tries to read nBits raw bits 638func (d *D) TryRawLen(nBits int64) (*bitio.Buffer, error) { return d.tryBitBuf(nBits) } 639 640// RawLen reads nBits raw bits 641func (d *D) RawLen(nBits int64) *bitio.Buffer { 642 v, err := d.tryBitBuf(nBits) 643 if err != nil { 644 panic(IOError{Err: err, Op: "RawLen", Pos: d.Pos()}) 645 } 646 return v 647} 648 649// TryFieldScalarRawLen tries to add a field and read nBits raw bits 650func (d *D) TryFieldScalarRawLen(name string, nBits int64, sms ...scalar.Mapper) (*scalar.S, error) { 651 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 652 v, err := d.tryBitBuf(nBits) 653 s.Actual = v 654 return s, err 655 }, sms...) 656 if err != nil { 657 return nil, err 658 } 659 return s, err 660} 661 662// FieldScalarRawLen adds a field and reads nBits raw bits 663func (d *D) FieldScalarRawLen(name string, nBits int64, sms ...scalar.Mapper) *scalar.S { 664 s, err := d.TryFieldScalarRawLen(name, nBits, sms...) 665 if err != nil { 666 panic(IOError{Err: err, Name: name, Op: "RawLen", Pos: d.Pos()}) 667 } 668 return s 669} 670 671// TryFieldRawLen tries to add a field and read nBits raw bits 672func (d *D) TryFieldRawLen(name string, nBits int64, sms ...scalar.Mapper) (*bitio.Buffer, error) { 673 s, err := d.TryFieldScalarRawLen(name, nBits, sms...) 674 return s.ActualBitBuf(), err 675} 676 677// FieldRawLen adds a field and reads nBits raw bits 678func (d *D) FieldRawLen(name string, nBits int64, sms ...scalar.Mapper) *bitio.Buffer { 679 return d.FieldScalarRawLen(name, nBits, sms...).ActualBitBuf() 680} 681 682// Reader Bool 683 684// TryBool tries to read 1 bit boolean 685func (d *D) TryBool() (bool, error) { return d.tryBool() } 686 687// Bool reads 1 bit boolean 688func (d *D) Bool() bool { 689 v, err := d.tryBool() 690 if err != nil { 691 panic(IOError{Err: err, Op: "Bool", Pos: d.Pos()}) 692 } 693 return v 694} 695 696// TryFieldScalarBool tries to add a field and read 1 bit boolean 697func (d *D) TryFieldScalarBool(name string, sms ...scalar.Mapper) (*scalar.S, error) { 698 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 699 v, err := d.tryBool() 700 s.Actual = v 701 return s, err 702 }, sms...) 703 if err != nil { 704 return nil, err 705 } 706 return s, err 707} 708 709// FieldScalarBool adds a field and reads 1 bit boolean 710func (d *D) FieldScalarBool(name string, sms ...scalar.Mapper) *scalar.S { 711 s, err := d.TryFieldScalarBool(name, sms...) 712 if err != nil { 713 panic(IOError{Err: err, Name: name, Op: "Bool", Pos: d.Pos()}) 714 } 715 return s 716} 717 718// TryFieldBool tries to add a field and read 1 bit boolean 719func (d *D) TryFieldBool(name string, sms ...scalar.Mapper) (bool, error) { 720 s, err := d.TryFieldScalarBool(name, sms...) 721 return s.ActualBool(), err 722} 723 724// FieldBool adds a field and reads 1 bit boolean 725func (d *D) FieldBool(name string, sms ...scalar.Mapper) bool { 726 return d.FieldScalarBool(name, sms...).ActualBool() 727} 728 729// Reader U 730 731// TryU tries to read nBits bits unsigned integer in current endian 732func (d *D) TryU(nBits int) (uint64, error) { return d.tryUE(nBits, d.Endian) } 733 734// U reads nBits bits unsigned integer in current endian 735func (d *D) U(nBits int) uint64 { 736 v, err := d.tryUE(nBits, d.Endian) 737 if err != nil { 738 panic(IOError{Err: err, Op: "U", Pos: d.Pos()}) 739 } 740 return v 741} 742 743// TryFieldScalarU tries to add a field and read nBits bits unsigned integer in current endian 744func (d *D) TryFieldScalarU(name string, nBits int, sms ...scalar.Mapper) (*scalar.S, error) { 745 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 746 v, err := d.tryUE(nBits, d.Endian) 747 s.Actual = v 748 return s, err 749 }, sms...) 750 if err != nil { 751 return nil, err 752 } 753 return s, err 754} 755 756// FieldScalarU adds a field and reads nBits bits unsigned integer in current endian 757func (d *D) FieldScalarU(name string, nBits int, sms ...scalar.Mapper) *scalar.S { 758 s, err := d.TryFieldScalarU(name, nBits, sms...) 759 if err != nil { 760 panic(IOError{Err: err, Name: name, Op: "U", Pos: d.Pos()}) 761 } 762 return s 763} 764 765// TryFieldU tries to add a field and read nBits bits unsigned integer in current endian 766func (d *D) TryFieldU(name string, nBits int, sms ...scalar.Mapper) (uint64, error) { 767 s, err := d.TryFieldScalarU(name, nBits, sms...) 768 return s.ActualU(), err 769} 770 771// FieldU adds a field and reads nBits bits unsigned integer in current endian 772func (d *D) FieldU(name string, nBits int, sms ...scalar.Mapper) uint64 { 773 return d.FieldScalarU(name, nBits, sms...).ActualU() 774} 775 776// Reader UE 777 778// TryUE tries to read nBits unsigned integer in specified endian 779func (d *D) TryUE(nBits int, endian Endian) (uint64, error) { return d.tryUE(nBits, endian) } 780 781// UE reads nBits unsigned integer in specified endian 782func (d *D) UE(nBits int, endian Endian) uint64 { 783 v, err := d.tryUE(nBits, endian) 784 if err != nil { 785 panic(IOError{Err: err, Op: "UE", Pos: d.Pos()}) 786 } 787 return v 788} 789 790// TryFieldScalarUE tries to add a field and read nBits unsigned integer in specified endian 791func (d *D) TryFieldScalarUE(name string, nBits int, endian Endian, sms ...scalar.Mapper) (*scalar.S, error) { 792 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 793 v, err := d.tryUE(nBits, endian) 794 s.Actual = v 795 return s, err 796 }, sms...) 797 if err != nil { 798 return nil, err 799 } 800 return s, err 801} 802 803// FieldScalarUE adds a field and reads nBits unsigned integer in specified endian 804func (d *D) FieldScalarUE(name string, nBits int, endian Endian, sms ...scalar.Mapper) *scalar.S { 805 s, err := d.TryFieldScalarUE(name, nBits, endian, sms...) 806 if err != nil { 807 panic(IOError{Err: err, Name: name, Op: "UE", Pos: d.Pos()}) 808 } 809 return s 810} 811 812// TryFieldUE tries to add a field and read nBits unsigned integer in specified endian 813func (d *D) TryFieldUE(name string, nBits int, endian Endian, sms ...scalar.Mapper) (uint64, error) { 814 s, err := d.TryFieldScalarUE(name, nBits, endian, sms...) 815 return s.ActualU(), err 816} 817 818// FieldUE adds a field and reads nBits unsigned integer in specified endian 819func (d *D) FieldUE(name string, nBits int, endian Endian, sms ...scalar.Mapper) uint64 { 820 return d.FieldScalarUE(name, nBits, endian, sms...).ActualU() 821} 822 823// Reader U1 824 825// TryU1 tries to read 1 bit unsigned integer in current endian 826func (d *D) TryU1() (uint64, error) { return d.tryUE(1, d.Endian) } 827 828// U1 reads 1 bit unsigned integer in current endian 829func (d *D) U1() uint64 { 830 v, err := d.tryUE(1, d.Endian) 831 if err != nil { 832 panic(IOError{Err: err, Op: "U1", Pos: d.Pos()}) 833 } 834 return v 835} 836 837// TryFieldScalarU1 tries to add a field and read 1 bit unsigned integer in current endian 838func (d *D) TryFieldScalarU1(name string, sms ...scalar.Mapper) (*scalar.S, error) { 839 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 840 v, err := d.tryUE(1, d.Endian) 841 s.Actual = v 842 return s, err 843 }, sms...) 844 if err != nil { 845 return nil, err 846 } 847 return s, err 848} 849 850// FieldScalarU1 adds a field and reads 1 bit unsigned integer in current endian 851func (d *D) FieldScalarU1(name string, sms ...scalar.Mapper) *scalar.S { 852 s, err := d.TryFieldScalarU1(name, sms...) 853 if err != nil { 854 panic(IOError{Err: err, Name: name, Op: "U1", Pos: d.Pos()}) 855 } 856 return s 857} 858 859// TryFieldU1 tries to add a field and read 1 bit unsigned integer in current endian 860func (d *D) TryFieldU1(name string, sms ...scalar.Mapper) (uint64, error) { 861 s, err := d.TryFieldScalarU1(name, sms...) 862 return s.ActualU(), err 863} 864 865// FieldU1 adds a field and reads 1 bit unsigned integer in current endian 866func (d *D) FieldU1(name string, sms ...scalar.Mapper) uint64 { 867 return d.FieldScalarU1(name, sms...).ActualU() 868} 869 870// Reader U2 871 872// TryU2 tries to read 2 bit unsigned integer in current endian 873func (d *D) TryU2() (uint64, error) { return d.tryUE(2, d.Endian) } 874 875// U2 reads 2 bit unsigned integer in current endian 876func (d *D) U2() uint64 { 877 v, err := d.tryUE(2, d.Endian) 878 if err != nil { 879 panic(IOError{Err: err, Op: "U2", Pos: d.Pos()}) 880 } 881 return v 882} 883 884// TryFieldScalarU2 tries to add a field and read 2 bit unsigned integer in current endian 885func (d *D) TryFieldScalarU2(name string, sms ...scalar.Mapper) (*scalar.S, error) { 886 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 887 v, err := d.tryUE(2, d.Endian) 888 s.Actual = v 889 return s, err 890 }, sms...) 891 if err != nil { 892 return nil, err 893 } 894 return s, err 895} 896 897// FieldScalarU2 adds a field and reads 2 bit unsigned integer in current endian 898func (d *D) FieldScalarU2(name string, sms ...scalar.Mapper) *scalar.S { 899 s, err := d.TryFieldScalarU2(name, sms...) 900 if err != nil { 901 panic(IOError{Err: err, Name: name, Op: "U2", Pos: d.Pos()}) 902 } 903 return s 904} 905 906// TryFieldU2 tries to add a field and read 2 bit unsigned integer in current endian 907func (d *D) TryFieldU2(name string, sms ...scalar.Mapper) (uint64, error) { 908 s, err := d.TryFieldScalarU2(name, sms...) 909 return s.ActualU(), err 910} 911 912// FieldU2 adds a field and reads 2 bit unsigned integer in current endian 913func (d *D) FieldU2(name string, sms ...scalar.Mapper) uint64 { 914 return d.FieldScalarU2(name, sms...).ActualU() 915} 916 917// Reader U3 918 919// TryU3 tries to read 3 bit unsigned integer in current endian 920func (d *D) TryU3() (uint64, error) { return d.tryUE(3, d.Endian) } 921 922// U3 reads 3 bit unsigned integer in current endian 923func (d *D) U3() uint64 { 924 v, err := d.tryUE(3, d.Endian) 925 if err != nil { 926 panic(IOError{Err: err, Op: "U3", Pos: d.Pos()}) 927 } 928 return v 929} 930 931// TryFieldScalarU3 tries to add a field and read 3 bit unsigned integer in current endian 932func (d *D) TryFieldScalarU3(name string, sms ...scalar.Mapper) (*scalar.S, error) { 933 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 934 v, err := d.tryUE(3, d.Endian) 935 s.Actual = v 936 return s, err 937 }, sms...) 938 if err != nil { 939 return nil, err 940 } 941 return s, err 942} 943 944// FieldScalarU3 adds a field and reads 3 bit unsigned integer in current endian 945func (d *D) FieldScalarU3(name string, sms ...scalar.Mapper) *scalar.S { 946 s, err := d.TryFieldScalarU3(name, sms...) 947 if err != nil { 948 panic(IOError{Err: err, Name: name, Op: "U3", Pos: d.Pos()}) 949 } 950 return s 951} 952 953// TryFieldU3 tries to add a field and read 3 bit unsigned integer in current endian 954func (d *D) TryFieldU3(name string, sms ...scalar.Mapper) (uint64, error) { 955 s, err := d.TryFieldScalarU3(name, sms...) 956 return s.ActualU(), err 957} 958 959// FieldU3 adds a field and reads 3 bit unsigned integer in current endian 960func (d *D) FieldU3(name string, sms ...scalar.Mapper) uint64 { 961 return d.FieldScalarU3(name, sms...).ActualU() 962} 963 964// Reader U4 965 966// TryU4 tries to read 4 bit unsigned integer in current endian 967func (d *D) TryU4() (uint64, error) { return d.tryUE(4, d.Endian) } 968 969// U4 reads 4 bit unsigned integer in current endian 970func (d *D) U4() uint64 { 971 v, err := d.tryUE(4, d.Endian) 972 if err != nil { 973 panic(IOError{Err: err, Op: "U4", Pos: d.Pos()}) 974 } 975 return v 976} 977 978// TryFieldScalarU4 tries to add a field and read 4 bit unsigned integer in current endian 979func (d *D) TryFieldScalarU4(name string, sms ...scalar.Mapper) (*scalar.S, error) { 980 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 981 v, err := d.tryUE(4, d.Endian) 982 s.Actual = v 983 return s, err 984 }, sms...) 985 if err != nil { 986 return nil, err 987 } 988 return s, err 989} 990 991// FieldScalarU4 adds a field and reads 4 bit unsigned integer in current endian 992func (d *D) FieldScalarU4(name string, sms ...scalar.Mapper) *scalar.S { 993 s, err := d.TryFieldScalarU4(name, sms...) 994 if err != nil { 995 panic(IOError{Err: err, Name: name, Op: "U4", Pos: d.Pos()}) 996 } 997 return s 998} 999 1000// TryFieldU4 tries to add a field and read 4 bit unsigned integer in current endian 1001func (d *D) TryFieldU4(name string, sms ...scalar.Mapper) (uint64, error) { 1002 s, err := d.TryFieldScalarU4(name, sms...) 1003 return s.ActualU(), err 1004} 1005 1006// FieldU4 adds a field and reads 4 bit unsigned integer in current endian 1007func (d *D) FieldU4(name string, sms ...scalar.Mapper) uint64 { 1008 return d.FieldScalarU4(name, sms...).ActualU() 1009} 1010 1011// Reader U5 1012 1013// TryU5 tries to read 5 bit unsigned integer in current endian 1014func (d *D) TryU5() (uint64, error) { return d.tryUE(5, d.Endian) } 1015 1016// U5 reads 5 bit unsigned integer in current endian 1017func (d *D) U5() uint64 { 1018 v, err := d.tryUE(5, d.Endian) 1019 if err != nil { 1020 panic(IOError{Err: err, Op: "U5", Pos: d.Pos()}) 1021 } 1022 return v 1023} 1024 1025// TryFieldScalarU5 tries to add a field and read 5 bit unsigned integer in current endian 1026func (d *D) TryFieldScalarU5(name string, sms ...scalar.Mapper) (*scalar.S, error) { 1027 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 1028 v, err := d.tryUE(5, d.Endian) 1029 s.Actual = v 1030 return s, err 1031 }, sms...) 1032 if err != nil { 1033 return nil, err 1034 } 1035 return s, err 1036} 1037 1038// FieldScalarU5 adds a field and reads 5 bit unsigned integer in current endian 1039func (d *D) FieldScalarU5(name string, sms ...scalar.Mapper) *scalar.S { 1040 s, err := d.TryFieldScalarU5(name, sms...) 1041 if err != nil { 1042 panic(IOError{Err: err, Name: name, Op: "U5", Pos: d.Pos()}) 1043 } 1044 return s 1045} 1046 1047// TryFieldU5 tries to add a field and read 5 bit unsigned integer in current endian 1048func (d *D) TryFieldU5(name string, sms ...scalar.Mapper) (uint64, error) { 1049 s, err := d.TryFieldScalarU5(name, sms...) 1050 return s.ActualU(), err 1051} 1052 1053// FieldU5 adds a field and reads 5 bit unsigned integer in current endian 1054func (d *D) FieldU5(name string, sms ...scalar.Mapper) uint64 { 1055 return d.FieldScalarU5(name, sms...).ActualU() 1056} 1057 1058// Reader U6 1059 1060// TryU6 tries to read 6 bit unsigned integer in current endian 1061func (d *D) TryU6() (uint64, error) { return d.tryUE(6, d.Endian) } 1062 1063// U6 reads 6 bit unsigned integer in current endian 1064func (d *D) U6() uint64 { 1065 v, err := d.tryUE(6, d.Endian) 1066 if err != nil { 1067 panic(IOError{Err: err, Op: "U6", Pos: d.Pos()}) 1068 } 1069 return v 1070} 1071 1072// TryFieldScalarU6 tries to add a field and read 6 bit unsigned integer in current endian 1073func (d *D) TryFieldScalarU6(name string, sms ...scalar.Mapper) (*scalar.S, error) { 1074 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 1075 v, err := d.tryUE(6, d.Endian) 1076 s.Actual = v 1077 return s, err 1078 }, sms...) 1079 if err != nil { 1080 return nil, err 1081 } 1082 return s, err 1083} 1084 1085// FieldScalarU6 adds a field and reads 6 bit unsigned integer in current endian 1086func (d *D) FieldScalarU6(name string, sms ...scalar.Mapper) *scalar.S { 1087 s, err := d.TryFieldScalarU6(name, sms...) 1088 if err != nil { 1089 panic(IOError{Err: err, Name: name, Op: "U6", Pos: d.Pos()}) 1090 } 1091 return s 1092} 1093 1094// TryFieldU6 tries to add a field and read 6 bit unsigned integer in current endian 1095func (d *D) TryFieldU6(name string, sms ...scalar.Mapper) (uint64, error) { 1096 s, err := d.TryFieldScalarU6(name, sms...) 1097 return s.ActualU(), err 1098} 1099 1100// FieldU6 adds a field and reads 6 bit unsigned integer in current endian 1101func (d *D) FieldU6(name string, sms ...scalar.Mapper) uint64 { 1102 return d.FieldScalarU6(name, sms...).ActualU() 1103} 1104 1105// Reader U7 1106 1107// TryU7 tries to read 7 bit unsigned integer in current endian 1108func (d *D) TryU7() (uint64, error) { return d.tryUE(7, d.Endian) } 1109 1110// U7 reads 7 bit unsigned integer in current endian 1111func (d *D) U7() uint64 { 1112 v, err := d.tryUE(7, d.Endian) 1113 if err != nil { 1114 panic(IOError{Err: err, Op: "U7", Pos: d.Pos()}) 1115 } 1116 return v 1117} 1118 1119// TryFieldScalarU7 tries to add a field and read 7 bit unsigned integer in current endian 1120func (d *D) TryFieldScalarU7(name string, sms ...scalar.Mapper) (*scalar.S, error) { 1121 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 1122 v, err := d.tryUE(7, d.Endian) 1123 s.Actual = v 1124 return s, err 1125 }, sms...) 1126 if err != nil { 1127 return nil, err 1128 } 1129 return s, err 1130} 1131 1132// FieldScalarU7 adds a field and reads 7 bit unsigned integer in current endian 1133func (d *D) FieldScalarU7(name string, sms ...scalar.Mapper) *scalar.S { 1134 s, err := d.TryFieldScalarU7(name, sms...) 1135 if err != nil { 1136 panic(IOError{Err: err, Name: name, Op: "U7", Pos: d.Pos()}) 1137 } 1138 return s 1139} 1140 1141// TryFieldU7 tries to add a field and read 7 bit unsigned integer in current endian 1142func (d *D) TryFieldU7(name string, sms ...scalar.Mapper) (uint64, error) { 1143 s, err := d.TryFieldScalarU7(name, sms...) 1144 return s.ActualU(), err 1145} 1146 1147// FieldU7 adds a field and reads 7 bit unsigned integer in current endian 1148func (d *D) FieldU7(name string, sms ...scalar.Mapper) uint64 { 1149 return d.FieldScalarU7(name, sms...).ActualU() 1150} 1151 1152// Reader U8 1153 1154// TryU8 tries to read 8 bit unsigned integer in current endian 1155func (d *D) TryU8() (uint64, error) { return d.tryUE(8, d.Endian) } 1156 1157// U8 reads 8 bit unsigned integer in current endian 1158func (d *D) U8() uint64 { 1159 v, err := d.tryUE(8, d.Endian) 1160 if err != nil { 1161 panic(IOError{Err: err, Op: "U8", Pos: d.Pos()}) 1162 } 1163 return v 1164} 1165 1166// TryFieldScalarU8 tries to add a field and read 8 bit unsigned integer in current endian 1167func (d *D) TryFieldScalarU8(name string, sms ...scalar.Mapper) (*scalar.S, error) { 1168 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 1169 v, err := d.tryUE(8, d.Endian) 1170 s.Actual = v 1171 return s, err 1172 }, sms...) 1173 if err != nil { 1174 return nil, err 1175 } 1176 return s, err 1177} 1178 1179// FieldScalarU8 adds a field and reads 8 bit unsigned integer in current endian 1180func (d *D) FieldScalarU8(name string, sms ...scalar.Mapper) *scalar.S { 1181 s, err := d.TryFieldScalarU8(name, sms...) 1182 if err != nil { 1183 panic(IOError{Err: err, Name: name, Op: "U8", Pos: d.Pos()}) 1184 } 1185 return s 1186} 1187 1188// TryFieldU8 tries to add a field and read 8 bit unsigned integer in current endian 1189func (d *D) TryFieldU8(name string, sms ...scalar.Mapper) (uint64, error) { 1190 s, err := d.TryFieldScalarU8(name, sms...) 1191 return s.ActualU(), err 1192} 1193 1194// FieldU8 adds a field and reads 8 bit unsigned integer in current endian 1195func (d *D) FieldU8(name string, sms ...scalar.Mapper) uint64 { 1196 return d.FieldScalarU8(name, sms...).ActualU() 1197} 1198 1199// Reader U9 1200 1201// TryU9 tries to read 9 bit unsigned integer in current endian 1202func (d *D) TryU9() (uint64, error) { return d.tryUE(9, d.Endian) } 1203 1204// U9 reads 9 bit unsigned integer in current endian 1205func (d *D) U9() uint64 { 1206 v, err := d.tryUE(9, d.Endian) 1207 if err != nil { 1208 panic(IOError{Err: err, Op: "U9", Pos: d.Pos()}) 1209 } 1210 return v 1211} 1212 1213// TryFieldScalarU9 tries to add a field and read 9 bit unsigned integer in current endian 1214func (d *D) TryFieldScalarU9(name string, sms ...scalar.Mapper) (*scalar.S, error) { 1215 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 1216 v, err := d.tryUE(9, d.Endian) 1217 s.Actual = v 1218 return s, err 1219 }, sms...) 1220 if err != nil { 1221 return nil, err 1222 } 1223 return s, err 1224} 1225 1226// FieldScalarU9 adds a field and reads 9 bit unsigned integer in current endian 1227func (d *D) FieldScalarU9(name string, sms ...scalar.Mapper) *scalar.S { 1228 s, err := d.TryFieldScalarU9(name, sms...) 1229 if err != nil { 1230 panic(IOError{Err: err, Name: name, Op: "U9", Pos: d.Pos()}) 1231 } 1232 return s 1233} 1234 1235// TryFieldU9 tries to add a field and read 9 bit unsigned integer in current endian 1236func (d *D) TryFieldU9(name string, sms ...scalar.Mapper) (uint64, error) { 1237 s, err := d.TryFieldScalarU9(name, sms...) 1238 return s.ActualU(), err 1239} 1240 1241// FieldU9 adds a field and reads 9 bit unsigned integer in current endian 1242func (d *D) FieldU9(name string, sms ...scalar.Mapper) uint64 { 1243 return d.FieldScalarU9(name, sms...).ActualU() 1244} 1245 1246// Reader U10 1247 1248// TryU10 tries to read 10 bit unsigned integer in current endian 1249func (d *D) TryU10() (uint64, error) { return d.tryUE(10, d.Endian) } 1250 1251// U10 reads 10 bit unsigned integer in current endian 1252func (d *D) U10() uint64 { 1253 v, err := d.tryUE(10, d.Endian) 1254 if err != nil { 1255 panic(IOError{Err: err, Op: "U10", Pos: d.Pos()}) 1256 } 1257 return v 1258} 1259 1260// TryFieldScalarU10 tries to add a field and read 10 bit unsigned integer in current endian 1261func (d *D) TryFieldScalarU10(name string, sms ...scalar.Mapper) (*scalar.S, error) { 1262 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 1263 v, err := d.tryUE(10, d.Endian) 1264 s.Actual = v 1265 return s, err 1266 }, sms...) 1267 if err != nil { 1268 return nil, err 1269 } 1270 return s, err 1271} 1272 1273// FieldScalarU10 adds a field and reads 10 bit unsigned integer in current endian 1274func (d *D) FieldScalarU10(name string, sms ...scalar.Mapper) *scalar.S { 1275 s, err := d.TryFieldScalarU10(name, sms...) 1276 if err != nil { 1277 panic(IOError{Err: err, Name: name, Op: "U10", Pos: d.Pos()}) 1278 } 1279 return s 1280} 1281 1282// TryFieldU10 tries to add a field and read 10 bit unsigned integer in current endian 1283func (d *D) TryFieldU10(name string, sms ...scalar.Mapper) (uint64, error) { 1284 s, err := d.TryFieldScalarU10(name, sms...) 1285 return s.ActualU(), err 1286} 1287 1288// FieldU10 adds a field and reads 10 bit unsigned integer in current endian 1289func (d *D) FieldU10(name string, sms ...scalar.Mapper) uint64 { 1290 return d.FieldScalarU10(name, sms...).ActualU() 1291} 1292 1293// Reader U11 1294 1295// TryU11 tries to read 11 bit unsigned integer in current endian 1296func (d *D) TryU11() (uint64, error) { return d.tryUE(11, d.Endian) } 1297 1298// U11 reads 11 bit unsigned integer in current endian 1299func (d *D) U11() uint64 { 1300 v, err := d.tryUE(11, d.Endian) 1301 if err != nil { 1302 panic(IOError{Err: err, Op: "U11", Pos: d.Pos()}) 1303 } 1304 return v 1305} 1306 1307// TryFieldScalarU11 tries to add a field and read 11 bit unsigned integer in current endian 1308func (d *D) TryFieldScalarU11(name string, sms ...scalar.Mapper) (*scalar.S, error) { 1309 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 1310 v, err := d.tryUE(11, d.Endian) 1311 s.Actual = v 1312 return s, err 1313 }, sms...) 1314 if err != nil { 1315 return nil, err 1316 } 1317 return s, err 1318} 1319 1320// FieldScalarU11 adds a field and reads 11 bit unsigned integer in current endian 1321func (d *D) FieldScalarU11(name string, sms ...scalar.Mapper) *scalar.S { 1322 s, err := d.TryFieldScalarU11(name, sms...) 1323 if err != nil { 1324 panic(IOError{Err: err, Name: name, Op: "U11", Pos: d.Pos()}) 1325 } 1326 return s 1327} 1328 1329// TryFieldU11 tries to add a field and read 11 bit unsigned integer in current endian 1330func (d *D) TryFieldU11(name string, sms ...scalar.Mapper) (uint64, error) { 1331 s, err := d.TryFieldScalarU11(name, sms...) 1332 return s.ActualU(), err 1333} 1334 1335// FieldU11 adds a field and reads 11 bit unsigned integer in current endian 1336func (d *D) FieldU11(name string, sms ...scalar.Mapper) uint64 { 1337 return d.FieldScalarU11(name, sms...).ActualU() 1338} 1339 1340// Reader U12 1341 1342// TryU12 tries to read 12 bit unsigned integer in current endian 1343func (d *D) TryU12() (uint64, error) { return d.tryUE(12, d.Endian) } 1344 1345// U12 reads 12 bit unsigned integer in current endian 1346func (d *D) U12() uint64 { 1347 v, err := d.tryUE(12, d.Endian) 1348 if err != nil { 1349 panic(IOError{Err: err, Op: "U12", Pos: d.Pos()}) 1350 } 1351 return v 1352} 1353 1354// TryFieldScalarU12 tries to add a field and read 12 bit unsigned integer in current endian 1355func (d *D) TryFieldScalarU12(name string, sms ...scalar.Mapper) (*scalar.S, error) { 1356 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 1357 v, err := d.tryUE(12, d.Endian) 1358 s.Actual = v 1359 return s, err 1360 }, sms...) 1361 if err != nil { 1362 return nil, err 1363 } 1364 return s, err 1365} 1366 1367// FieldScalarU12 adds a field and reads 12 bit unsigned integer in current endian 1368func (d *D) FieldScalarU12(name string, sms ...scalar.Mapper) *scalar.S { 1369 s, err := d.TryFieldScalarU12(name, sms...) 1370 if err != nil { 1371 panic(IOError{Err: err, Name: name, Op: "U12", Pos: d.Pos()}) 1372 } 1373 return s 1374} 1375 1376// TryFieldU12 tries to add a field and read 12 bit unsigned integer in current endian 1377func (d *D) TryFieldU12(name string, sms ...scalar.Mapper) (uint64, error) { 1378 s, err := d.TryFieldScalarU12(name, sms...) 1379 return s.ActualU(), err 1380} 1381 1382// FieldU12 adds a field and reads 12 bit unsigned integer in current endian 1383func (d *D) FieldU12(name string, sms ...scalar.Mapper) uint64 { 1384 return d.FieldScalarU12(name, sms...).ActualU() 1385} 1386 1387// Reader U13 1388 1389// TryU13 tries to read 13 bit unsigned integer in current endian 1390func (d *D) TryU13() (uint64, error) { return d.tryUE(13, d.Endian) } 1391 1392// U13 reads 13 bit unsigned integer in current endian 1393func (d *D) U13() uint64 { 1394 v, err := d.tryUE(13, d.Endian) 1395 if err != nil { 1396 panic(IOError{Err: err, Op: "U13", Pos: d.Pos()}) 1397 } 1398 return v 1399} 1400 1401// TryFieldScalarU13 tries to add a field and read 13 bit unsigned integer in current endian 1402func (d *D) TryFieldScalarU13(name string, sms ...scalar.Mapper) (*scalar.S, error) { 1403 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 1404 v, err := d.tryUE(13, d.Endian) 1405 s.Actual = v 1406 return s, err 1407 }, sms...) 1408 if err != nil { 1409 return nil, err 1410 } 1411 return s, err 1412} 1413 1414// FieldScalarU13 adds a field and reads 13 bit unsigned integer in current endian 1415func (d *D) FieldScalarU13(name string, sms ...scalar.Mapper) *scalar.S { 1416 s, err := d.TryFieldScalarU13(name, sms...) 1417 if err != nil { 1418 panic(IOError{Err: err, Name: name, Op: "U13", Pos: d.Pos()}) 1419 } 1420 return s 1421} 1422 1423// TryFieldU13 tries to add a field and read 13 bit unsigned integer in current endian 1424func (d *D) TryFieldU13(name string, sms ...scalar.Mapper) (uint64, error) { 1425 s, err := d.TryFieldScalarU13(name, sms...) 1426 return s.ActualU(), err 1427} 1428 1429// FieldU13 adds a field and reads 13 bit unsigned integer in current endian 1430func (d *D) FieldU13(name string, sms ...scalar.Mapper) uint64 { 1431 return d.FieldScalarU13(name, sms...).ActualU() 1432} 1433 1434// Reader U14 1435 1436// TryU14 tries to read 14 bit unsigned integer in current endian 1437func (d *D) TryU14() (uint64, error) { return d.tryUE(14, d.Endian) } 1438 1439// U14 reads 14 bit unsigned integer in current endian 1440func (d *D) U14() uint64 { 1441 v, err := d.tryUE(14, d.Endian) 1442 if err != nil { 1443 panic(IOError{Err: err, Op: "U14", Pos: d.Pos()}) 1444 } 1445 return v 1446} 1447 1448// TryFieldScalarU14 tries to add a field and read 14 bit unsigned integer in current endian 1449func (d *D) TryFieldScalarU14(name string, sms ...scalar.Mapper) (*scalar.S, error) { 1450 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 1451 v, err := d.tryUE(14, d.Endian) 1452 s.Actual = v 1453 return s, err 1454 }, sms...) 1455 if err != nil { 1456 return nil, err 1457 } 1458 return s, err 1459} 1460 1461// FieldScalarU14 adds a field and reads 14 bit unsigned integer in current endian 1462func (d *D) FieldScalarU14(name string, sms ...scalar.Mapper) *scalar.S { 1463 s, err := d.TryFieldScalarU14(name, sms...) 1464 if err != nil { 1465 panic(IOError{Err: err, Name: name, Op: "U14", Pos: d.Pos()}) 1466 } 1467 return s 1468} 1469 1470// TryFieldU14 tries to add a field and read 14 bit unsigned integer in current endian 1471func (d *D) TryFieldU14(name string, sms ...scalar.Mapper) (uint64, error) { 1472 s, err := d.TryFieldScalarU14(name, sms...) 1473 return s.ActualU(), err 1474} 1475 1476// FieldU14 adds a field and reads 14 bit unsigned integer in current endian 1477func (d *D) FieldU14(name string, sms ...scalar.Mapper) uint64 { 1478 return d.FieldScalarU14(name, sms...).ActualU() 1479} 1480 1481// Reader U15 1482 1483// TryU15 tries to read 15 bit unsigned integer in current endian 1484func (d *D) TryU15() (uint64, error) { return d.tryUE(15, d.Endian) } 1485 1486// U15 reads 15 bit unsigned integer in current endian 1487func (d *D) U15() uint64 { 1488 v, err := d.tryUE(15, d.Endian) 1489 if err != nil { 1490 panic(IOError{Err: err, Op: "U15", Pos: d.Pos()}) 1491 } 1492 return v 1493} 1494 1495// TryFieldScalarU15 tries to add a field and read 15 bit unsigned integer in current endian 1496func (d *D) TryFieldScalarU15(name string, sms ...scalar.Mapper) (*scalar.S, error) { 1497 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 1498 v, err := d.tryUE(15, d.Endian) 1499 s.Actual = v 1500 return s, err 1501 }, sms...) 1502 if err != nil { 1503 return nil, err 1504 } 1505 return s, err 1506} 1507 1508// FieldScalarU15 adds a field and reads 15 bit unsigned integer in current endian 1509func (d *D) FieldScalarU15(name string, sms ...scalar.Mapper) *scalar.S { 1510 s, err := d.TryFieldScalarU15(name, sms...) 1511 if err != nil { 1512 panic(IOError{Err: err, Name: name, Op: "U15", Pos: d.Pos()}) 1513 } 1514 return s 1515} 1516 1517// TryFieldU15 tries to add a field and read 15 bit unsigned integer in current endian 1518func (d *D) TryFieldU15(name string, sms ...scalar.Mapper) (uint64, error) { 1519 s, err := d.TryFieldScalarU15(name, sms...) 1520 return s.ActualU(), err 1521} 1522 1523// FieldU15 adds a field and reads 15 bit unsigned integer in current endian 1524func (d *D) FieldU15(name string, sms ...scalar.Mapper) uint64 { 1525 return d.FieldScalarU15(name, sms...).ActualU() 1526} 1527 1528// Reader U16 1529 1530// TryU16 tries to read 16 bit unsigned integer in current endian 1531func (d *D) TryU16() (uint64, error) { return d.tryUE(16, d.Endian) } 1532 1533// U16 reads 16 bit unsigned integer in current endian 1534func (d *D) U16() uint64 { 1535 v, err := d.tryUE(16, d.Endian) 1536 if err != nil { 1537 panic(IOError{Err: err, Op: "U16", Pos: d.Pos()}) 1538 } 1539 return v 1540} 1541 1542// TryFieldScalarU16 tries to add a field and read 16 bit unsigned integer in current endian 1543func (d *D) TryFieldScalarU16(name string, sms ...scalar.Mapper) (*scalar.S, error) { 1544 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 1545 v, err := d.tryUE(16, d.Endian) 1546 s.Actual = v 1547 return s, err 1548 }, sms...) 1549 if err != nil { 1550 return nil, err 1551 } 1552 return s, err 1553} 1554 1555// FieldScalarU16 adds a field and reads 16 bit unsigned integer in current endian 1556func (d *D) FieldScalarU16(name string, sms ...scalar.Mapper) *scalar.S { 1557 s, err := d.TryFieldScalarU16(name, sms...) 1558 if err != nil { 1559 panic(IOError{Err: err, Name: name, Op: "U16", Pos: d.Pos()}) 1560 } 1561 return s 1562} 1563 1564// TryFieldU16 tries to add a field and read 16 bit unsigned integer in current endian 1565func (d *D) TryFieldU16(name string, sms ...scalar.Mapper) (uint64, error) { 1566 s, err := d.TryFieldScalarU16(name, sms...) 1567 return s.ActualU(), err 1568} 1569 1570// FieldU16 adds a field and reads 16 bit unsigned integer in current endian 1571func (d *D) FieldU16(name string, sms ...scalar.Mapper) uint64 { 1572 return d.FieldScalarU16(name, sms...).ActualU() 1573} 1574 1575// Reader U17 1576 1577// TryU17 tries to read 17 bit unsigned integer in current endian 1578func (d *D) TryU17() (uint64, error) { return d.tryUE(17, d.Endian) } 1579 1580// U17 reads 17 bit unsigned integer in current endian 1581func (d *D) U17() uint64 { 1582 v, err := d.tryUE(17, d.Endian) 1583 if err != nil { 1584 panic(IOError{Err: err, Op: "U17", Pos: d.Pos()}) 1585 } 1586 return v 1587} 1588 1589// TryFieldScalarU17 tries to add a field and read 17 bit unsigned integer in current endian 1590func (d *D) TryFieldScalarU17(name string, sms ...scalar.Mapper) (*scalar.S, error) { 1591 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 1592 v, err := d.tryUE(17, d.Endian) 1593 s.Actual = v 1594 return s, err 1595 }, sms...) 1596 if err != nil { 1597 return nil, err 1598 } 1599 return s, err 1600} 1601 1602// FieldScalarU17 adds a field and reads 17 bit unsigned integer in current endian 1603func (d *D) FieldScalarU17(name string, sms ...scalar.Mapper) *scalar.S { 1604 s, err := d.TryFieldScalarU17(name, sms...) 1605 if err != nil { 1606 panic(IOError{Err: err, Name: name, Op: "U17", Pos: d.Pos()}) 1607 } 1608 return s 1609} 1610 1611// TryFieldU17 tries to add a field and read 17 bit unsigned integer in current endian 1612func (d *D) TryFieldU17(name string, sms ...scalar.Mapper) (uint64, error) { 1613 s, err := d.TryFieldScalarU17(name, sms...) 1614 return s.ActualU(), err 1615} 1616 1617// FieldU17 adds a field and reads 17 bit unsigned integer in current endian 1618func (d *D) FieldU17(name string, sms ...scalar.Mapper) uint64 { 1619 return d.FieldScalarU17(name, sms...).ActualU() 1620} 1621 1622// Reader U18 1623 1624// TryU18 tries to read 18 bit unsigned integer in current endian 1625func (d *D) TryU18() (uint64, error) { return d.tryUE(18, d.Endian) } 1626 1627// U18 reads 18 bit unsigned integer in current endian 1628func (d *D) U18() uint64 { 1629 v, err := d.tryUE(18, d.Endian) 1630 if err != nil { 1631 panic(IOError{Err: err, Op: "U18", Pos: d.Pos()}) 1632 } 1633 return v 1634} 1635 1636// TryFieldScalarU18 tries to add a field and read 18 bit unsigned integer in current endian 1637func (d *D) TryFieldScalarU18(name string, sms ...scalar.Mapper) (*scalar.S, error) { 1638 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 1639 v, err := d.tryUE(18, d.Endian) 1640 s.Actual = v 1641 return s, err 1642 }, sms...) 1643 if err != nil { 1644 return nil, err 1645 } 1646 return s, err 1647} 1648 1649// FieldScalarU18 adds a field and reads 18 bit unsigned integer in current endian 1650func (d *D) FieldScalarU18(name string, sms ...scalar.Mapper) *scalar.S { 1651 s, err := d.TryFieldScalarU18(name, sms...) 1652 if err != nil { 1653 panic(IOError{Err: err, Name: name, Op: "U18", Pos: d.Pos()}) 1654 } 1655 return s 1656} 1657 1658// TryFieldU18 tries to add a field and read 18 bit unsigned integer in current endian 1659func (d *D) TryFieldU18(name string, sms ...scalar.Mapper) (uint64, error) { 1660 s, err := d.TryFieldScalarU18(name, sms...) 1661 return s.ActualU(), err 1662} 1663 1664// FieldU18 adds a field and reads 18 bit unsigned integer in current endian 1665func (d *D) FieldU18(name string, sms ...scalar.Mapper) uint64 { 1666 return d.FieldScalarU18(name, sms...).ActualU() 1667} 1668 1669// Reader U19 1670 1671// TryU19 tries to read 19 bit unsigned integer in current endian 1672func (d *D) TryU19() (uint64, error) { return d.tryUE(19, d.Endian) } 1673 1674// U19 reads 19 bit unsigned integer in current endian 1675func (d *D) U19() uint64 { 1676 v, err := d.tryUE(19, d.Endian) 1677 if err != nil { 1678 panic(IOError{Err: err, Op: "U19", Pos: d.Pos()}) 1679 } 1680 return v 1681} 1682 1683// TryFieldScalarU19 tries to add a field and read 19 bit unsigned integer in current endian 1684func (d *D) TryFieldScalarU19(name string, sms ...scalar.Mapper) (*scalar.S, error) { 1685 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 1686 v, err := d.tryUE(19, d.Endian) 1687 s.Actual = v 1688 return s, err 1689 }, sms...) 1690 if err != nil { 1691 return nil, err 1692 } 1693 return s, err 1694} 1695 1696// FieldScalarU19 adds a field and reads 19 bit unsigned integer in current endian 1697func (d *D) FieldScalarU19(name string, sms ...scalar.Mapper) *scalar.S { 1698 s, err := d.TryFieldScalarU19(name, sms...) 1699 if err != nil { 1700 panic(IOError{Err: err, Name: name, Op: "U19", Pos: d.Pos()}) 1701 } 1702 return s 1703} 1704 1705// TryFieldU19 tries to add a field and read 19 bit unsigned integer in current endian 1706func (d *D) TryFieldU19(name string, sms ...scalar.Mapper) (uint64, error) { 1707 s, err := d.TryFieldScalarU19(name, sms...) 1708 return s.ActualU(), err 1709} 1710 1711// FieldU19 adds a field and reads 19 bit unsigned integer in current endian 1712func (d *D) FieldU19(name string, sms ...scalar.Mapper) uint64 { 1713 return d.FieldScalarU19(name, sms...).ActualU() 1714} 1715 1716// Reader U20 1717 1718// TryU20 tries to read 20 bit unsigned integer in current endian 1719func (d *D) TryU20() (uint64, error) { return d.tryUE(20, d.Endian) } 1720 1721// U20 reads 20 bit unsigned integer in current endian 1722func (d *D) U20() uint64 { 1723 v, err := d.tryUE(20, d.Endian) 1724 if err != nil { 1725 panic(IOError{Err: err, Op: "U20", Pos: d.Pos()}) 1726 } 1727 return v 1728} 1729 1730// TryFieldScalarU20 tries to add a field and read 20 bit unsigned integer in current endian 1731func (d *D) TryFieldScalarU20(name string, sms ...scalar.Mapper) (*scalar.S, error) { 1732 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 1733 v, err := d.tryUE(20, d.Endian) 1734 s.Actual = v 1735 return s, err 1736 }, sms...) 1737 if err != nil { 1738 return nil, err 1739 } 1740 return s, err 1741} 1742 1743// FieldScalarU20 adds a field and reads 20 bit unsigned integer in current endian 1744func (d *D) FieldScalarU20(name string, sms ...scalar.Mapper) *scalar.S { 1745 s, err := d.TryFieldScalarU20(name, sms...) 1746 if err != nil { 1747 panic(IOError{Err: err, Name: name, Op: "U20", Pos: d.Pos()}) 1748 } 1749 return s 1750} 1751 1752// TryFieldU20 tries to add a field and read 20 bit unsigned integer in current endian 1753func (d *D) TryFieldU20(name string, sms ...scalar.Mapper) (uint64, error) { 1754 s, err := d.TryFieldScalarU20(name, sms...) 1755 return s.ActualU(), err 1756} 1757 1758// FieldU20 adds a field and reads 20 bit unsigned integer in current endian 1759func (d *D) FieldU20(name string, sms ...scalar.Mapper) uint64 { 1760 return d.FieldScalarU20(name, sms...).ActualU() 1761} 1762 1763// Reader U21 1764 1765// TryU21 tries to read 21 bit unsigned integer in current endian 1766func (d *D) TryU21() (uint64, error) { return d.tryUE(21, d.Endian) } 1767 1768// U21 reads 21 bit unsigned integer in current endian 1769func (d *D) U21() uint64 { 1770 v, err := d.tryUE(21, d.Endian) 1771 if err != nil { 1772 panic(IOError{Err: err, Op: "U21", Pos: d.Pos()}) 1773 } 1774 return v 1775} 1776 1777// TryFieldScalarU21 tries to add a field and read 21 bit unsigned integer in current endian 1778func (d *D) TryFieldScalarU21(name string, sms ...scalar.Mapper) (*scalar.S, error) { 1779 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 1780 v, err := d.tryUE(21, d.Endian) 1781 s.Actual = v 1782 return s, err 1783 }, sms...) 1784 if err != nil { 1785 return nil, err 1786 } 1787 return s, err 1788} 1789 1790// FieldScalarU21 adds a field and reads 21 bit unsigned integer in current endian 1791func (d *D) FieldScalarU21(name string, sms ...scalar.Mapper) *scalar.S { 1792 s, err := d.TryFieldScalarU21(name, sms...) 1793 if err != nil { 1794 panic(IOError{Err: err, Name: name, Op: "U21", Pos: d.Pos()}) 1795 } 1796 return s 1797} 1798 1799// TryFieldU21 tries to add a field and read 21 bit unsigned integer in current endian 1800func (d *D) TryFieldU21(name string, sms ...scalar.Mapper) (uint64, error) { 1801 s, err := d.TryFieldScalarU21(name, sms...) 1802 return s.ActualU(), err 1803} 1804 1805// FieldU21 adds a field and reads 21 bit unsigned integer in current endian 1806func (d *D) FieldU21(name string, sms ...scalar.Mapper) uint64 { 1807 return d.FieldScalarU21(name, sms...).ActualU() 1808} 1809 1810// Reader U22 1811 1812// TryU22 tries to read 22 bit unsigned integer in current endian 1813func (d *D) TryU22() (uint64, error) { return d.tryUE(22, d.Endian) } 1814 1815// U22 reads 22 bit unsigned integer in current endian 1816func (d *D) U22() uint64 { 1817 v, err := d.tryUE(22, d.Endian) 1818 if err != nil { 1819 panic(IOError{Err: err, Op: "U22", Pos: d.Pos()}) 1820 } 1821 return v 1822} 1823 1824// TryFieldScalarU22 tries to add a field and read 22 bit unsigned integer in current endian 1825func (d *D) TryFieldScalarU22(name string, sms ...scalar.Mapper) (*scalar.S, error) { 1826 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 1827 v, err := d.tryUE(22, d.Endian) 1828 s.Actual = v 1829 return s, err 1830 }, sms...) 1831 if err != nil { 1832 return nil, err 1833 } 1834 return s, err 1835} 1836 1837// FieldScalarU22 adds a field and reads 22 bit unsigned integer in current endian 1838func (d *D) FieldScalarU22(name string, sms ...scalar.Mapper) *scalar.S { 1839 s, err := d.TryFieldScalarU22(name, sms...) 1840 if err != nil { 1841 panic(IOError{Err: err, Name: name, Op: "U22", Pos: d.Pos()}) 1842 } 1843 return s 1844} 1845 1846// TryFieldU22 tries to add a field and read 22 bit unsigned integer in current endian 1847func (d *D) TryFieldU22(name string, sms ...scalar.Mapper) (uint64, error) { 1848 s, err := d.TryFieldScalarU22(name, sms...) 1849 return s.ActualU(), err 1850} 1851 1852// FieldU22 adds a field and reads 22 bit unsigned integer in current endian 1853func (d *D) FieldU22(name string, sms ...scalar.Mapper) uint64 { 1854 return d.FieldScalarU22(name, sms...).ActualU() 1855} 1856 1857// Reader U23 1858 1859// TryU23 tries to read 23 bit unsigned integer in current endian 1860func (d *D) TryU23() (uint64, error) { return d.tryUE(23, d.Endian) } 1861 1862// U23 reads 23 bit unsigned integer in current endian 1863func (d *D) U23() uint64 { 1864 v, err := d.tryUE(23, d.Endian) 1865 if err != nil { 1866 panic(IOError{Err: err, Op: "U23", Pos: d.Pos()}) 1867 } 1868 return v 1869} 1870 1871// TryFieldScalarU23 tries to add a field and read 23 bit unsigned integer in current endian 1872func (d *D) TryFieldScalarU23(name string, sms ...scalar.Mapper) (*scalar.S, error) { 1873 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 1874 v, err := d.tryUE(23, d.Endian) 1875 s.Actual = v 1876 return s, err 1877 }, sms...) 1878 if err != nil { 1879 return nil, err 1880 } 1881 return s, err 1882} 1883 1884// FieldScalarU23 adds a field and reads 23 bit unsigned integer in current endian 1885func (d *D) FieldScalarU23(name string, sms ...scalar.Mapper) *scalar.S { 1886 s, err := d.TryFieldScalarU23(name, sms...) 1887 if err != nil { 1888 panic(IOError{Err: err, Name: name, Op: "U23", Pos: d.Pos()}) 1889 } 1890 return s 1891} 1892 1893// TryFieldU23 tries to add a field and read 23 bit unsigned integer in current endian 1894func (d *D) TryFieldU23(name string, sms ...scalar.Mapper) (uint64, error) { 1895 s, err := d.TryFieldScalarU23(name, sms...) 1896 return s.ActualU(), err 1897} 1898 1899// FieldU23 adds a field and reads 23 bit unsigned integer in current endian 1900func (d *D) FieldU23(name string, sms ...scalar.Mapper) uint64 { 1901 return d.FieldScalarU23(name, sms...).ActualU() 1902} 1903 1904// Reader U24 1905 1906// TryU24 tries to read 24 bit unsigned integer in current endian 1907func (d *D) TryU24() (uint64, error) { return d.tryUE(24, d.Endian) } 1908 1909// U24 reads 24 bit unsigned integer in current endian 1910func (d *D) U24() uint64 { 1911 v, err := d.tryUE(24, d.Endian) 1912 if err != nil { 1913 panic(IOError{Err: err, Op: "U24", Pos: d.Pos()}) 1914 } 1915 return v 1916} 1917 1918// TryFieldScalarU24 tries to add a field and read 24 bit unsigned integer in current endian 1919func (d *D) TryFieldScalarU24(name string, sms ...scalar.Mapper) (*scalar.S, error) { 1920 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 1921 v, err := d.tryUE(24, d.Endian) 1922 s.Actual = v 1923 return s, err 1924 }, sms...) 1925 if err != nil { 1926 return nil, err 1927 } 1928 return s, err 1929} 1930 1931// FieldScalarU24 adds a field and reads 24 bit unsigned integer in current endian 1932func (d *D) FieldScalarU24(name string, sms ...scalar.Mapper) *scalar.S { 1933 s, err := d.TryFieldScalarU24(name, sms...) 1934 if err != nil { 1935 panic(IOError{Err: err, Name: name, Op: "U24", Pos: d.Pos()}) 1936 } 1937 return s 1938} 1939 1940// TryFieldU24 tries to add a field and read 24 bit unsigned integer in current endian 1941func (d *D) TryFieldU24(name string, sms ...scalar.Mapper) (uint64, error) { 1942 s, err := d.TryFieldScalarU24(name, sms...) 1943 return s.ActualU(), err 1944} 1945 1946// FieldU24 adds a field and reads 24 bit unsigned integer in current endian 1947func (d *D) FieldU24(name string, sms ...scalar.Mapper) uint64 { 1948 return d.FieldScalarU24(name, sms...).ActualU() 1949} 1950 1951// Reader U25 1952 1953// TryU25 tries to read 25 bit unsigned integer in current endian 1954func (d *D) TryU25() (uint64, error) { return d.tryUE(25, d.Endian) } 1955 1956// U25 reads 25 bit unsigned integer in current endian 1957func (d *D) U25() uint64 { 1958 v, err := d.tryUE(25, d.Endian) 1959 if err != nil { 1960 panic(IOError{Err: err, Op: "U25", Pos: d.Pos()}) 1961 } 1962 return v 1963} 1964 1965// TryFieldScalarU25 tries to add a field and read 25 bit unsigned integer in current endian 1966func (d *D) TryFieldScalarU25(name string, sms ...scalar.Mapper) (*scalar.S, error) { 1967 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 1968 v, err := d.tryUE(25, d.Endian) 1969 s.Actual = v 1970 return s, err 1971 }, sms...) 1972 if err != nil { 1973 return nil, err 1974 } 1975 return s, err 1976} 1977 1978// FieldScalarU25 adds a field and reads 25 bit unsigned integer in current endian 1979func (d *D) FieldScalarU25(name string, sms ...scalar.Mapper) *scalar.S { 1980 s, err := d.TryFieldScalarU25(name, sms...) 1981 if err != nil { 1982 panic(IOError{Err: err, Name: name, Op: "U25", Pos: d.Pos()}) 1983 } 1984 return s 1985} 1986 1987// TryFieldU25 tries to add a field and read 25 bit unsigned integer in current endian 1988func (d *D) TryFieldU25(name string, sms ...scalar.Mapper) (uint64, error) { 1989 s, err := d.TryFieldScalarU25(name, sms...) 1990 return s.ActualU(), err 1991} 1992 1993// FieldU25 adds a field and reads 25 bit unsigned integer in current endian 1994func (d *D) FieldU25(name string, sms ...scalar.Mapper) uint64 { 1995 return d.FieldScalarU25(name, sms...).ActualU() 1996} 1997 1998// Reader U26 1999 2000// TryU26 tries to read 26 bit unsigned integer in current endian 2001func (d *D) TryU26() (uint64, error) { return d.tryUE(26, d.Endian) } 2002 2003// U26 reads 26 bit unsigned integer in current endian 2004func (d *D) U26() uint64 { 2005 v, err := d.tryUE(26, d.Endian) 2006 if err != nil { 2007 panic(IOError{Err: err, Op: "U26", Pos: d.Pos()}) 2008 } 2009 return v 2010} 2011 2012// TryFieldScalarU26 tries to add a field and read 26 bit unsigned integer in current endian 2013func (d *D) TryFieldScalarU26(name string, sms ...scalar.Mapper) (*scalar.S, error) { 2014 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 2015 v, err := d.tryUE(26, d.Endian) 2016 s.Actual = v 2017 return s, err 2018 }, sms...) 2019 if err != nil { 2020 return nil, err 2021 } 2022 return s, err 2023} 2024 2025// FieldScalarU26 adds a field and reads 26 bit unsigned integer in current endian 2026func (d *D) FieldScalarU26(name string, sms ...scalar.Mapper) *scalar.S { 2027 s, err := d.TryFieldScalarU26(name, sms...) 2028 if err != nil { 2029 panic(IOError{Err: err, Name: name, Op: "U26", Pos: d.Pos()}) 2030 } 2031 return s 2032} 2033 2034// TryFieldU26 tries to add a field and read 26 bit unsigned integer in current endian 2035func (d *D) TryFieldU26(name string, sms ...scalar.Mapper) (uint64, error) { 2036 s, err := d.TryFieldScalarU26(name, sms...) 2037 return s.ActualU(), err 2038} 2039 2040// FieldU26 adds a field and reads 26 bit unsigned integer in current endian 2041func (d *D) FieldU26(name string, sms ...scalar.Mapper) uint64 { 2042 return d.FieldScalarU26(name, sms...).ActualU() 2043} 2044 2045// Reader U27 2046 2047// TryU27 tries to read 27 bit unsigned integer in current endian 2048func (d *D) TryU27() (uint64, error) { return d.tryUE(27, d.Endian) } 2049 2050// U27 reads 27 bit unsigned integer in current endian 2051func (d *D) U27() uint64 { 2052 v, err := d.tryUE(27, d.Endian) 2053 if err != nil { 2054 panic(IOError{Err: err, Op: "U27", Pos: d.Pos()}) 2055 } 2056 return v 2057} 2058 2059// TryFieldScalarU27 tries to add a field and read 27 bit unsigned integer in current endian 2060func (d *D) TryFieldScalarU27(name string, sms ...scalar.Mapper) (*scalar.S, error) { 2061 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 2062 v, err := d.tryUE(27, d.Endian) 2063 s.Actual = v 2064 return s, err 2065 }, sms...) 2066 if err != nil { 2067 return nil, err 2068 } 2069 return s, err 2070} 2071 2072// FieldScalarU27 adds a field and reads 27 bit unsigned integer in current endian 2073func (d *D) FieldScalarU27(name string, sms ...scalar.Mapper) *scalar.S { 2074 s, err := d.TryFieldScalarU27(name, sms...) 2075 if err != nil { 2076 panic(IOError{Err: err, Name: name, Op: "U27", Pos: d.Pos()}) 2077 } 2078 return s 2079} 2080 2081// TryFieldU27 tries to add a field and read 27 bit unsigned integer in current endian 2082func (d *D) TryFieldU27(name string, sms ...scalar.Mapper) (uint64, error) { 2083 s, err := d.TryFieldScalarU27(name, sms...) 2084 return s.ActualU(), err 2085} 2086 2087// FieldU27 adds a field and reads 27 bit unsigned integer in current endian 2088func (d *D) FieldU27(name string, sms ...scalar.Mapper) uint64 { 2089 return d.FieldScalarU27(name, sms...).ActualU() 2090} 2091 2092// Reader U28 2093 2094// TryU28 tries to read 28 bit unsigned integer in current endian 2095func (d *D) TryU28() (uint64, error) { return d.tryUE(28, d.Endian) } 2096 2097// U28 reads 28 bit unsigned integer in current endian 2098func (d *D) U28() uint64 { 2099 v, err := d.tryUE(28, d.Endian) 2100 if err != nil { 2101 panic(IOError{Err: err, Op: "U28", Pos: d.Pos()}) 2102 } 2103 return v 2104} 2105 2106// TryFieldScalarU28 tries to add a field and read 28 bit unsigned integer in current endian 2107func (d *D) TryFieldScalarU28(name string, sms ...scalar.Mapper) (*scalar.S, error) { 2108 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 2109 v, err := d.tryUE(28, d.Endian) 2110 s.Actual = v 2111 return s, err 2112 }, sms...) 2113 if err != nil { 2114 return nil, err 2115 } 2116 return s, err 2117} 2118 2119// FieldScalarU28 adds a field and reads 28 bit unsigned integer in current endian 2120func (d *D) FieldScalarU28(name string, sms ...scalar.Mapper) *scalar.S { 2121 s, err := d.TryFieldScalarU28(name, sms...) 2122 if err != nil { 2123 panic(IOError{Err: err, Name: name, Op: "U28", Pos: d.Pos()}) 2124 } 2125 return s 2126} 2127 2128// TryFieldU28 tries to add a field and read 28 bit unsigned integer in current endian 2129func (d *D) TryFieldU28(name string, sms ...scalar.Mapper) (uint64, error) { 2130 s, err := d.TryFieldScalarU28(name, sms...) 2131 return s.ActualU(), err 2132} 2133 2134// FieldU28 adds a field and reads 28 bit unsigned integer in current endian 2135func (d *D) FieldU28(name string, sms ...scalar.Mapper) uint64 { 2136 return d.FieldScalarU28(name, sms...).ActualU() 2137} 2138 2139// Reader U29 2140 2141// TryU29 tries to read 29 bit unsigned integer in current endian 2142func (d *D) TryU29() (uint64, error) { return d.tryUE(29, d.Endian) } 2143 2144// U29 reads 29 bit unsigned integer in current endian 2145func (d *D) U29() uint64 { 2146 v, err := d.tryUE(29, d.Endian) 2147 if err != nil { 2148 panic(IOError{Err: err, Op: "U29", Pos: d.Pos()}) 2149 } 2150 return v 2151} 2152 2153// TryFieldScalarU29 tries to add a field and read 29 bit unsigned integer in current endian 2154func (d *D) TryFieldScalarU29(name string, sms ...scalar.Mapper) (*scalar.S, error) { 2155 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 2156 v, err := d.tryUE(29, d.Endian) 2157 s.Actual = v 2158 return s, err 2159 }, sms...) 2160 if err != nil { 2161 return nil, err 2162 } 2163 return s, err 2164} 2165 2166// FieldScalarU29 adds a field and reads 29 bit unsigned integer in current endian 2167func (d *D) FieldScalarU29(name string, sms ...scalar.Mapper) *scalar.S { 2168 s, err := d.TryFieldScalarU29(name, sms...) 2169 if err != nil { 2170 panic(IOError{Err: err, Name: name, Op: "U29", Pos: d.Pos()}) 2171 } 2172 return s 2173} 2174 2175// TryFieldU29 tries to add a field and read 29 bit unsigned integer in current endian 2176func (d *D) TryFieldU29(name string, sms ...scalar.Mapper) (uint64, error) { 2177 s, err := d.TryFieldScalarU29(name, sms...) 2178 return s.ActualU(), err 2179} 2180 2181// FieldU29 adds a field and reads 29 bit unsigned integer in current endian 2182func (d *D) FieldU29(name string, sms ...scalar.Mapper) uint64 { 2183 return d.FieldScalarU29(name, sms...).ActualU() 2184} 2185 2186// Reader U30 2187 2188// TryU30 tries to read 30 bit unsigned integer in current endian 2189func (d *D) TryU30() (uint64, error) { return d.tryUE(30, d.Endian) } 2190 2191// U30 reads 30 bit unsigned integer in current endian 2192func (d *D) U30() uint64 { 2193 v, err := d.tryUE(30, d.Endian) 2194 if err != nil { 2195 panic(IOError{Err: err, Op: "U30", Pos: d.Pos()}) 2196 } 2197 return v 2198} 2199 2200// TryFieldScalarU30 tries to add a field and read 30 bit unsigned integer in current endian 2201func (d *D) TryFieldScalarU30(name string, sms ...scalar.Mapper) (*scalar.S, error) { 2202 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 2203 v, err := d.tryUE(30, d.Endian) 2204 s.Actual = v 2205 return s, err 2206 }, sms...) 2207 if err != nil { 2208 return nil, err 2209 } 2210 return s, err 2211} 2212 2213// FieldScalarU30 adds a field and reads 30 bit unsigned integer in current endian 2214func (d *D) FieldScalarU30(name string, sms ...scalar.Mapper) *scalar.S { 2215 s, err := d.TryFieldScalarU30(name, sms...) 2216 if err != nil { 2217 panic(IOError{Err: err, Name: name, Op: "U30", Pos: d.Pos()}) 2218 } 2219 return s 2220} 2221 2222// TryFieldU30 tries to add a field and read 30 bit unsigned integer in current endian 2223func (d *D) TryFieldU30(name string, sms ...scalar.Mapper) (uint64, error) { 2224 s, err := d.TryFieldScalarU30(name, sms...) 2225 return s.ActualU(), err 2226} 2227 2228// FieldU30 adds a field and reads 30 bit unsigned integer in current endian 2229func (d *D) FieldU30(name string, sms ...scalar.Mapper) uint64 { 2230 return d.FieldScalarU30(name, sms...).ActualU() 2231} 2232 2233// Reader U31 2234 2235// TryU31 tries to read 31 bit unsigned integer in current endian 2236func (d *D) TryU31() (uint64, error) { return d.tryUE(31, d.Endian) } 2237 2238// U31 reads 31 bit unsigned integer in current endian 2239func (d *D) U31() uint64 { 2240 v, err := d.tryUE(31, d.Endian) 2241 if err != nil { 2242 panic(IOError{Err: err, Op: "U31", Pos: d.Pos()}) 2243 } 2244 return v 2245} 2246 2247// TryFieldScalarU31 tries to add a field and read 31 bit unsigned integer in current endian 2248func (d *D) TryFieldScalarU31(name string, sms ...scalar.Mapper) (*scalar.S, error) { 2249 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 2250 v, err := d.tryUE(31, d.Endian) 2251 s.Actual = v 2252 return s, err 2253 }, sms...) 2254 if err != nil { 2255 return nil, err 2256 } 2257 return s, err 2258} 2259 2260// FieldScalarU31 adds a field and reads 31 bit unsigned integer in current endian 2261func (d *D) FieldScalarU31(name string, sms ...scalar.Mapper) *scalar.S { 2262 s, err := d.TryFieldScalarU31(name, sms...) 2263 if err != nil { 2264 panic(IOError{Err: err, Name: name, Op: "U31", Pos: d.Pos()}) 2265 } 2266 return s 2267} 2268 2269// TryFieldU31 tries to add a field and read 31 bit unsigned integer in current endian 2270func (d *D) TryFieldU31(name string, sms ...scalar.Mapper) (uint64, error) { 2271 s, err := d.TryFieldScalarU31(name, sms...) 2272 return s.ActualU(), err 2273} 2274 2275// FieldU31 adds a field and reads 31 bit unsigned integer in current endian 2276func (d *D) FieldU31(name string, sms ...scalar.Mapper) uint64 { 2277 return d.FieldScalarU31(name, sms...).ActualU() 2278} 2279 2280// Reader U32 2281 2282// TryU32 tries to read 32 bit unsigned integer in current endian 2283func (d *D) TryU32() (uint64, error) { return d.tryUE(32, d.Endian) } 2284 2285// U32 reads 32 bit unsigned integer in current endian 2286func (d *D) U32() uint64 { 2287 v, err := d.tryUE(32, d.Endian) 2288 if err != nil { 2289 panic(IOError{Err: err, Op: "U32", Pos: d.Pos()}) 2290 } 2291 return v 2292} 2293 2294// TryFieldScalarU32 tries to add a field and read 32 bit unsigned integer in current endian 2295func (d *D) TryFieldScalarU32(name string, sms ...scalar.Mapper) (*scalar.S, error) { 2296 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 2297 v, err := d.tryUE(32, d.Endian) 2298 s.Actual = v 2299 return s, err 2300 }, sms...) 2301 if err != nil { 2302 return nil, err 2303 } 2304 return s, err 2305} 2306 2307// FieldScalarU32 adds a field and reads 32 bit unsigned integer in current endian 2308func (d *D) FieldScalarU32(name string, sms ...scalar.Mapper) *scalar.S { 2309 s, err := d.TryFieldScalarU32(name, sms...) 2310 if err != nil { 2311 panic(IOError{Err: err, Name: name, Op: "U32", Pos: d.Pos()}) 2312 } 2313 return s 2314} 2315 2316// TryFieldU32 tries to add a field and read 32 bit unsigned integer in current endian 2317func (d *D) TryFieldU32(name string, sms ...scalar.Mapper) (uint64, error) { 2318 s, err := d.TryFieldScalarU32(name, sms...) 2319 return s.ActualU(), err 2320} 2321 2322// FieldU32 adds a field and reads 32 bit unsigned integer in current endian 2323func (d *D) FieldU32(name string, sms ...scalar.Mapper) uint64 { 2324 return d.FieldScalarU32(name, sms...).ActualU() 2325} 2326 2327// Reader U33 2328 2329// TryU33 tries to read 33 bit unsigned integer in current endian 2330func (d *D) TryU33() (uint64, error) { return d.tryUE(33, d.Endian) } 2331 2332// U33 reads 33 bit unsigned integer in current endian 2333func (d *D) U33() uint64 { 2334 v, err := d.tryUE(33, d.Endian) 2335 if err != nil { 2336 panic(IOError{Err: err, Op: "U33", Pos: d.Pos()}) 2337 } 2338 return v 2339} 2340 2341// TryFieldScalarU33 tries to add a field and read 33 bit unsigned integer in current endian 2342func (d *D) TryFieldScalarU33(name string, sms ...scalar.Mapper) (*scalar.S, error) { 2343 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 2344 v, err := d.tryUE(33, d.Endian) 2345 s.Actual = v 2346 return s, err 2347 }, sms...) 2348 if err != nil { 2349 return nil, err 2350 } 2351 return s, err 2352} 2353 2354// FieldScalarU33 adds a field and reads 33 bit unsigned integer in current endian 2355func (d *D) FieldScalarU33(name string, sms ...scalar.Mapper) *scalar.S { 2356 s, err := d.TryFieldScalarU33(name, sms...) 2357 if err != nil { 2358 panic(IOError{Err: err, Name: name, Op: "U33", Pos: d.Pos()}) 2359 } 2360 return s 2361} 2362 2363// TryFieldU33 tries to add a field and read 33 bit unsigned integer in current endian 2364func (d *D) TryFieldU33(name string, sms ...scalar.Mapper) (uint64, error) { 2365 s, err := d.TryFieldScalarU33(name, sms...) 2366 return s.ActualU(), err 2367} 2368 2369// FieldU33 adds a field and reads 33 bit unsigned integer in current endian 2370func (d *D) FieldU33(name string, sms ...scalar.Mapper) uint64 { 2371 return d.FieldScalarU33(name, sms...).ActualU() 2372} 2373 2374// Reader U34 2375 2376// TryU34 tries to read 34 bit unsigned integer in current endian 2377func (d *D) TryU34() (uint64, error) { return d.tryUE(34, d.Endian) } 2378 2379// U34 reads 34 bit unsigned integer in current endian 2380func (d *D) U34() uint64 { 2381 v, err := d.tryUE(34, d.Endian) 2382 if err != nil { 2383 panic(IOError{Err: err, Op: "U34", Pos: d.Pos()}) 2384 } 2385 return v 2386} 2387 2388// TryFieldScalarU34 tries to add a field and read 34 bit unsigned integer in current endian 2389func (d *D) TryFieldScalarU34(name string, sms ...scalar.Mapper) (*scalar.S, error) { 2390 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 2391 v, err := d.tryUE(34, d.Endian) 2392 s.Actual = v 2393 return s, err 2394 }, sms...) 2395 if err != nil { 2396 return nil, err 2397 } 2398 return s, err 2399} 2400 2401// FieldScalarU34 adds a field and reads 34 bit unsigned integer in current endian 2402func (d *D) FieldScalarU34(name string, sms ...scalar.Mapper) *scalar.S { 2403 s, err := d.TryFieldScalarU34(name, sms...) 2404 if err != nil { 2405 panic(IOError{Err: err, Name: name, Op: "U34", Pos: d.Pos()}) 2406 } 2407 return s 2408} 2409 2410// TryFieldU34 tries to add a field and read 34 bit unsigned integer in current endian 2411func (d *D) TryFieldU34(name string, sms ...scalar.Mapper) (uint64, error) { 2412 s, err := d.TryFieldScalarU34(name, sms...) 2413 return s.ActualU(), err 2414} 2415 2416// FieldU34 adds a field and reads 34 bit unsigned integer in current endian 2417func (d *D) FieldU34(name string, sms ...scalar.Mapper) uint64 { 2418 return d.FieldScalarU34(name, sms...).ActualU() 2419} 2420 2421// Reader U35 2422 2423// TryU35 tries to read 35 bit unsigned integer in current endian 2424func (d *D) TryU35() (uint64, error) { return d.tryUE(35, d.Endian) } 2425 2426// U35 reads 35 bit unsigned integer in current endian 2427func (d *D) U35() uint64 { 2428 v, err := d.tryUE(35, d.Endian) 2429 if err != nil { 2430 panic(IOError{Err: err, Op: "U35", Pos: d.Pos()}) 2431 } 2432 return v 2433} 2434 2435// TryFieldScalarU35 tries to add a field and read 35 bit unsigned integer in current endian 2436func (d *D) TryFieldScalarU35(name string, sms ...scalar.Mapper) (*scalar.S, error) { 2437 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 2438 v, err := d.tryUE(35, d.Endian) 2439 s.Actual = v 2440 return s, err 2441 }, sms...) 2442 if err != nil { 2443 return nil, err 2444 } 2445 return s, err 2446} 2447 2448// FieldScalarU35 adds a field and reads 35 bit unsigned integer in current endian 2449func (d *D) FieldScalarU35(name string, sms ...scalar.Mapper) *scalar.S { 2450 s, err := d.TryFieldScalarU35(name, sms...) 2451 if err != nil { 2452 panic(IOError{Err: err, Name: name, Op: "U35", Pos: d.Pos()}) 2453 } 2454 return s 2455} 2456 2457// TryFieldU35 tries to add a field and read 35 bit unsigned integer in current endian 2458func (d *D) TryFieldU35(name string, sms ...scalar.Mapper) (uint64, error) { 2459 s, err := d.TryFieldScalarU35(name, sms...) 2460 return s.ActualU(), err 2461} 2462 2463// FieldU35 adds a field and reads 35 bit unsigned integer in current endian 2464func (d *D) FieldU35(name string, sms ...scalar.Mapper) uint64 { 2465 return d.FieldScalarU35(name, sms...).ActualU() 2466} 2467 2468// Reader U36 2469 2470// TryU36 tries to read 36 bit unsigned integer in current endian 2471func (d *D) TryU36() (uint64, error) { return d.tryUE(36, d.Endian) } 2472 2473// U36 reads 36 bit unsigned integer in current endian 2474func (d *D) U36() uint64 { 2475 v, err := d.tryUE(36, d.Endian) 2476 if err != nil { 2477 panic(IOError{Err: err, Op: "U36", Pos: d.Pos()}) 2478 } 2479 return v 2480} 2481 2482// TryFieldScalarU36 tries to add a field and read 36 bit unsigned integer in current endian 2483func (d *D) TryFieldScalarU36(name string, sms ...scalar.Mapper) (*scalar.S, error) { 2484 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 2485 v, err := d.tryUE(36, d.Endian) 2486 s.Actual = v 2487 return s, err 2488 }, sms...) 2489 if err != nil { 2490 return nil, err 2491 } 2492 return s, err 2493} 2494 2495// FieldScalarU36 adds a field and reads 36 bit unsigned integer in current endian 2496func (d *D) FieldScalarU36(name string, sms ...scalar.Mapper) *scalar.S { 2497 s, err := d.TryFieldScalarU36(name, sms...) 2498 if err != nil { 2499 panic(IOError{Err: err, Name: name, Op: "U36", Pos: d.Pos()}) 2500 } 2501 return s 2502} 2503 2504// TryFieldU36 tries to add a field and read 36 bit unsigned integer in current endian 2505func (d *D) TryFieldU36(name string, sms ...scalar.Mapper) (uint64, error) { 2506 s, err := d.TryFieldScalarU36(name, sms...) 2507 return s.ActualU(), err 2508} 2509 2510// FieldU36 adds a field and reads 36 bit unsigned integer in current endian 2511func (d *D) FieldU36(name string, sms ...scalar.Mapper) uint64 { 2512 return d.FieldScalarU36(name, sms...).ActualU() 2513} 2514 2515// Reader U37 2516 2517// TryU37 tries to read 37 bit unsigned integer in current endian 2518func (d *D) TryU37() (uint64, error) { return d.tryUE(37, d.Endian) } 2519 2520// U37 reads 37 bit unsigned integer in current endian 2521func (d *D) U37() uint64 { 2522 v, err := d.tryUE(37, d.Endian) 2523 if err != nil { 2524 panic(IOError{Err: err, Op: "U37", Pos: d.Pos()}) 2525 } 2526 return v 2527} 2528 2529// TryFieldScalarU37 tries to add a field and read 37 bit unsigned integer in current endian 2530func (d *D) TryFieldScalarU37(name string, sms ...scalar.Mapper) (*scalar.S, error) { 2531 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 2532 v, err := d.tryUE(37, d.Endian) 2533 s.Actual = v 2534 return s, err 2535 }, sms...) 2536 if err != nil { 2537 return nil, err 2538 } 2539 return s, err 2540} 2541 2542// FieldScalarU37 adds a field and reads 37 bit unsigned integer in current endian 2543func (d *D) FieldScalarU37(name string, sms ...scalar.Mapper) *scalar.S { 2544 s, err := d.TryFieldScalarU37(name, sms...) 2545 if err != nil { 2546 panic(IOError{Err: err, Name: name, Op: "U37", Pos: d.Pos()}) 2547 } 2548 return s 2549} 2550 2551// TryFieldU37 tries to add a field and read 37 bit unsigned integer in current endian 2552func (d *D) TryFieldU37(name string, sms ...scalar.Mapper) (uint64, error) { 2553 s, err := d.TryFieldScalarU37(name, sms...) 2554 return s.ActualU(), err 2555} 2556 2557// FieldU37 adds a field and reads 37 bit unsigned integer in current endian 2558func (d *D) FieldU37(name string, sms ...scalar.Mapper) uint64 { 2559 return d.FieldScalarU37(name, sms...).ActualU() 2560} 2561 2562// Reader U38 2563 2564// TryU38 tries to read 38 bit unsigned integer in current endian 2565func (d *D) TryU38() (uint64, error) { return d.tryUE(38, d.Endian) } 2566 2567// U38 reads 38 bit unsigned integer in current endian 2568func (d *D) U38() uint64 { 2569 v, err := d.tryUE(38, d.Endian) 2570 if err != nil { 2571 panic(IOError{Err: err, Op: "U38", Pos: d.Pos()}) 2572 } 2573 return v 2574} 2575 2576// TryFieldScalarU38 tries to add a field and read 38 bit unsigned integer in current endian 2577func (d *D) TryFieldScalarU38(name string, sms ...scalar.Mapper) (*scalar.S, error) { 2578 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 2579 v, err := d.tryUE(38, d.Endian) 2580 s.Actual = v 2581 return s, err 2582 }, sms...) 2583 if err != nil { 2584 return nil, err 2585 } 2586 return s, err 2587} 2588 2589// FieldScalarU38 adds a field and reads 38 bit unsigned integer in current endian 2590func (d *D) FieldScalarU38(name string, sms ...scalar.Mapper) *scalar.S { 2591 s, err := d.TryFieldScalarU38(name, sms...) 2592 if err != nil { 2593 panic(IOError{Err: err, Name: name, Op: "U38", Pos: d.Pos()}) 2594 } 2595 return s 2596} 2597 2598// TryFieldU38 tries to add a field and read 38 bit unsigned integer in current endian 2599func (d *D) TryFieldU38(name string, sms ...scalar.Mapper) (uint64, error) { 2600 s, err := d.TryFieldScalarU38(name, sms...) 2601 return s.ActualU(), err 2602} 2603 2604// FieldU38 adds a field and reads 38 bit unsigned integer in current endian 2605func (d *D) FieldU38(name string, sms ...scalar.Mapper) uint64 { 2606 return d.FieldScalarU38(name, sms...).ActualU() 2607} 2608 2609// Reader U39 2610 2611// TryU39 tries to read 39 bit unsigned integer in current endian 2612func (d *D) TryU39() (uint64, error) { return d.tryUE(39, d.Endian) } 2613 2614// U39 reads 39 bit unsigned integer in current endian 2615func (d *D) U39() uint64 { 2616 v, err := d.tryUE(39, d.Endian) 2617 if err != nil { 2618 panic(IOError{Err: err, Op: "U39", Pos: d.Pos()}) 2619 } 2620 return v 2621} 2622 2623// TryFieldScalarU39 tries to add a field and read 39 bit unsigned integer in current endian 2624func (d *D) TryFieldScalarU39(name string, sms ...scalar.Mapper) (*scalar.S, error) { 2625 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 2626 v, err := d.tryUE(39, d.Endian) 2627 s.Actual = v 2628 return s, err 2629 }, sms...) 2630 if err != nil { 2631 return nil, err 2632 } 2633 return s, err 2634} 2635 2636// FieldScalarU39 adds a field and reads 39 bit unsigned integer in current endian 2637func (d *D) FieldScalarU39(name string, sms ...scalar.Mapper) *scalar.S { 2638 s, err := d.TryFieldScalarU39(name, sms...) 2639 if err != nil { 2640 panic(IOError{Err: err, Name: name, Op: "U39", Pos: d.Pos()}) 2641 } 2642 return s 2643} 2644 2645// TryFieldU39 tries to add a field and read 39 bit unsigned integer in current endian 2646func (d *D) TryFieldU39(name string, sms ...scalar.Mapper) (uint64, error) { 2647 s, err := d.TryFieldScalarU39(name, sms...) 2648 return s.ActualU(), err 2649} 2650 2651// FieldU39 adds a field and reads 39 bit unsigned integer in current endian 2652func (d *D) FieldU39(name string, sms ...scalar.Mapper) uint64 { 2653 return d.FieldScalarU39(name, sms...).ActualU() 2654} 2655 2656// Reader U40 2657 2658// TryU40 tries to read 40 bit unsigned integer in current endian 2659func (d *D) TryU40() (uint64, error) { return d.tryUE(40, d.Endian) } 2660 2661// U40 reads 40 bit unsigned integer in current endian 2662func (d *D) U40() uint64 { 2663 v, err := d.tryUE(40, d.Endian) 2664 if err != nil { 2665 panic(IOError{Err: err, Op: "U40", Pos: d.Pos()}) 2666 } 2667 return v 2668} 2669 2670// TryFieldScalarU40 tries to add a field and read 40 bit unsigned integer in current endian 2671func (d *D) TryFieldScalarU40(name string, sms ...scalar.Mapper) (*scalar.S, error) { 2672 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 2673 v, err := d.tryUE(40, d.Endian) 2674 s.Actual = v 2675 return s, err 2676 }, sms...) 2677 if err != nil { 2678 return nil, err 2679 } 2680 return s, err 2681} 2682 2683// FieldScalarU40 adds a field and reads 40 bit unsigned integer in current endian 2684func (d *D) FieldScalarU40(name string, sms ...scalar.Mapper) *scalar.S { 2685 s, err := d.TryFieldScalarU40(name, sms...) 2686 if err != nil { 2687 panic(IOError{Err: err, Name: name, Op: "U40", Pos: d.Pos()}) 2688 } 2689 return s 2690} 2691 2692// TryFieldU40 tries to add a field and read 40 bit unsigned integer in current endian 2693func (d *D) TryFieldU40(name string, sms ...scalar.Mapper) (uint64, error) { 2694 s, err := d.TryFieldScalarU40(name, sms...) 2695 return s.ActualU(), err 2696} 2697 2698// FieldU40 adds a field and reads 40 bit unsigned integer in current endian 2699func (d *D) FieldU40(name string, sms ...scalar.Mapper) uint64 { 2700 return d.FieldScalarU40(name, sms...).ActualU() 2701} 2702 2703// Reader U41 2704 2705// TryU41 tries to read 41 bit unsigned integer in current endian 2706func (d *D) TryU41() (uint64, error) { return d.tryUE(41, d.Endian) } 2707 2708// U41 reads 41 bit unsigned integer in current endian 2709func (d *D) U41() uint64 { 2710 v, err := d.tryUE(41, d.Endian) 2711 if err != nil { 2712 panic(IOError{Err: err, Op: "U41", Pos: d.Pos()}) 2713 } 2714 return v 2715} 2716 2717// TryFieldScalarU41 tries to add a field and read 41 bit unsigned integer in current endian 2718func (d *D) TryFieldScalarU41(name string, sms ...scalar.Mapper) (*scalar.S, error) { 2719 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 2720 v, err := d.tryUE(41, d.Endian) 2721 s.Actual = v 2722 return s, err 2723 }, sms...) 2724 if err != nil { 2725 return nil, err 2726 } 2727 return s, err 2728} 2729 2730// FieldScalarU41 adds a field and reads 41 bit unsigned integer in current endian 2731func (d *D) FieldScalarU41(name string, sms ...scalar.Mapper) *scalar.S { 2732 s, err := d.TryFieldScalarU41(name, sms...) 2733 if err != nil { 2734 panic(IOError{Err: err, Name: name, Op: "U41", Pos: d.Pos()}) 2735 } 2736 return s 2737} 2738 2739// TryFieldU41 tries to add a field and read 41 bit unsigned integer in current endian 2740func (d *D) TryFieldU41(name string, sms ...scalar.Mapper) (uint64, error) { 2741 s, err := d.TryFieldScalarU41(name, sms...) 2742 return s.ActualU(), err 2743} 2744 2745// FieldU41 adds a field and reads 41 bit unsigned integer in current endian 2746func (d *D) FieldU41(name string, sms ...scalar.Mapper) uint64 { 2747 return d.FieldScalarU41(name, sms...).ActualU() 2748} 2749 2750// Reader U42 2751 2752// TryU42 tries to read 42 bit unsigned integer in current endian 2753func (d *D) TryU42() (uint64, error) { return d.tryUE(42, d.Endian) } 2754 2755// U42 reads 42 bit unsigned integer in current endian 2756func (d *D) U42() uint64 { 2757 v, err := d.tryUE(42, d.Endian) 2758 if err != nil { 2759 panic(IOError{Err: err, Op: "U42", Pos: d.Pos()}) 2760 } 2761 return v 2762} 2763 2764// TryFieldScalarU42 tries to add a field and read 42 bit unsigned integer in current endian 2765func (d *D) TryFieldScalarU42(name string, sms ...scalar.Mapper) (*scalar.S, error) { 2766 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 2767 v, err := d.tryUE(42, d.Endian) 2768 s.Actual = v 2769 return s, err 2770 }, sms...) 2771 if err != nil { 2772 return nil, err 2773 } 2774 return s, err 2775} 2776 2777// FieldScalarU42 adds a field and reads 42 bit unsigned integer in current endian 2778func (d *D) FieldScalarU42(name string, sms ...scalar.Mapper) *scalar.S { 2779 s, err := d.TryFieldScalarU42(name, sms...) 2780 if err != nil { 2781 panic(IOError{Err: err, Name: name, Op: "U42", Pos: d.Pos()}) 2782 } 2783 return s 2784} 2785 2786// TryFieldU42 tries to add a field and read 42 bit unsigned integer in current endian 2787func (d *D) TryFieldU42(name string, sms ...scalar.Mapper) (uint64, error) { 2788 s, err := d.TryFieldScalarU42(name, sms...) 2789 return s.ActualU(), err 2790} 2791 2792// FieldU42 adds a field and reads 42 bit unsigned integer in current endian 2793func (d *D) FieldU42(name string, sms ...scalar.Mapper) uint64 { 2794 return d.FieldScalarU42(name, sms...).ActualU() 2795} 2796 2797// Reader U43 2798 2799// TryU43 tries to read 43 bit unsigned integer in current endian 2800func (d *D) TryU43() (uint64, error) { return d.tryUE(43, d.Endian) } 2801 2802// U43 reads 43 bit unsigned integer in current endian 2803func (d *D) U43() uint64 { 2804 v, err := d.tryUE(43, d.Endian) 2805 if err != nil { 2806 panic(IOError{Err: err, Op: "U43", Pos: d.Pos()}) 2807 } 2808 return v 2809} 2810 2811// TryFieldScalarU43 tries to add a field and read 43 bit unsigned integer in current endian 2812func (d *D) TryFieldScalarU43(name string, sms ...scalar.Mapper) (*scalar.S, error) { 2813 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 2814 v, err := d.tryUE(43, d.Endian) 2815 s.Actual = v 2816 return s, err 2817 }, sms...) 2818 if err != nil { 2819 return nil, err 2820 } 2821 return s, err 2822} 2823 2824// FieldScalarU43 adds a field and reads 43 bit unsigned integer in current endian 2825func (d *D) FieldScalarU43(name string, sms ...scalar.Mapper) *scalar.S { 2826 s, err := d.TryFieldScalarU43(name, sms...) 2827 if err != nil { 2828 panic(IOError{Err: err, Name: name, Op: "U43", Pos: d.Pos()}) 2829 } 2830 return s 2831} 2832 2833// TryFieldU43 tries to add a field and read 43 bit unsigned integer in current endian 2834func (d *D) TryFieldU43(name string, sms ...scalar.Mapper) (uint64, error) { 2835 s, err := d.TryFieldScalarU43(name, sms...) 2836 return s.ActualU(), err 2837} 2838 2839// FieldU43 adds a field and reads 43 bit unsigned integer in current endian 2840func (d *D) FieldU43(name string, sms ...scalar.Mapper) uint64 { 2841 return d.FieldScalarU43(name, sms...).ActualU() 2842} 2843 2844// Reader U44 2845 2846// TryU44 tries to read 44 bit unsigned integer in current endian 2847func (d *D) TryU44() (uint64, error) { return d.tryUE(44, d.Endian) } 2848 2849// U44 reads 44 bit unsigned integer in current endian 2850func (d *D) U44() uint64 { 2851 v, err := d.tryUE(44, d.Endian) 2852 if err != nil { 2853 panic(IOError{Err: err, Op: "U44", Pos: d.Pos()}) 2854 } 2855 return v 2856} 2857 2858// TryFieldScalarU44 tries to add a field and read 44 bit unsigned integer in current endian 2859func (d *D) TryFieldScalarU44(name string, sms ...scalar.Mapper) (*scalar.S, error) { 2860 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 2861 v, err := d.tryUE(44, d.Endian) 2862 s.Actual = v 2863 return s, err 2864 }, sms...) 2865 if err != nil { 2866 return nil, err 2867 } 2868 return s, err 2869} 2870 2871// FieldScalarU44 adds a field and reads 44 bit unsigned integer in current endian 2872func (d *D) FieldScalarU44(name string, sms ...scalar.Mapper) *scalar.S { 2873 s, err := d.TryFieldScalarU44(name, sms...) 2874 if err != nil { 2875 panic(IOError{Err: err, Name: name, Op: "U44", Pos: d.Pos()}) 2876 } 2877 return s 2878} 2879 2880// TryFieldU44 tries to add a field and read 44 bit unsigned integer in current endian 2881func (d *D) TryFieldU44(name string, sms ...scalar.Mapper) (uint64, error) { 2882 s, err := d.TryFieldScalarU44(name, sms...) 2883 return s.ActualU(), err 2884} 2885 2886// FieldU44 adds a field and reads 44 bit unsigned integer in current endian 2887func (d *D) FieldU44(name string, sms ...scalar.Mapper) uint64 { 2888 return d.FieldScalarU44(name, sms...).ActualU() 2889} 2890 2891// Reader U45 2892 2893// TryU45 tries to read 45 bit unsigned integer in current endian 2894func (d *D) TryU45() (uint64, error) { return d.tryUE(45, d.Endian) } 2895 2896// U45 reads 45 bit unsigned integer in current endian 2897func (d *D) U45() uint64 { 2898 v, err := d.tryUE(45, d.Endian) 2899 if err != nil { 2900 panic(IOError{Err: err, Op: "U45", Pos: d.Pos()}) 2901 } 2902 return v 2903} 2904 2905// TryFieldScalarU45 tries to add a field and read 45 bit unsigned integer in current endian 2906func (d *D) TryFieldScalarU45(name string, sms ...scalar.Mapper) (*scalar.S, error) { 2907 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 2908 v, err := d.tryUE(45, d.Endian) 2909 s.Actual = v 2910 return s, err 2911 }, sms...) 2912 if err != nil { 2913 return nil, err 2914 } 2915 return s, err 2916} 2917 2918// FieldScalarU45 adds a field and reads 45 bit unsigned integer in current endian 2919func (d *D) FieldScalarU45(name string, sms ...scalar.Mapper) *scalar.S { 2920 s, err := d.TryFieldScalarU45(name, sms...) 2921 if err != nil { 2922 panic(IOError{Err: err, Name: name, Op: "U45", Pos: d.Pos()}) 2923 } 2924 return s 2925} 2926 2927// TryFieldU45 tries to add a field and read 45 bit unsigned integer in current endian 2928func (d *D) TryFieldU45(name string, sms ...scalar.Mapper) (uint64, error) { 2929 s, err := d.TryFieldScalarU45(name, sms...) 2930 return s.ActualU(), err 2931} 2932 2933// FieldU45 adds a field and reads 45 bit unsigned integer in current endian 2934func (d *D) FieldU45(name string, sms ...scalar.Mapper) uint64 { 2935 return d.FieldScalarU45(name, sms...).ActualU() 2936} 2937 2938// Reader U46 2939 2940// TryU46 tries to read 46 bit unsigned integer in current endian 2941func (d *D) TryU46() (uint64, error) { return d.tryUE(46, d.Endian) } 2942 2943// U46 reads 46 bit unsigned integer in current endian 2944func (d *D) U46() uint64 { 2945 v, err := d.tryUE(46, d.Endian) 2946 if err != nil { 2947 panic(IOError{Err: err, Op: "U46", Pos: d.Pos()}) 2948 } 2949 return v 2950} 2951 2952// TryFieldScalarU46 tries to add a field and read 46 bit unsigned integer in current endian 2953func (d *D) TryFieldScalarU46(name string, sms ...scalar.Mapper) (*scalar.S, error) { 2954 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 2955 v, err := d.tryUE(46, d.Endian) 2956 s.Actual = v 2957 return s, err 2958 }, sms...) 2959 if err != nil { 2960 return nil, err 2961 } 2962 return s, err 2963} 2964 2965// FieldScalarU46 adds a field and reads 46 bit unsigned integer in current endian 2966func (d *D) FieldScalarU46(name string, sms ...scalar.Mapper) *scalar.S { 2967 s, err := d.TryFieldScalarU46(name, sms...) 2968 if err != nil { 2969 panic(IOError{Err: err, Name: name, Op: "U46", Pos: d.Pos()}) 2970 } 2971 return s 2972} 2973 2974// TryFieldU46 tries to add a field and read 46 bit unsigned integer in current endian 2975func (d *D) TryFieldU46(name string, sms ...scalar.Mapper) (uint64, error) { 2976 s, err := d.TryFieldScalarU46(name, sms...) 2977 return s.ActualU(), err 2978} 2979 2980// FieldU46 adds a field and reads 46 bit unsigned integer in current endian 2981func (d *D) FieldU46(name string, sms ...scalar.Mapper) uint64 { 2982 return d.FieldScalarU46(name, sms...).ActualU() 2983} 2984 2985// Reader U47 2986 2987// TryU47 tries to read 47 bit unsigned integer in current endian 2988func (d *D) TryU47() (uint64, error) { return d.tryUE(47, d.Endian) } 2989 2990// U47 reads 47 bit unsigned integer in current endian 2991func (d *D) U47() uint64 { 2992 v, err := d.tryUE(47, d.Endian) 2993 if err != nil { 2994 panic(IOError{Err: err, Op: "U47", Pos: d.Pos()}) 2995 } 2996 return v 2997} 2998 2999// TryFieldScalarU47 tries to add a field and read 47 bit unsigned integer in current endian 3000func (d *D) TryFieldScalarU47(name string, sms ...scalar.Mapper) (*scalar.S, error) { 3001 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 3002 v, err := d.tryUE(47, d.Endian) 3003 s.Actual = v 3004 return s, err 3005 }, sms...) 3006 if err != nil { 3007 return nil, err 3008 } 3009 return s, err 3010} 3011 3012// FieldScalarU47 adds a field and reads 47 bit unsigned integer in current endian 3013func (d *D) FieldScalarU47(name string, sms ...scalar.Mapper) *scalar.S { 3014 s, err := d.TryFieldScalarU47(name, sms...) 3015 if err != nil { 3016 panic(IOError{Err: err, Name: name, Op: "U47", Pos: d.Pos()}) 3017 } 3018 return s 3019} 3020 3021// TryFieldU47 tries to add a field and read 47 bit unsigned integer in current endian 3022func (d *D) TryFieldU47(name string, sms ...scalar.Mapper) (uint64, error) { 3023 s, err := d.TryFieldScalarU47(name, sms...) 3024 return s.ActualU(), err 3025} 3026 3027// FieldU47 adds a field and reads 47 bit unsigned integer in current endian 3028func (d *D) FieldU47(name string, sms ...scalar.Mapper) uint64 { 3029 return d.FieldScalarU47(name, sms...).ActualU() 3030} 3031 3032// Reader U48 3033 3034// TryU48 tries to read 48 bit unsigned integer in current endian 3035func (d *D) TryU48() (uint64, error) { return d.tryUE(48, d.Endian) } 3036 3037// U48 reads 48 bit unsigned integer in current endian 3038func (d *D) U48() uint64 { 3039 v, err := d.tryUE(48, d.Endian) 3040 if err != nil { 3041 panic(IOError{Err: err, Op: "U48", Pos: d.Pos()}) 3042 } 3043 return v 3044} 3045 3046// TryFieldScalarU48 tries to add a field and read 48 bit unsigned integer in current endian 3047func (d *D) TryFieldScalarU48(name string, sms ...scalar.Mapper) (*scalar.S, error) { 3048 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 3049 v, err := d.tryUE(48, d.Endian) 3050 s.Actual = v 3051 return s, err 3052 }, sms...) 3053 if err != nil { 3054 return nil, err 3055 } 3056 return s, err 3057} 3058 3059// FieldScalarU48 adds a field and reads 48 bit unsigned integer in current endian 3060func (d *D) FieldScalarU48(name string, sms ...scalar.Mapper) *scalar.S { 3061 s, err := d.TryFieldScalarU48(name, sms...) 3062 if err != nil { 3063 panic(IOError{Err: err, Name: name, Op: "U48", Pos: d.Pos()}) 3064 } 3065 return s 3066} 3067 3068// TryFieldU48 tries to add a field and read 48 bit unsigned integer in current endian 3069func (d *D) TryFieldU48(name string, sms ...scalar.Mapper) (uint64, error) { 3070 s, err := d.TryFieldScalarU48(name, sms...) 3071 return s.ActualU(), err 3072} 3073 3074// FieldU48 adds a field and reads 48 bit unsigned integer in current endian 3075func (d *D) FieldU48(name string, sms ...scalar.Mapper) uint64 { 3076 return d.FieldScalarU48(name, sms...).ActualU() 3077} 3078 3079// Reader U49 3080 3081// TryU49 tries to read 49 bit unsigned integer in current endian 3082func (d *D) TryU49() (uint64, error) { return d.tryUE(49, d.Endian) } 3083 3084// U49 reads 49 bit unsigned integer in current endian 3085func (d *D) U49() uint64 { 3086 v, err := d.tryUE(49, d.Endian) 3087 if err != nil { 3088 panic(IOError{Err: err, Op: "U49", Pos: d.Pos()}) 3089 } 3090 return v 3091} 3092 3093// TryFieldScalarU49 tries to add a field and read 49 bit unsigned integer in current endian 3094func (d *D) TryFieldScalarU49(name string, sms ...scalar.Mapper) (*scalar.S, error) { 3095 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 3096 v, err := d.tryUE(49, d.Endian) 3097 s.Actual = v 3098 return s, err 3099 }, sms...) 3100 if err != nil { 3101 return nil, err 3102 } 3103 return s, err 3104} 3105 3106// FieldScalarU49 adds a field and reads 49 bit unsigned integer in current endian 3107func (d *D) FieldScalarU49(name string, sms ...scalar.Mapper) *scalar.S { 3108 s, err := d.TryFieldScalarU49(name, sms...) 3109 if err != nil { 3110 panic(IOError{Err: err, Name: name, Op: "U49", Pos: d.Pos()}) 3111 } 3112 return s 3113} 3114 3115// TryFieldU49 tries to add a field and read 49 bit unsigned integer in current endian 3116func (d *D) TryFieldU49(name string, sms ...scalar.Mapper) (uint64, error) { 3117 s, err := d.TryFieldScalarU49(name, sms...) 3118 return s.ActualU(), err 3119} 3120 3121// FieldU49 adds a field and reads 49 bit unsigned integer in current endian 3122func (d *D) FieldU49(name string, sms ...scalar.Mapper) uint64 { 3123 return d.FieldScalarU49(name, sms...).ActualU() 3124} 3125 3126// Reader U50 3127 3128// TryU50 tries to read 50 bit unsigned integer in current endian 3129func (d *D) TryU50() (uint64, error) { return d.tryUE(50, d.Endian) } 3130 3131// U50 reads 50 bit unsigned integer in current endian 3132func (d *D) U50() uint64 { 3133 v, err := d.tryUE(50, d.Endian) 3134 if err != nil { 3135 panic(IOError{Err: err, Op: "U50", Pos: d.Pos()}) 3136 } 3137 return v 3138} 3139 3140// TryFieldScalarU50 tries to add a field and read 50 bit unsigned integer in current endian 3141func (d *D) TryFieldScalarU50(name string, sms ...scalar.Mapper) (*scalar.S, error) { 3142 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 3143 v, err := d.tryUE(50, d.Endian) 3144 s.Actual = v 3145 return s, err 3146 }, sms...) 3147 if err != nil { 3148 return nil, err 3149 } 3150 return s, err 3151} 3152 3153// FieldScalarU50 adds a field and reads 50 bit unsigned integer in current endian 3154func (d *D) FieldScalarU50(name string, sms ...scalar.Mapper) *scalar.S { 3155 s, err := d.TryFieldScalarU50(name, sms...) 3156 if err != nil { 3157 panic(IOError{Err: err, Name: name, Op: "U50", Pos: d.Pos()}) 3158 } 3159 return s 3160} 3161 3162// TryFieldU50 tries to add a field and read 50 bit unsigned integer in current endian 3163func (d *D) TryFieldU50(name string, sms ...scalar.Mapper) (uint64, error) { 3164 s, err := d.TryFieldScalarU50(name, sms...) 3165 return s.ActualU(), err 3166} 3167 3168// FieldU50 adds a field and reads 50 bit unsigned integer in current endian 3169func (d *D) FieldU50(name string, sms ...scalar.Mapper) uint64 { 3170 return d.FieldScalarU50(name, sms...).ActualU() 3171} 3172 3173// Reader U51 3174 3175// TryU51 tries to read 51 bit unsigned integer in current endian 3176func (d *D) TryU51() (uint64, error) { return d.tryUE(51, d.Endian) } 3177 3178// U51 reads 51 bit unsigned integer in current endian 3179func (d *D) U51() uint64 { 3180 v, err := d.tryUE(51, d.Endian) 3181 if err != nil { 3182 panic(IOError{Err: err, Op: "U51", Pos: d.Pos()}) 3183 } 3184 return v 3185} 3186 3187// TryFieldScalarU51 tries to add a field and read 51 bit unsigned integer in current endian 3188func (d *D) TryFieldScalarU51(name string, sms ...scalar.Mapper) (*scalar.S, error) { 3189 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 3190 v, err := d.tryUE(51, d.Endian) 3191 s.Actual = v 3192 return s, err 3193 }, sms...) 3194 if err != nil { 3195 return nil, err 3196 } 3197 return s, err 3198} 3199 3200// FieldScalarU51 adds a field and reads 51 bit unsigned integer in current endian 3201func (d *D) FieldScalarU51(name string, sms ...scalar.Mapper) *scalar.S { 3202 s, err := d.TryFieldScalarU51(name, sms...) 3203 if err != nil { 3204 panic(IOError{Err: err, Name: name, Op: "U51", Pos: d.Pos()}) 3205 } 3206 return s 3207} 3208 3209// TryFieldU51 tries to add a field and read 51 bit unsigned integer in current endian 3210func (d *D) TryFieldU51(name string, sms ...scalar.Mapper) (uint64, error) { 3211 s, err := d.TryFieldScalarU51(name, sms...) 3212 return s.ActualU(), err 3213} 3214 3215// FieldU51 adds a field and reads 51 bit unsigned integer in current endian 3216func (d *D) FieldU51(name string, sms ...scalar.Mapper) uint64 { 3217 return d.FieldScalarU51(name, sms...).ActualU() 3218} 3219 3220// Reader U52 3221 3222// TryU52 tries to read 52 bit unsigned integer in current endian 3223func (d *D) TryU52() (uint64, error) { return d.tryUE(52, d.Endian) } 3224 3225// U52 reads 52 bit unsigned integer in current endian 3226func (d *D) U52() uint64 { 3227 v, err := d.tryUE(52, d.Endian) 3228 if err != nil { 3229 panic(IOError{Err: err, Op: "U52", Pos: d.Pos()}) 3230 } 3231 return v 3232} 3233 3234// TryFieldScalarU52 tries to add a field and read 52 bit unsigned integer in current endian 3235func (d *D) TryFieldScalarU52(name string, sms ...scalar.Mapper) (*scalar.S, error) { 3236 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 3237 v, err := d.tryUE(52, d.Endian) 3238 s.Actual = v 3239 return s, err 3240 }, sms...) 3241 if err != nil { 3242 return nil, err 3243 } 3244 return s, err 3245} 3246 3247// FieldScalarU52 adds a field and reads 52 bit unsigned integer in current endian 3248func (d *D) FieldScalarU52(name string, sms ...scalar.Mapper) *scalar.S { 3249 s, err := d.TryFieldScalarU52(name, sms...) 3250 if err != nil { 3251 panic(IOError{Err: err, Name: name, Op: "U52", Pos: d.Pos()}) 3252 } 3253 return s 3254} 3255 3256// TryFieldU52 tries to add a field and read 52 bit unsigned integer in current endian 3257func (d *D) TryFieldU52(name string, sms ...scalar.Mapper) (uint64, error) { 3258 s, err := d.TryFieldScalarU52(name, sms...) 3259 return s.ActualU(), err 3260} 3261 3262// FieldU52 adds a field and reads 52 bit unsigned integer in current endian 3263func (d *D) FieldU52(name string, sms ...scalar.Mapper) uint64 { 3264 return d.FieldScalarU52(name, sms...).ActualU() 3265} 3266 3267// Reader U53 3268 3269// TryU53 tries to read 53 bit unsigned integer in current endian 3270func (d *D) TryU53() (uint64, error) { return d.tryUE(53, d.Endian) } 3271 3272// U53 reads 53 bit unsigned integer in current endian 3273func (d *D) U53() uint64 { 3274 v, err := d.tryUE(53, d.Endian) 3275 if err != nil { 3276 panic(IOError{Err: err, Op: "U53", Pos: d.Pos()}) 3277 } 3278 return v 3279} 3280 3281// TryFieldScalarU53 tries to add a field and read 53 bit unsigned integer in current endian 3282func (d *D) TryFieldScalarU53(name string, sms ...scalar.Mapper) (*scalar.S, error) { 3283 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 3284 v, err := d.tryUE(53, d.Endian) 3285 s.Actual = v 3286 return s, err 3287 }, sms...) 3288 if err != nil { 3289 return nil, err 3290 } 3291 return s, err 3292} 3293 3294// FieldScalarU53 adds a field and reads 53 bit unsigned integer in current endian 3295func (d *D) FieldScalarU53(name string, sms ...scalar.Mapper) *scalar.S { 3296 s, err := d.TryFieldScalarU53(name, sms...) 3297 if err != nil { 3298 panic(IOError{Err: err, Name: name, Op: "U53", Pos: d.Pos()}) 3299 } 3300 return s 3301} 3302 3303// TryFieldU53 tries to add a field and read 53 bit unsigned integer in current endian 3304func (d *D) TryFieldU53(name string, sms ...scalar.Mapper) (uint64, error) { 3305 s, err := d.TryFieldScalarU53(name, sms...) 3306 return s.ActualU(), err 3307} 3308 3309// FieldU53 adds a field and reads 53 bit unsigned integer in current endian 3310func (d *D) FieldU53(name string, sms ...scalar.Mapper) uint64 { 3311 return d.FieldScalarU53(name, sms...).ActualU() 3312} 3313 3314// Reader U54 3315 3316// TryU54 tries to read 54 bit unsigned integer in current endian 3317func (d *D) TryU54() (uint64, error) { return d.tryUE(54, d.Endian) } 3318 3319// U54 reads 54 bit unsigned integer in current endian 3320func (d *D) U54() uint64 { 3321 v, err := d.tryUE(54, d.Endian) 3322 if err != nil { 3323 panic(IOError{Err: err, Op: "U54", Pos: d.Pos()}) 3324 } 3325 return v 3326} 3327 3328// TryFieldScalarU54 tries to add a field and read 54 bit unsigned integer in current endian 3329func (d *D) TryFieldScalarU54(name string, sms ...scalar.Mapper) (*scalar.S, error) { 3330 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 3331 v, err := d.tryUE(54, d.Endian) 3332 s.Actual = v 3333 return s, err 3334 }, sms...) 3335 if err != nil { 3336 return nil, err 3337 } 3338 return s, err 3339} 3340 3341// FieldScalarU54 adds a field and reads 54 bit unsigned integer in current endian 3342func (d *D) FieldScalarU54(name string, sms ...scalar.Mapper) *scalar.S { 3343 s, err := d.TryFieldScalarU54(name, sms...) 3344 if err != nil { 3345 panic(IOError{Err: err, Name: name, Op: "U54", Pos: d.Pos()}) 3346 } 3347 return s 3348} 3349 3350// TryFieldU54 tries to add a field and read 54 bit unsigned integer in current endian 3351func (d *D) TryFieldU54(name string, sms ...scalar.Mapper) (uint64, error) { 3352 s, err := d.TryFieldScalarU54(name, sms...) 3353 return s.ActualU(), err 3354} 3355 3356// FieldU54 adds a field and reads 54 bit unsigned integer in current endian 3357func (d *D) FieldU54(name string, sms ...scalar.Mapper) uint64 { 3358 return d.FieldScalarU54(name, sms...).ActualU() 3359} 3360 3361// Reader U55 3362 3363// TryU55 tries to read 55 bit unsigned integer in current endian 3364func (d *D) TryU55() (uint64, error) { return d.tryUE(55, d.Endian) } 3365 3366// U55 reads 55 bit unsigned integer in current endian 3367func (d *D) U55() uint64 { 3368 v, err := d.tryUE(55, d.Endian) 3369 if err != nil { 3370 panic(IOError{Err: err, Op: "U55", Pos: d.Pos()}) 3371 } 3372 return v 3373} 3374 3375// TryFieldScalarU55 tries to add a field and read 55 bit unsigned integer in current endian 3376func (d *D) TryFieldScalarU55(name string, sms ...scalar.Mapper) (*scalar.S, error) { 3377 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 3378 v, err := d.tryUE(55, d.Endian) 3379 s.Actual = v 3380 return s, err 3381 }, sms...) 3382 if err != nil { 3383 return nil, err 3384 } 3385 return s, err 3386} 3387 3388// FieldScalarU55 adds a field and reads 55 bit unsigned integer in current endian 3389func (d *D) FieldScalarU55(name string, sms ...scalar.Mapper) *scalar.S { 3390 s, err := d.TryFieldScalarU55(name, sms...) 3391 if err != nil { 3392 panic(IOError{Err: err, Name: name, Op: "U55", Pos: d.Pos()}) 3393 } 3394 return s 3395} 3396 3397// TryFieldU55 tries to add a field and read 55 bit unsigned integer in current endian 3398func (d *D) TryFieldU55(name string, sms ...scalar.Mapper) (uint64, error) { 3399 s, err := d.TryFieldScalarU55(name, sms...) 3400 return s.ActualU(), err 3401} 3402 3403// FieldU55 adds a field and reads 55 bit unsigned integer in current endian 3404func (d *D) FieldU55(name string, sms ...scalar.Mapper) uint64 { 3405 return d.FieldScalarU55(name, sms...).ActualU() 3406} 3407 3408// Reader U56 3409 3410// TryU56 tries to read 56 bit unsigned integer in current endian 3411func (d *D) TryU56() (uint64, error) { return d.tryUE(56, d.Endian) } 3412 3413// U56 reads 56 bit unsigned integer in current endian 3414func (d *D) U56() uint64 { 3415 v, err := d.tryUE(56, d.Endian) 3416 if err != nil { 3417 panic(IOError{Err: err, Op: "U56", Pos: d.Pos()}) 3418 } 3419 return v 3420} 3421 3422// TryFieldScalarU56 tries to add a field and read 56 bit unsigned integer in current endian 3423func (d *D) TryFieldScalarU56(name string, sms ...scalar.Mapper) (*scalar.S, error) { 3424 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 3425 v, err := d.tryUE(56, d.Endian) 3426 s.Actual = v 3427 return s, err 3428 }, sms...) 3429 if err != nil { 3430 return nil, err 3431 } 3432 return s, err 3433} 3434 3435// FieldScalarU56 adds a field and reads 56 bit unsigned integer in current endian 3436func (d *D) FieldScalarU56(name string, sms ...scalar.Mapper) *scalar.S { 3437 s, err := d.TryFieldScalarU56(name, sms...) 3438 if err != nil { 3439 panic(IOError{Err: err, Name: name, Op: "U56", Pos: d.Pos()}) 3440 } 3441 return s 3442} 3443 3444// TryFieldU56 tries to add a field and read 56 bit unsigned integer in current endian 3445func (d *D) TryFieldU56(name string, sms ...scalar.Mapper) (uint64, error) { 3446 s, err := d.TryFieldScalarU56(name, sms...) 3447 return s.ActualU(), err 3448} 3449 3450// FieldU56 adds a field and reads 56 bit unsigned integer in current endian 3451func (d *D) FieldU56(name string, sms ...scalar.Mapper) uint64 { 3452 return d.FieldScalarU56(name, sms...).ActualU() 3453} 3454 3455// Reader U57 3456 3457// TryU57 tries to read 57 bit unsigned integer in current endian 3458func (d *D) TryU57() (uint64, error) { return d.tryUE(57, d.Endian) } 3459 3460// U57 reads 57 bit unsigned integer in current endian 3461func (d *D) U57() uint64 { 3462 v, err := d.tryUE(57, d.Endian) 3463 if err != nil { 3464 panic(IOError{Err: err, Op: "U57", Pos: d.Pos()}) 3465 } 3466 return v 3467} 3468 3469// TryFieldScalarU57 tries to add a field and read 57 bit unsigned integer in current endian 3470func (d *D) TryFieldScalarU57(name string, sms ...scalar.Mapper) (*scalar.S, error) { 3471 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 3472 v, err := d.tryUE(57, d.Endian) 3473 s.Actual = v 3474 return s, err 3475 }, sms...) 3476 if err != nil { 3477 return nil, err 3478 } 3479 return s, err 3480} 3481 3482// FieldScalarU57 adds a field and reads 57 bit unsigned integer in current endian 3483func (d *D) FieldScalarU57(name string, sms ...scalar.Mapper) *scalar.S { 3484 s, err := d.TryFieldScalarU57(name, sms...) 3485 if err != nil { 3486 panic(IOError{Err: err, Name: name, Op: "U57", Pos: d.Pos()}) 3487 } 3488 return s 3489} 3490 3491// TryFieldU57 tries to add a field and read 57 bit unsigned integer in current endian 3492func (d *D) TryFieldU57(name string, sms ...scalar.Mapper) (uint64, error) { 3493 s, err := d.TryFieldScalarU57(name, sms...) 3494 return s.ActualU(), err 3495} 3496 3497// FieldU57 adds a field and reads 57 bit unsigned integer in current endian 3498func (d *D) FieldU57(name string, sms ...scalar.Mapper) uint64 { 3499 return d.FieldScalarU57(name, sms...).ActualU() 3500} 3501 3502// Reader U58 3503 3504// TryU58 tries to read 58 bit unsigned integer in current endian 3505func (d *D) TryU58() (uint64, error) { return d.tryUE(58, d.Endian) } 3506 3507// U58 reads 58 bit unsigned integer in current endian 3508func (d *D) U58() uint64 { 3509 v, err := d.tryUE(58, d.Endian) 3510 if err != nil { 3511 panic(IOError{Err: err, Op: "U58", Pos: d.Pos()}) 3512 } 3513 return v 3514} 3515 3516// TryFieldScalarU58 tries to add a field and read 58 bit unsigned integer in current endian 3517func (d *D) TryFieldScalarU58(name string, sms ...scalar.Mapper) (*scalar.S, error) { 3518 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 3519 v, err := d.tryUE(58, d.Endian) 3520 s.Actual = v 3521 return s, err 3522 }, sms...) 3523 if err != nil { 3524 return nil, err 3525 } 3526 return s, err 3527} 3528 3529// FieldScalarU58 adds a field and reads 58 bit unsigned integer in current endian 3530func (d *D) FieldScalarU58(name string, sms ...scalar.Mapper) *scalar.S { 3531 s, err := d.TryFieldScalarU58(name, sms...) 3532 if err != nil { 3533 panic(IOError{Err: err, Name: name, Op: "U58", Pos: d.Pos()}) 3534 } 3535 return s 3536} 3537 3538// TryFieldU58 tries to add a field and read 58 bit unsigned integer in current endian 3539func (d *D) TryFieldU58(name string, sms ...scalar.Mapper) (uint64, error) { 3540 s, err := d.TryFieldScalarU58(name, sms...) 3541 return s.ActualU(), err 3542} 3543 3544// FieldU58 adds a field and reads 58 bit unsigned integer in current endian 3545func (d *D) FieldU58(name string, sms ...scalar.Mapper) uint64 { 3546 return d.FieldScalarU58(name, sms...).ActualU() 3547} 3548 3549// Reader U59 3550 3551// TryU59 tries to read 59 bit unsigned integer in current endian 3552func (d *D) TryU59() (uint64, error) { return d.tryUE(59, d.Endian) } 3553 3554// U59 reads 59 bit unsigned integer in current endian 3555func (d *D) U59() uint64 { 3556 v, err := d.tryUE(59, d.Endian) 3557 if err != nil { 3558 panic(IOError{Err: err, Op: "U59", Pos: d.Pos()}) 3559 } 3560 return v 3561} 3562 3563// TryFieldScalarU59 tries to add a field and read 59 bit unsigned integer in current endian 3564func (d *D) TryFieldScalarU59(name string, sms ...scalar.Mapper) (*scalar.S, error) { 3565 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 3566 v, err := d.tryUE(59, d.Endian) 3567 s.Actual = v 3568 return s, err 3569 }, sms...) 3570 if err != nil { 3571 return nil, err 3572 } 3573 return s, err 3574} 3575 3576// FieldScalarU59 adds a field and reads 59 bit unsigned integer in current endian 3577func (d *D) FieldScalarU59(name string, sms ...scalar.Mapper) *scalar.S { 3578 s, err := d.TryFieldScalarU59(name, sms...) 3579 if err != nil { 3580 panic(IOError{Err: err, Name: name, Op: "U59", Pos: d.Pos()}) 3581 } 3582 return s 3583} 3584 3585// TryFieldU59 tries to add a field and read 59 bit unsigned integer in current endian 3586func (d *D) TryFieldU59(name string, sms ...scalar.Mapper) (uint64, error) { 3587 s, err := d.TryFieldScalarU59(name, sms...) 3588 return s.ActualU(), err 3589} 3590 3591// FieldU59 adds a field and reads 59 bit unsigned integer in current endian 3592func (d *D) FieldU59(name string, sms ...scalar.Mapper) uint64 { 3593 return d.FieldScalarU59(name, sms...).ActualU() 3594} 3595 3596// Reader U60 3597 3598// TryU60 tries to read 60 bit unsigned integer in current endian 3599func (d *D) TryU60() (uint64, error) { return d.tryUE(60, d.Endian) } 3600 3601// U60 reads 60 bit unsigned integer in current endian 3602func (d *D) U60() uint64 { 3603 v, err := d.tryUE(60, d.Endian) 3604 if err != nil { 3605 panic(IOError{Err: err, Op: "U60", Pos: d.Pos()}) 3606 } 3607 return v 3608} 3609 3610// TryFieldScalarU60 tries to add a field and read 60 bit unsigned integer in current endian 3611func (d *D) TryFieldScalarU60(name string, sms ...scalar.Mapper) (*scalar.S, error) { 3612 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 3613 v, err := d.tryUE(60, d.Endian) 3614 s.Actual = v 3615 return s, err 3616 }, sms...) 3617 if err != nil { 3618 return nil, err 3619 } 3620 return s, err 3621} 3622 3623// FieldScalarU60 adds a field and reads 60 bit unsigned integer in current endian 3624func (d *D) FieldScalarU60(name string, sms ...scalar.Mapper) *scalar.S { 3625 s, err := d.TryFieldScalarU60(name, sms...) 3626 if err != nil { 3627 panic(IOError{Err: err, Name: name, Op: "U60", Pos: d.Pos()}) 3628 } 3629 return s 3630} 3631 3632// TryFieldU60 tries to add a field and read 60 bit unsigned integer in current endian 3633func (d *D) TryFieldU60(name string, sms ...scalar.Mapper) (uint64, error) { 3634 s, err := d.TryFieldScalarU60(name, sms...) 3635 return s.ActualU(), err 3636} 3637 3638// FieldU60 adds a field and reads 60 bit unsigned integer in current endian 3639func (d *D) FieldU60(name string, sms ...scalar.Mapper) uint64 { 3640 return d.FieldScalarU60(name, sms...).ActualU() 3641} 3642 3643// Reader U61 3644 3645// TryU61 tries to read 61 bit unsigned integer in current endian 3646func (d *D) TryU61() (uint64, error) { return d.tryUE(61, d.Endian) } 3647 3648// U61 reads 61 bit unsigned integer in current endian 3649func (d *D) U61() uint64 { 3650 v, err := d.tryUE(61, d.Endian) 3651 if err != nil { 3652 panic(IOError{Err: err, Op: "U61", Pos: d.Pos()}) 3653 } 3654 return v 3655} 3656 3657// TryFieldScalarU61 tries to add a field and read 61 bit unsigned integer in current endian 3658func (d *D) TryFieldScalarU61(name string, sms ...scalar.Mapper) (*scalar.S, error) { 3659 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 3660 v, err := d.tryUE(61, d.Endian) 3661 s.Actual = v 3662 return s, err 3663 }, sms...) 3664 if err != nil { 3665 return nil, err 3666 } 3667 return s, err 3668} 3669 3670// FieldScalarU61 adds a field and reads 61 bit unsigned integer in current endian 3671func (d *D) FieldScalarU61(name string, sms ...scalar.Mapper) *scalar.S { 3672 s, err := d.TryFieldScalarU61(name, sms...) 3673 if err != nil { 3674 panic(IOError{Err: err, Name: name, Op: "U61", Pos: d.Pos()}) 3675 } 3676 return s 3677} 3678 3679// TryFieldU61 tries to add a field and read 61 bit unsigned integer in current endian 3680func (d *D) TryFieldU61(name string, sms ...scalar.Mapper) (uint64, error) { 3681 s, err := d.TryFieldScalarU61(name, sms...) 3682 return s.ActualU(), err 3683} 3684 3685// FieldU61 adds a field and reads 61 bit unsigned integer in current endian 3686func (d *D) FieldU61(name string, sms ...scalar.Mapper) uint64 { 3687 return d.FieldScalarU61(name, sms...).ActualU() 3688} 3689 3690// Reader U62 3691 3692// TryU62 tries to read 62 bit unsigned integer in current endian 3693func (d *D) TryU62() (uint64, error) { return d.tryUE(62, d.Endian) } 3694 3695// U62 reads 62 bit unsigned integer in current endian 3696func (d *D) U62() uint64 { 3697 v, err := d.tryUE(62, d.Endian) 3698 if err != nil { 3699 panic(IOError{Err: err, Op: "U62", Pos: d.Pos()}) 3700 } 3701 return v 3702} 3703 3704// TryFieldScalarU62 tries to add a field and read 62 bit unsigned integer in current endian 3705func (d *D) TryFieldScalarU62(name string, sms ...scalar.Mapper) (*scalar.S, error) { 3706 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 3707 v, err := d.tryUE(62, d.Endian) 3708 s.Actual = v 3709 return s, err 3710 }, sms...) 3711 if err != nil { 3712 return nil, err 3713 } 3714 return s, err 3715} 3716 3717// FieldScalarU62 adds a field and reads 62 bit unsigned integer in current endian 3718func (d *D) FieldScalarU62(name string, sms ...scalar.Mapper) *scalar.S { 3719 s, err := d.TryFieldScalarU62(name, sms...) 3720 if err != nil { 3721 panic(IOError{Err: err, Name: name, Op: "U62", Pos: d.Pos()}) 3722 } 3723 return s 3724} 3725 3726// TryFieldU62 tries to add a field and read 62 bit unsigned integer in current endian 3727func (d *D) TryFieldU62(name string, sms ...scalar.Mapper) (uint64, error) { 3728 s, err := d.TryFieldScalarU62(name, sms...) 3729 return s.ActualU(), err 3730} 3731 3732// FieldU62 adds a field and reads 62 bit unsigned integer in current endian 3733func (d *D) FieldU62(name string, sms ...scalar.Mapper) uint64 { 3734 return d.FieldScalarU62(name, sms...).ActualU() 3735} 3736 3737// Reader U63 3738 3739// TryU63 tries to read 63 bit unsigned integer in current endian 3740func (d *D) TryU63() (uint64, error) { return d.tryUE(63, d.Endian) } 3741 3742// U63 reads 63 bit unsigned integer in current endian 3743func (d *D) U63() uint64 { 3744 v, err := d.tryUE(63, d.Endian) 3745 if err != nil { 3746 panic(IOError{Err: err, Op: "U63", Pos: d.Pos()}) 3747 } 3748 return v 3749} 3750 3751// TryFieldScalarU63 tries to add a field and read 63 bit unsigned integer in current endian 3752func (d *D) TryFieldScalarU63(name string, sms ...scalar.Mapper) (*scalar.S, error) { 3753 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 3754 v, err := d.tryUE(63, d.Endian) 3755 s.Actual = v 3756 return s, err 3757 }, sms...) 3758 if err != nil { 3759 return nil, err 3760 } 3761 return s, err 3762} 3763 3764// FieldScalarU63 adds a field and reads 63 bit unsigned integer in current endian 3765func (d *D) FieldScalarU63(name string, sms ...scalar.Mapper) *scalar.S { 3766 s, err := d.TryFieldScalarU63(name, sms...) 3767 if err != nil { 3768 panic(IOError{Err: err, Name: name, Op: "U63", Pos: d.Pos()}) 3769 } 3770 return s 3771} 3772 3773// TryFieldU63 tries to add a field and read 63 bit unsigned integer in current endian 3774func (d *D) TryFieldU63(name string, sms ...scalar.Mapper) (uint64, error) { 3775 s, err := d.TryFieldScalarU63(name, sms...) 3776 return s.ActualU(), err 3777} 3778 3779// FieldU63 adds a field and reads 63 bit unsigned integer in current endian 3780func (d *D) FieldU63(name string, sms ...scalar.Mapper) uint64 { 3781 return d.FieldScalarU63(name, sms...).ActualU() 3782} 3783 3784// Reader U64 3785 3786// TryU64 tries to read 64 bit unsigned integer in current endian 3787func (d *D) TryU64() (uint64, error) { return d.tryUE(64, d.Endian) } 3788 3789// U64 reads 64 bit unsigned integer in current endian 3790func (d *D) U64() uint64 { 3791 v, err := d.tryUE(64, d.Endian) 3792 if err != nil { 3793 panic(IOError{Err: err, Op: "U64", Pos: d.Pos()}) 3794 } 3795 return v 3796} 3797 3798// TryFieldScalarU64 tries to add a field and read 64 bit unsigned integer in current endian 3799func (d *D) TryFieldScalarU64(name string, sms ...scalar.Mapper) (*scalar.S, error) { 3800 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 3801 v, err := d.tryUE(64, d.Endian) 3802 s.Actual = v 3803 return s, err 3804 }, sms...) 3805 if err != nil { 3806 return nil, err 3807 } 3808 return s, err 3809} 3810 3811// FieldScalarU64 adds a field and reads 64 bit unsigned integer in current endian 3812func (d *D) FieldScalarU64(name string, sms ...scalar.Mapper) *scalar.S { 3813 s, err := d.TryFieldScalarU64(name, sms...) 3814 if err != nil { 3815 panic(IOError{Err: err, Name: name, Op: "U64", Pos: d.Pos()}) 3816 } 3817 return s 3818} 3819 3820// TryFieldU64 tries to add a field and read 64 bit unsigned integer in current endian 3821func (d *D) TryFieldU64(name string, sms ...scalar.Mapper) (uint64, error) { 3822 s, err := d.TryFieldScalarU64(name, sms...) 3823 return s.ActualU(), err 3824} 3825 3826// FieldU64 adds a field and reads 64 bit unsigned integer in current endian 3827func (d *D) FieldU64(name string, sms ...scalar.Mapper) uint64 { 3828 return d.FieldScalarU64(name, sms...).ActualU() 3829} 3830 3831// Reader U8LE 3832 3833// TryU8LE tries to read 8 bit unsigned integer in little-endian 3834func (d *D) TryU8LE() (uint64, error) { return d.tryUE(8, LittleEndian) } 3835 3836// U8LE reads 8 bit unsigned integer in little-endian 3837func (d *D) U8LE() uint64 { 3838 v, err := d.tryUE(8, LittleEndian) 3839 if err != nil { 3840 panic(IOError{Err: err, Op: "U8LE", Pos: d.Pos()}) 3841 } 3842 return v 3843} 3844 3845// TryFieldScalarU8LE tries to add a field and read 8 bit unsigned integer in little-endian 3846func (d *D) TryFieldScalarU8LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 3847 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 3848 v, err := d.tryUE(8, LittleEndian) 3849 s.Actual = v 3850 return s, err 3851 }, sms...) 3852 if err != nil { 3853 return nil, err 3854 } 3855 return s, err 3856} 3857 3858// FieldScalarU8LE adds a field and reads 8 bit unsigned integer in little-endian 3859func (d *D) FieldScalarU8LE(name string, sms ...scalar.Mapper) *scalar.S { 3860 s, err := d.TryFieldScalarU8LE(name, sms...) 3861 if err != nil { 3862 panic(IOError{Err: err, Name: name, Op: "U8LE", Pos: d.Pos()}) 3863 } 3864 return s 3865} 3866 3867// TryFieldU8LE tries to add a field and read 8 bit unsigned integer in little-endian 3868func (d *D) TryFieldU8LE(name string, sms ...scalar.Mapper) (uint64, error) { 3869 s, err := d.TryFieldScalarU8LE(name, sms...) 3870 return s.ActualU(), err 3871} 3872 3873// FieldU8LE adds a field and reads 8 bit unsigned integer in little-endian 3874func (d *D) FieldU8LE(name string, sms ...scalar.Mapper) uint64 { 3875 return d.FieldScalarU8LE(name, sms...).ActualU() 3876} 3877 3878// Reader U9LE 3879 3880// TryU9LE tries to read 9 bit unsigned integer in little-endian 3881func (d *D) TryU9LE() (uint64, error) { return d.tryUE(9, LittleEndian) } 3882 3883// U9LE reads 9 bit unsigned integer in little-endian 3884func (d *D) U9LE() uint64 { 3885 v, err := d.tryUE(9, LittleEndian) 3886 if err != nil { 3887 panic(IOError{Err: err, Op: "U9LE", Pos: d.Pos()}) 3888 } 3889 return v 3890} 3891 3892// TryFieldScalarU9LE tries to add a field and read 9 bit unsigned integer in little-endian 3893func (d *D) TryFieldScalarU9LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 3894 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 3895 v, err := d.tryUE(9, LittleEndian) 3896 s.Actual = v 3897 return s, err 3898 }, sms...) 3899 if err != nil { 3900 return nil, err 3901 } 3902 return s, err 3903} 3904 3905// FieldScalarU9LE adds a field and reads 9 bit unsigned integer in little-endian 3906func (d *D) FieldScalarU9LE(name string, sms ...scalar.Mapper) *scalar.S { 3907 s, err := d.TryFieldScalarU9LE(name, sms...) 3908 if err != nil { 3909 panic(IOError{Err: err, Name: name, Op: "U9LE", Pos: d.Pos()}) 3910 } 3911 return s 3912} 3913 3914// TryFieldU9LE tries to add a field and read 9 bit unsigned integer in little-endian 3915func (d *D) TryFieldU9LE(name string, sms ...scalar.Mapper) (uint64, error) { 3916 s, err := d.TryFieldScalarU9LE(name, sms...) 3917 return s.ActualU(), err 3918} 3919 3920// FieldU9LE adds a field and reads 9 bit unsigned integer in little-endian 3921func (d *D) FieldU9LE(name string, sms ...scalar.Mapper) uint64 { 3922 return d.FieldScalarU9LE(name, sms...).ActualU() 3923} 3924 3925// Reader U10LE 3926 3927// TryU10LE tries to read 10 bit unsigned integer in little-endian 3928func (d *D) TryU10LE() (uint64, error) { return d.tryUE(10, LittleEndian) } 3929 3930// U10LE reads 10 bit unsigned integer in little-endian 3931func (d *D) U10LE() uint64 { 3932 v, err := d.tryUE(10, LittleEndian) 3933 if err != nil { 3934 panic(IOError{Err: err, Op: "U10LE", Pos: d.Pos()}) 3935 } 3936 return v 3937} 3938 3939// TryFieldScalarU10LE tries to add a field and read 10 bit unsigned integer in little-endian 3940func (d *D) TryFieldScalarU10LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 3941 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 3942 v, err := d.tryUE(10, LittleEndian) 3943 s.Actual = v 3944 return s, err 3945 }, sms...) 3946 if err != nil { 3947 return nil, err 3948 } 3949 return s, err 3950} 3951 3952// FieldScalarU10LE adds a field and reads 10 bit unsigned integer in little-endian 3953func (d *D) FieldScalarU10LE(name string, sms ...scalar.Mapper) *scalar.S { 3954 s, err := d.TryFieldScalarU10LE(name, sms...) 3955 if err != nil { 3956 panic(IOError{Err: err, Name: name, Op: "U10LE", Pos: d.Pos()}) 3957 } 3958 return s 3959} 3960 3961// TryFieldU10LE tries to add a field and read 10 bit unsigned integer in little-endian 3962func (d *D) TryFieldU10LE(name string, sms ...scalar.Mapper) (uint64, error) { 3963 s, err := d.TryFieldScalarU10LE(name, sms...) 3964 return s.ActualU(), err 3965} 3966 3967// FieldU10LE adds a field and reads 10 bit unsigned integer in little-endian 3968func (d *D) FieldU10LE(name string, sms ...scalar.Mapper) uint64 { 3969 return d.FieldScalarU10LE(name, sms...).ActualU() 3970} 3971 3972// Reader U11LE 3973 3974// TryU11LE tries to read 11 bit unsigned integer in little-endian 3975func (d *D) TryU11LE() (uint64, error) { return d.tryUE(11, LittleEndian) } 3976 3977// U11LE reads 11 bit unsigned integer in little-endian 3978func (d *D) U11LE() uint64 { 3979 v, err := d.tryUE(11, LittleEndian) 3980 if err != nil { 3981 panic(IOError{Err: err, Op: "U11LE", Pos: d.Pos()}) 3982 } 3983 return v 3984} 3985 3986// TryFieldScalarU11LE tries to add a field and read 11 bit unsigned integer in little-endian 3987func (d *D) TryFieldScalarU11LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 3988 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 3989 v, err := d.tryUE(11, LittleEndian) 3990 s.Actual = v 3991 return s, err 3992 }, sms...) 3993 if err != nil { 3994 return nil, err 3995 } 3996 return s, err 3997} 3998 3999// FieldScalarU11LE adds a field and reads 11 bit unsigned integer in little-endian 4000func (d *D) FieldScalarU11LE(name string, sms ...scalar.Mapper) *scalar.S { 4001 s, err := d.TryFieldScalarU11LE(name, sms...) 4002 if err != nil { 4003 panic(IOError{Err: err, Name: name, Op: "U11LE", Pos: d.Pos()}) 4004 } 4005 return s 4006} 4007 4008// TryFieldU11LE tries to add a field and read 11 bit unsigned integer in little-endian 4009func (d *D) TryFieldU11LE(name string, sms ...scalar.Mapper) (uint64, error) { 4010 s, err := d.TryFieldScalarU11LE(name, sms...) 4011 return s.ActualU(), err 4012} 4013 4014// FieldU11LE adds a field and reads 11 bit unsigned integer in little-endian 4015func (d *D) FieldU11LE(name string, sms ...scalar.Mapper) uint64 { 4016 return d.FieldScalarU11LE(name, sms...).ActualU() 4017} 4018 4019// Reader U12LE 4020 4021// TryU12LE tries to read 12 bit unsigned integer in little-endian 4022func (d *D) TryU12LE() (uint64, error) { return d.tryUE(12, LittleEndian) } 4023 4024// U12LE reads 12 bit unsigned integer in little-endian 4025func (d *D) U12LE() uint64 { 4026 v, err := d.tryUE(12, LittleEndian) 4027 if err != nil { 4028 panic(IOError{Err: err, Op: "U12LE", Pos: d.Pos()}) 4029 } 4030 return v 4031} 4032 4033// TryFieldScalarU12LE tries to add a field and read 12 bit unsigned integer in little-endian 4034func (d *D) TryFieldScalarU12LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 4035 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 4036 v, err := d.tryUE(12, LittleEndian) 4037 s.Actual = v 4038 return s, err 4039 }, sms...) 4040 if err != nil { 4041 return nil, err 4042 } 4043 return s, err 4044} 4045 4046// FieldScalarU12LE adds a field and reads 12 bit unsigned integer in little-endian 4047func (d *D) FieldScalarU12LE(name string, sms ...scalar.Mapper) *scalar.S { 4048 s, err := d.TryFieldScalarU12LE(name, sms...) 4049 if err != nil { 4050 panic(IOError{Err: err, Name: name, Op: "U12LE", Pos: d.Pos()}) 4051 } 4052 return s 4053} 4054 4055// TryFieldU12LE tries to add a field and read 12 bit unsigned integer in little-endian 4056func (d *D) TryFieldU12LE(name string, sms ...scalar.Mapper) (uint64, error) { 4057 s, err := d.TryFieldScalarU12LE(name, sms...) 4058 return s.ActualU(), err 4059} 4060 4061// FieldU12LE adds a field and reads 12 bit unsigned integer in little-endian 4062func (d *D) FieldU12LE(name string, sms ...scalar.Mapper) uint64 { 4063 return d.FieldScalarU12LE(name, sms...).ActualU() 4064} 4065 4066// Reader U13LE 4067 4068// TryU13LE tries to read 13 bit unsigned integer in little-endian 4069func (d *D) TryU13LE() (uint64, error) { return d.tryUE(13, LittleEndian) } 4070 4071// U13LE reads 13 bit unsigned integer in little-endian 4072func (d *D) U13LE() uint64 { 4073 v, err := d.tryUE(13, LittleEndian) 4074 if err != nil { 4075 panic(IOError{Err: err, Op: "U13LE", Pos: d.Pos()}) 4076 } 4077 return v 4078} 4079 4080// TryFieldScalarU13LE tries to add a field and read 13 bit unsigned integer in little-endian 4081func (d *D) TryFieldScalarU13LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 4082 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 4083 v, err := d.tryUE(13, LittleEndian) 4084 s.Actual = v 4085 return s, err 4086 }, sms...) 4087 if err != nil { 4088 return nil, err 4089 } 4090 return s, err 4091} 4092 4093// FieldScalarU13LE adds a field and reads 13 bit unsigned integer in little-endian 4094func (d *D) FieldScalarU13LE(name string, sms ...scalar.Mapper) *scalar.S { 4095 s, err := d.TryFieldScalarU13LE(name, sms...) 4096 if err != nil { 4097 panic(IOError{Err: err, Name: name, Op: "U13LE", Pos: d.Pos()}) 4098 } 4099 return s 4100} 4101 4102// TryFieldU13LE tries to add a field and read 13 bit unsigned integer in little-endian 4103func (d *D) TryFieldU13LE(name string, sms ...scalar.Mapper) (uint64, error) { 4104 s, err := d.TryFieldScalarU13LE(name, sms...) 4105 return s.ActualU(), err 4106} 4107 4108// FieldU13LE adds a field and reads 13 bit unsigned integer in little-endian 4109func (d *D) FieldU13LE(name string, sms ...scalar.Mapper) uint64 { 4110 return d.FieldScalarU13LE(name, sms...).ActualU() 4111} 4112 4113// Reader U14LE 4114 4115// TryU14LE tries to read 14 bit unsigned integer in little-endian 4116func (d *D) TryU14LE() (uint64, error) { return d.tryUE(14, LittleEndian) } 4117 4118// U14LE reads 14 bit unsigned integer in little-endian 4119func (d *D) U14LE() uint64 { 4120 v, err := d.tryUE(14, LittleEndian) 4121 if err != nil { 4122 panic(IOError{Err: err, Op: "U14LE", Pos: d.Pos()}) 4123 } 4124 return v 4125} 4126 4127// TryFieldScalarU14LE tries to add a field and read 14 bit unsigned integer in little-endian 4128func (d *D) TryFieldScalarU14LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 4129 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 4130 v, err := d.tryUE(14, LittleEndian) 4131 s.Actual = v 4132 return s, err 4133 }, sms...) 4134 if err != nil { 4135 return nil, err 4136 } 4137 return s, err 4138} 4139 4140// FieldScalarU14LE adds a field and reads 14 bit unsigned integer in little-endian 4141func (d *D) FieldScalarU14LE(name string, sms ...scalar.Mapper) *scalar.S { 4142 s, err := d.TryFieldScalarU14LE(name, sms...) 4143 if err != nil { 4144 panic(IOError{Err: err, Name: name, Op: "U14LE", Pos: d.Pos()}) 4145 } 4146 return s 4147} 4148 4149// TryFieldU14LE tries to add a field and read 14 bit unsigned integer in little-endian 4150func (d *D) TryFieldU14LE(name string, sms ...scalar.Mapper) (uint64, error) { 4151 s, err := d.TryFieldScalarU14LE(name, sms...) 4152 return s.ActualU(), err 4153} 4154 4155// FieldU14LE adds a field and reads 14 bit unsigned integer in little-endian 4156func (d *D) FieldU14LE(name string, sms ...scalar.Mapper) uint64 { 4157 return d.FieldScalarU14LE(name, sms...).ActualU() 4158} 4159 4160// Reader U15LE 4161 4162// TryU15LE tries to read 15 bit unsigned integer in little-endian 4163func (d *D) TryU15LE() (uint64, error) { return d.tryUE(15, LittleEndian) } 4164 4165// U15LE reads 15 bit unsigned integer in little-endian 4166func (d *D) U15LE() uint64 { 4167 v, err := d.tryUE(15, LittleEndian) 4168 if err != nil { 4169 panic(IOError{Err: err, Op: "U15LE", Pos: d.Pos()}) 4170 } 4171 return v 4172} 4173 4174// TryFieldScalarU15LE tries to add a field and read 15 bit unsigned integer in little-endian 4175func (d *D) TryFieldScalarU15LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 4176 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 4177 v, err := d.tryUE(15, LittleEndian) 4178 s.Actual = v 4179 return s, err 4180 }, sms...) 4181 if err != nil { 4182 return nil, err 4183 } 4184 return s, err 4185} 4186 4187// FieldScalarU15LE adds a field and reads 15 bit unsigned integer in little-endian 4188func (d *D) FieldScalarU15LE(name string, sms ...scalar.Mapper) *scalar.S { 4189 s, err := d.TryFieldScalarU15LE(name, sms...) 4190 if err != nil { 4191 panic(IOError{Err: err, Name: name, Op: "U15LE", Pos: d.Pos()}) 4192 } 4193 return s 4194} 4195 4196// TryFieldU15LE tries to add a field and read 15 bit unsigned integer in little-endian 4197func (d *D) TryFieldU15LE(name string, sms ...scalar.Mapper) (uint64, error) { 4198 s, err := d.TryFieldScalarU15LE(name, sms...) 4199 return s.ActualU(), err 4200} 4201 4202// FieldU15LE adds a field and reads 15 bit unsigned integer in little-endian 4203func (d *D) FieldU15LE(name string, sms ...scalar.Mapper) uint64 { 4204 return d.FieldScalarU15LE(name, sms...).ActualU() 4205} 4206 4207// Reader U16LE 4208 4209// TryU16LE tries to read 16 bit unsigned integer in little-endian 4210func (d *D) TryU16LE() (uint64, error) { return d.tryUE(16, LittleEndian) } 4211 4212// U16LE reads 16 bit unsigned integer in little-endian 4213func (d *D) U16LE() uint64 { 4214 v, err := d.tryUE(16, LittleEndian) 4215 if err != nil { 4216 panic(IOError{Err: err, Op: "U16LE", Pos: d.Pos()}) 4217 } 4218 return v 4219} 4220 4221// TryFieldScalarU16LE tries to add a field and read 16 bit unsigned integer in little-endian 4222func (d *D) TryFieldScalarU16LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 4223 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 4224 v, err := d.tryUE(16, LittleEndian) 4225 s.Actual = v 4226 return s, err 4227 }, sms...) 4228 if err != nil { 4229 return nil, err 4230 } 4231 return s, err 4232} 4233 4234// FieldScalarU16LE adds a field and reads 16 bit unsigned integer in little-endian 4235func (d *D) FieldScalarU16LE(name string, sms ...scalar.Mapper) *scalar.S { 4236 s, err := d.TryFieldScalarU16LE(name, sms...) 4237 if err != nil { 4238 panic(IOError{Err: err, Name: name, Op: "U16LE", Pos: d.Pos()}) 4239 } 4240 return s 4241} 4242 4243// TryFieldU16LE tries to add a field and read 16 bit unsigned integer in little-endian 4244func (d *D) TryFieldU16LE(name string, sms ...scalar.Mapper) (uint64, error) { 4245 s, err := d.TryFieldScalarU16LE(name, sms...) 4246 return s.ActualU(), err 4247} 4248 4249// FieldU16LE adds a field and reads 16 bit unsigned integer in little-endian 4250func (d *D) FieldU16LE(name string, sms ...scalar.Mapper) uint64 { 4251 return d.FieldScalarU16LE(name, sms...).ActualU() 4252} 4253 4254// Reader U17LE 4255 4256// TryU17LE tries to read 17 bit unsigned integer in little-endian 4257func (d *D) TryU17LE() (uint64, error) { return d.tryUE(17, LittleEndian) } 4258 4259// U17LE reads 17 bit unsigned integer in little-endian 4260func (d *D) U17LE() uint64 { 4261 v, err := d.tryUE(17, LittleEndian) 4262 if err != nil { 4263 panic(IOError{Err: err, Op: "U17LE", Pos: d.Pos()}) 4264 } 4265 return v 4266} 4267 4268// TryFieldScalarU17LE tries to add a field and read 17 bit unsigned integer in little-endian 4269func (d *D) TryFieldScalarU17LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 4270 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 4271 v, err := d.tryUE(17, LittleEndian) 4272 s.Actual = v 4273 return s, err 4274 }, sms...) 4275 if err != nil { 4276 return nil, err 4277 } 4278 return s, err 4279} 4280 4281// FieldScalarU17LE adds a field and reads 17 bit unsigned integer in little-endian 4282func (d *D) FieldScalarU17LE(name string, sms ...scalar.Mapper) *scalar.S { 4283 s, err := d.TryFieldScalarU17LE(name, sms...) 4284 if err != nil { 4285 panic(IOError{Err: err, Name: name, Op: "U17LE", Pos: d.Pos()}) 4286 } 4287 return s 4288} 4289 4290// TryFieldU17LE tries to add a field and read 17 bit unsigned integer in little-endian 4291func (d *D) TryFieldU17LE(name string, sms ...scalar.Mapper) (uint64, error) { 4292 s, err := d.TryFieldScalarU17LE(name, sms...) 4293 return s.ActualU(), err 4294} 4295 4296// FieldU17LE adds a field and reads 17 bit unsigned integer in little-endian 4297func (d *D) FieldU17LE(name string, sms ...scalar.Mapper) uint64 { 4298 return d.FieldScalarU17LE(name, sms...).ActualU() 4299} 4300 4301// Reader U18LE 4302 4303// TryU18LE tries to read 18 bit unsigned integer in little-endian 4304func (d *D) TryU18LE() (uint64, error) { return d.tryUE(18, LittleEndian) } 4305 4306// U18LE reads 18 bit unsigned integer in little-endian 4307func (d *D) U18LE() uint64 { 4308 v, err := d.tryUE(18, LittleEndian) 4309 if err != nil { 4310 panic(IOError{Err: err, Op: "U18LE", Pos: d.Pos()}) 4311 } 4312 return v 4313} 4314 4315// TryFieldScalarU18LE tries to add a field and read 18 bit unsigned integer in little-endian 4316func (d *D) TryFieldScalarU18LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 4317 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 4318 v, err := d.tryUE(18, LittleEndian) 4319 s.Actual = v 4320 return s, err 4321 }, sms...) 4322 if err != nil { 4323 return nil, err 4324 } 4325 return s, err 4326} 4327 4328// FieldScalarU18LE adds a field and reads 18 bit unsigned integer in little-endian 4329func (d *D) FieldScalarU18LE(name string, sms ...scalar.Mapper) *scalar.S { 4330 s, err := d.TryFieldScalarU18LE(name, sms...) 4331 if err != nil { 4332 panic(IOError{Err: err, Name: name, Op: "U18LE", Pos: d.Pos()}) 4333 } 4334 return s 4335} 4336 4337// TryFieldU18LE tries to add a field and read 18 bit unsigned integer in little-endian 4338func (d *D) TryFieldU18LE(name string, sms ...scalar.Mapper) (uint64, error) { 4339 s, err := d.TryFieldScalarU18LE(name, sms...) 4340 return s.ActualU(), err 4341} 4342 4343// FieldU18LE adds a field and reads 18 bit unsigned integer in little-endian 4344func (d *D) FieldU18LE(name string, sms ...scalar.Mapper) uint64 { 4345 return d.FieldScalarU18LE(name, sms...).ActualU() 4346} 4347 4348// Reader U19LE 4349 4350// TryU19LE tries to read 19 bit unsigned integer in little-endian 4351func (d *D) TryU19LE() (uint64, error) { return d.tryUE(19, LittleEndian) } 4352 4353// U19LE reads 19 bit unsigned integer in little-endian 4354func (d *D) U19LE() uint64 { 4355 v, err := d.tryUE(19, LittleEndian) 4356 if err != nil { 4357 panic(IOError{Err: err, Op: "U19LE", Pos: d.Pos()}) 4358 } 4359 return v 4360} 4361 4362// TryFieldScalarU19LE tries to add a field and read 19 bit unsigned integer in little-endian 4363func (d *D) TryFieldScalarU19LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 4364 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 4365 v, err := d.tryUE(19, LittleEndian) 4366 s.Actual = v 4367 return s, err 4368 }, sms...) 4369 if err != nil { 4370 return nil, err 4371 } 4372 return s, err 4373} 4374 4375// FieldScalarU19LE adds a field and reads 19 bit unsigned integer in little-endian 4376func (d *D) FieldScalarU19LE(name string, sms ...scalar.Mapper) *scalar.S { 4377 s, err := d.TryFieldScalarU19LE(name, sms...) 4378 if err != nil { 4379 panic(IOError{Err: err, Name: name, Op: "U19LE", Pos: d.Pos()}) 4380 } 4381 return s 4382} 4383 4384// TryFieldU19LE tries to add a field and read 19 bit unsigned integer in little-endian 4385func (d *D) TryFieldU19LE(name string, sms ...scalar.Mapper) (uint64, error) { 4386 s, err := d.TryFieldScalarU19LE(name, sms...) 4387 return s.ActualU(), err 4388} 4389 4390// FieldU19LE adds a field and reads 19 bit unsigned integer in little-endian 4391func (d *D) FieldU19LE(name string, sms ...scalar.Mapper) uint64 { 4392 return d.FieldScalarU19LE(name, sms...).ActualU() 4393} 4394 4395// Reader U20LE 4396 4397// TryU20LE tries to read 20 bit unsigned integer in little-endian 4398func (d *D) TryU20LE() (uint64, error) { return d.tryUE(20, LittleEndian) } 4399 4400// U20LE reads 20 bit unsigned integer in little-endian 4401func (d *D) U20LE() uint64 { 4402 v, err := d.tryUE(20, LittleEndian) 4403 if err != nil { 4404 panic(IOError{Err: err, Op: "U20LE", Pos: d.Pos()}) 4405 } 4406 return v 4407} 4408 4409// TryFieldScalarU20LE tries to add a field and read 20 bit unsigned integer in little-endian 4410func (d *D) TryFieldScalarU20LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 4411 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 4412 v, err := d.tryUE(20, LittleEndian) 4413 s.Actual = v 4414 return s, err 4415 }, sms...) 4416 if err != nil { 4417 return nil, err 4418 } 4419 return s, err 4420} 4421 4422// FieldScalarU20LE adds a field and reads 20 bit unsigned integer in little-endian 4423func (d *D) FieldScalarU20LE(name string, sms ...scalar.Mapper) *scalar.S { 4424 s, err := d.TryFieldScalarU20LE(name, sms...) 4425 if err != nil { 4426 panic(IOError{Err: err, Name: name, Op: "U20LE", Pos: d.Pos()}) 4427 } 4428 return s 4429} 4430 4431// TryFieldU20LE tries to add a field and read 20 bit unsigned integer in little-endian 4432func (d *D) TryFieldU20LE(name string, sms ...scalar.Mapper) (uint64, error) { 4433 s, err := d.TryFieldScalarU20LE(name, sms...) 4434 return s.ActualU(), err 4435} 4436 4437// FieldU20LE adds a field and reads 20 bit unsigned integer in little-endian 4438func (d *D) FieldU20LE(name string, sms ...scalar.Mapper) uint64 { 4439 return d.FieldScalarU20LE(name, sms...).ActualU() 4440} 4441 4442// Reader U21LE 4443 4444// TryU21LE tries to read 21 bit unsigned integer in little-endian 4445func (d *D) TryU21LE() (uint64, error) { return d.tryUE(21, LittleEndian) } 4446 4447// U21LE reads 21 bit unsigned integer in little-endian 4448func (d *D) U21LE() uint64 { 4449 v, err := d.tryUE(21, LittleEndian) 4450 if err != nil { 4451 panic(IOError{Err: err, Op: "U21LE", Pos: d.Pos()}) 4452 } 4453 return v 4454} 4455 4456// TryFieldScalarU21LE tries to add a field and read 21 bit unsigned integer in little-endian 4457func (d *D) TryFieldScalarU21LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 4458 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 4459 v, err := d.tryUE(21, LittleEndian) 4460 s.Actual = v 4461 return s, err 4462 }, sms...) 4463 if err != nil { 4464 return nil, err 4465 } 4466 return s, err 4467} 4468 4469// FieldScalarU21LE adds a field and reads 21 bit unsigned integer in little-endian 4470func (d *D) FieldScalarU21LE(name string, sms ...scalar.Mapper) *scalar.S { 4471 s, err := d.TryFieldScalarU21LE(name, sms...) 4472 if err != nil { 4473 panic(IOError{Err: err, Name: name, Op: "U21LE", Pos: d.Pos()}) 4474 } 4475 return s 4476} 4477 4478// TryFieldU21LE tries to add a field and read 21 bit unsigned integer in little-endian 4479func (d *D) TryFieldU21LE(name string, sms ...scalar.Mapper) (uint64, error) { 4480 s, err := d.TryFieldScalarU21LE(name, sms...) 4481 return s.ActualU(), err 4482} 4483 4484// FieldU21LE adds a field and reads 21 bit unsigned integer in little-endian 4485func (d *D) FieldU21LE(name string, sms ...scalar.Mapper) uint64 { 4486 return d.FieldScalarU21LE(name, sms...).ActualU() 4487} 4488 4489// Reader U22LE 4490 4491// TryU22LE tries to read 22 bit unsigned integer in little-endian 4492func (d *D) TryU22LE() (uint64, error) { return d.tryUE(22, LittleEndian) } 4493 4494// U22LE reads 22 bit unsigned integer in little-endian 4495func (d *D) U22LE() uint64 { 4496 v, err := d.tryUE(22, LittleEndian) 4497 if err != nil { 4498 panic(IOError{Err: err, Op: "U22LE", Pos: d.Pos()}) 4499 } 4500 return v 4501} 4502 4503// TryFieldScalarU22LE tries to add a field and read 22 bit unsigned integer in little-endian 4504func (d *D) TryFieldScalarU22LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 4505 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 4506 v, err := d.tryUE(22, LittleEndian) 4507 s.Actual = v 4508 return s, err 4509 }, sms...) 4510 if err != nil { 4511 return nil, err 4512 } 4513 return s, err 4514} 4515 4516// FieldScalarU22LE adds a field and reads 22 bit unsigned integer in little-endian 4517func (d *D) FieldScalarU22LE(name string, sms ...scalar.Mapper) *scalar.S { 4518 s, err := d.TryFieldScalarU22LE(name, sms...) 4519 if err != nil { 4520 panic(IOError{Err: err, Name: name, Op: "U22LE", Pos: d.Pos()}) 4521 } 4522 return s 4523} 4524 4525// TryFieldU22LE tries to add a field and read 22 bit unsigned integer in little-endian 4526func (d *D) TryFieldU22LE(name string, sms ...scalar.Mapper) (uint64, error) { 4527 s, err := d.TryFieldScalarU22LE(name, sms...) 4528 return s.ActualU(), err 4529} 4530 4531// FieldU22LE adds a field and reads 22 bit unsigned integer in little-endian 4532func (d *D) FieldU22LE(name string, sms ...scalar.Mapper) uint64 { 4533 return d.FieldScalarU22LE(name, sms...).ActualU() 4534} 4535 4536// Reader U23LE 4537 4538// TryU23LE tries to read 23 bit unsigned integer in little-endian 4539func (d *D) TryU23LE() (uint64, error) { return d.tryUE(23, LittleEndian) } 4540 4541// U23LE reads 23 bit unsigned integer in little-endian 4542func (d *D) U23LE() uint64 { 4543 v, err := d.tryUE(23, LittleEndian) 4544 if err != nil { 4545 panic(IOError{Err: err, Op: "U23LE", Pos: d.Pos()}) 4546 } 4547 return v 4548} 4549 4550// TryFieldScalarU23LE tries to add a field and read 23 bit unsigned integer in little-endian 4551func (d *D) TryFieldScalarU23LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 4552 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 4553 v, err := d.tryUE(23, LittleEndian) 4554 s.Actual = v 4555 return s, err 4556 }, sms...) 4557 if err != nil { 4558 return nil, err 4559 } 4560 return s, err 4561} 4562 4563// FieldScalarU23LE adds a field and reads 23 bit unsigned integer in little-endian 4564func (d *D) FieldScalarU23LE(name string, sms ...scalar.Mapper) *scalar.S { 4565 s, err := d.TryFieldScalarU23LE(name, sms...) 4566 if err != nil { 4567 panic(IOError{Err: err, Name: name, Op: "U23LE", Pos: d.Pos()}) 4568 } 4569 return s 4570} 4571 4572// TryFieldU23LE tries to add a field and read 23 bit unsigned integer in little-endian 4573func (d *D) TryFieldU23LE(name string, sms ...scalar.Mapper) (uint64, error) { 4574 s, err := d.TryFieldScalarU23LE(name, sms...) 4575 return s.ActualU(), err 4576} 4577 4578// FieldU23LE adds a field and reads 23 bit unsigned integer in little-endian 4579func (d *D) FieldU23LE(name string, sms ...scalar.Mapper) uint64 { 4580 return d.FieldScalarU23LE(name, sms...).ActualU() 4581} 4582 4583// Reader U24LE 4584 4585// TryU24LE tries to read 24 bit unsigned integer in little-endian 4586func (d *D) TryU24LE() (uint64, error) { return d.tryUE(24, LittleEndian) } 4587 4588// U24LE reads 24 bit unsigned integer in little-endian 4589func (d *D) U24LE() uint64 { 4590 v, err := d.tryUE(24, LittleEndian) 4591 if err != nil { 4592 panic(IOError{Err: err, Op: "U24LE", Pos: d.Pos()}) 4593 } 4594 return v 4595} 4596 4597// TryFieldScalarU24LE tries to add a field and read 24 bit unsigned integer in little-endian 4598func (d *D) TryFieldScalarU24LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 4599 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 4600 v, err := d.tryUE(24, LittleEndian) 4601 s.Actual = v 4602 return s, err 4603 }, sms...) 4604 if err != nil { 4605 return nil, err 4606 } 4607 return s, err 4608} 4609 4610// FieldScalarU24LE adds a field and reads 24 bit unsigned integer in little-endian 4611func (d *D) FieldScalarU24LE(name string, sms ...scalar.Mapper) *scalar.S { 4612 s, err := d.TryFieldScalarU24LE(name, sms...) 4613 if err != nil { 4614 panic(IOError{Err: err, Name: name, Op: "U24LE", Pos: d.Pos()}) 4615 } 4616 return s 4617} 4618 4619// TryFieldU24LE tries to add a field and read 24 bit unsigned integer in little-endian 4620func (d *D) TryFieldU24LE(name string, sms ...scalar.Mapper) (uint64, error) { 4621 s, err := d.TryFieldScalarU24LE(name, sms...) 4622 return s.ActualU(), err 4623} 4624 4625// FieldU24LE adds a field and reads 24 bit unsigned integer in little-endian 4626func (d *D) FieldU24LE(name string, sms ...scalar.Mapper) uint64 { 4627 return d.FieldScalarU24LE(name, sms...).ActualU() 4628} 4629 4630// Reader U25LE 4631 4632// TryU25LE tries to read 25 bit unsigned integer in little-endian 4633func (d *D) TryU25LE() (uint64, error) { return d.tryUE(25, LittleEndian) } 4634 4635// U25LE reads 25 bit unsigned integer in little-endian 4636func (d *D) U25LE() uint64 { 4637 v, err := d.tryUE(25, LittleEndian) 4638 if err != nil { 4639 panic(IOError{Err: err, Op: "U25LE", Pos: d.Pos()}) 4640 } 4641 return v 4642} 4643 4644// TryFieldScalarU25LE tries to add a field and read 25 bit unsigned integer in little-endian 4645func (d *D) TryFieldScalarU25LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 4646 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 4647 v, err := d.tryUE(25, LittleEndian) 4648 s.Actual = v 4649 return s, err 4650 }, sms...) 4651 if err != nil { 4652 return nil, err 4653 } 4654 return s, err 4655} 4656 4657// FieldScalarU25LE adds a field and reads 25 bit unsigned integer in little-endian 4658func (d *D) FieldScalarU25LE(name string, sms ...scalar.Mapper) *scalar.S { 4659 s, err := d.TryFieldScalarU25LE(name, sms...) 4660 if err != nil { 4661 panic(IOError{Err: err, Name: name, Op: "U25LE", Pos: d.Pos()}) 4662 } 4663 return s 4664} 4665 4666// TryFieldU25LE tries to add a field and read 25 bit unsigned integer in little-endian 4667func (d *D) TryFieldU25LE(name string, sms ...scalar.Mapper) (uint64, error) { 4668 s, err := d.TryFieldScalarU25LE(name, sms...) 4669 return s.ActualU(), err 4670} 4671 4672// FieldU25LE adds a field and reads 25 bit unsigned integer in little-endian 4673func (d *D) FieldU25LE(name string, sms ...scalar.Mapper) uint64 { 4674 return d.FieldScalarU25LE(name, sms...).ActualU() 4675} 4676 4677// Reader U26LE 4678 4679// TryU26LE tries to read 26 bit unsigned integer in little-endian 4680func (d *D) TryU26LE() (uint64, error) { return d.tryUE(26, LittleEndian) } 4681 4682// U26LE reads 26 bit unsigned integer in little-endian 4683func (d *D) U26LE() uint64 { 4684 v, err := d.tryUE(26, LittleEndian) 4685 if err != nil { 4686 panic(IOError{Err: err, Op: "U26LE", Pos: d.Pos()}) 4687 } 4688 return v 4689} 4690 4691// TryFieldScalarU26LE tries to add a field and read 26 bit unsigned integer in little-endian 4692func (d *D) TryFieldScalarU26LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 4693 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 4694 v, err := d.tryUE(26, LittleEndian) 4695 s.Actual = v 4696 return s, err 4697 }, sms...) 4698 if err != nil { 4699 return nil, err 4700 } 4701 return s, err 4702} 4703 4704// FieldScalarU26LE adds a field and reads 26 bit unsigned integer in little-endian 4705func (d *D) FieldScalarU26LE(name string, sms ...scalar.Mapper) *scalar.S { 4706 s, err := d.TryFieldScalarU26LE(name, sms...) 4707 if err != nil { 4708 panic(IOError{Err: err, Name: name, Op: "U26LE", Pos: d.Pos()}) 4709 } 4710 return s 4711} 4712 4713// TryFieldU26LE tries to add a field and read 26 bit unsigned integer in little-endian 4714func (d *D) TryFieldU26LE(name string, sms ...scalar.Mapper) (uint64, error) { 4715 s, err := d.TryFieldScalarU26LE(name, sms...) 4716 return s.ActualU(), err 4717} 4718 4719// FieldU26LE adds a field and reads 26 bit unsigned integer in little-endian 4720func (d *D) FieldU26LE(name string, sms ...scalar.Mapper) uint64 { 4721 return d.FieldScalarU26LE(name, sms...).ActualU() 4722} 4723 4724// Reader U27LE 4725 4726// TryU27LE tries to read 27 bit unsigned integer in little-endian 4727func (d *D) TryU27LE() (uint64, error) { return d.tryUE(27, LittleEndian) } 4728 4729// U27LE reads 27 bit unsigned integer in little-endian 4730func (d *D) U27LE() uint64 { 4731 v, err := d.tryUE(27, LittleEndian) 4732 if err != nil { 4733 panic(IOError{Err: err, Op: "U27LE", Pos: d.Pos()}) 4734 } 4735 return v 4736} 4737 4738// TryFieldScalarU27LE tries to add a field and read 27 bit unsigned integer in little-endian 4739func (d *D) TryFieldScalarU27LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 4740 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 4741 v, err := d.tryUE(27, LittleEndian) 4742 s.Actual = v 4743 return s, err 4744 }, sms...) 4745 if err != nil { 4746 return nil, err 4747 } 4748 return s, err 4749} 4750 4751// FieldScalarU27LE adds a field and reads 27 bit unsigned integer in little-endian 4752func (d *D) FieldScalarU27LE(name string, sms ...scalar.Mapper) *scalar.S { 4753 s, err := d.TryFieldScalarU27LE(name, sms...) 4754 if err != nil { 4755 panic(IOError{Err: err, Name: name, Op: "U27LE", Pos: d.Pos()}) 4756 } 4757 return s 4758} 4759 4760// TryFieldU27LE tries to add a field and read 27 bit unsigned integer in little-endian 4761func (d *D) TryFieldU27LE(name string, sms ...scalar.Mapper) (uint64, error) { 4762 s, err := d.TryFieldScalarU27LE(name, sms...) 4763 return s.ActualU(), err 4764} 4765 4766// FieldU27LE adds a field and reads 27 bit unsigned integer in little-endian 4767func (d *D) FieldU27LE(name string, sms ...scalar.Mapper) uint64 { 4768 return d.FieldScalarU27LE(name, sms...).ActualU() 4769} 4770 4771// Reader U28LE 4772 4773// TryU28LE tries to read 28 bit unsigned integer in little-endian 4774func (d *D) TryU28LE() (uint64, error) { return d.tryUE(28, LittleEndian) } 4775 4776// U28LE reads 28 bit unsigned integer in little-endian 4777func (d *D) U28LE() uint64 { 4778 v, err := d.tryUE(28, LittleEndian) 4779 if err != nil { 4780 panic(IOError{Err: err, Op: "U28LE", Pos: d.Pos()}) 4781 } 4782 return v 4783} 4784 4785// TryFieldScalarU28LE tries to add a field and read 28 bit unsigned integer in little-endian 4786func (d *D) TryFieldScalarU28LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 4787 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 4788 v, err := d.tryUE(28, LittleEndian) 4789 s.Actual = v 4790 return s, err 4791 }, sms...) 4792 if err != nil { 4793 return nil, err 4794 } 4795 return s, err 4796} 4797 4798// FieldScalarU28LE adds a field and reads 28 bit unsigned integer in little-endian 4799func (d *D) FieldScalarU28LE(name string, sms ...scalar.Mapper) *scalar.S { 4800 s, err := d.TryFieldScalarU28LE(name, sms...) 4801 if err != nil { 4802 panic(IOError{Err: err, Name: name, Op: "U28LE", Pos: d.Pos()}) 4803 } 4804 return s 4805} 4806 4807// TryFieldU28LE tries to add a field and read 28 bit unsigned integer in little-endian 4808func (d *D) TryFieldU28LE(name string, sms ...scalar.Mapper) (uint64, error) { 4809 s, err := d.TryFieldScalarU28LE(name, sms...) 4810 return s.ActualU(), err 4811} 4812 4813// FieldU28LE adds a field and reads 28 bit unsigned integer in little-endian 4814func (d *D) FieldU28LE(name string, sms ...scalar.Mapper) uint64 { 4815 return d.FieldScalarU28LE(name, sms...).ActualU() 4816} 4817 4818// Reader U29LE 4819 4820// TryU29LE tries to read 29 bit unsigned integer in little-endian 4821func (d *D) TryU29LE() (uint64, error) { return d.tryUE(29, LittleEndian) } 4822 4823// U29LE reads 29 bit unsigned integer in little-endian 4824func (d *D) U29LE() uint64 { 4825 v, err := d.tryUE(29, LittleEndian) 4826 if err != nil { 4827 panic(IOError{Err: err, Op: "U29LE", Pos: d.Pos()}) 4828 } 4829 return v 4830} 4831 4832// TryFieldScalarU29LE tries to add a field and read 29 bit unsigned integer in little-endian 4833func (d *D) TryFieldScalarU29LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 4834 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 4835 v, err := d.tryUE(29, LittleEndian) 4836 s.Actual = v 4837 return s, err 4838 }, sms...) 4839 if err != nil { 4840 return nil, err 4841 } 4842 return s, err 4843} 4844 4845// FieldScalarU29LE adds a field and reads 29 bit unsigned integer in little-endian 4846func (d *D) FieldScalarU29LE(name string, sms ...scalar.Mapper) *scalar.S { 4847 s, err := d.TryFieldScalarU29LE(name, sms...) 4848 if err != nil { 4849 panic(IOError{Err: err, Name: name, Op: "U29LE", Pos: d.Pos()}) 4850 } 4851 return s 4852} 4853 4854// TryFieldU29LE tries to add a field and read 29 bit unsigned integer in little-endian 4855func (d *D) TryFieldU29LE(name string, sms ...scalar.Mapper) (uint64, error) { 4856 s, err := d.TryFieldScalarU29LE(name, sms...) 4857 return s.ActualU(), err 4858} 4859 4860// FieldU29LE adds a field and reads 29 bit unsigned integer in little-endian 4861func (d *D) FieldU29LE(name string, sms ...scalar.Mapper) uint64 { 4862 return d.FieldScalarU29LE(name, sms...).ActualU() 4863} 4864 4865// Reader U30LE 4866 4867// TryU30LE tries to read 30 bit unsigned integer in little-endian 4868func (d *D) TryU30LE() (uint64, error) { return d.tryUE(30, LittleEndian) } 4869 4870// U30LE reads 30 bit unsigned integer in little-endian 4871func (d *D) U30LE() uint64 { 4872 v, err := d.tryUE(30, LittleEndian) 4873 if err != nil { 4874 panic(IOError{Err: err, Op: "U30LE", Pos: d.Pos()}) 4875 } 4876 return v 4877} 4878 4879// TryFieldScalarU30LE tries to add a field and read 30 bit unsigned integer in little-endian 4880func (d *D) TryFieldScalarU30LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 4881 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 4882 v, err := d.tryUE(30, LittleEndian) 4883 s.Actual = v 4884 return s, err 4885 }, sms...) 4886 if err != nil { 4887 return nil, err 4888 } 4889 return s, err 4890} 4891 4892// FieldScalarU30LE adds a field and reads 30 bit unsigned integer in little-endian 4893func (d *D) FieldScalarU30LE(name string, sms ...scalar.Mapper) *scalar.S { 4894 s, err := d.TryFieldScalarU30LE(name, sms...) 4895 if err != nil { 4896 panic(IOError{Err: err, Name: name, Op: "U30LE", Pos: d.Pos()}) 4897 } 4898 return s 4899} 4900 4901// TryFieldU30LE tries to add a field and read 30 bit unsigned integer in little-endian 4902func (d *D) TryFieldU30LE(name string, sms ...scalar.Mapper) (uint64, error) { 4903 s, err := d.TryFieldScalarU30LE(name, sms...) 4904 return s.ActualU(), err 4905} 4906 4907// FieldU30LE adds a field and reads 30 bit unsigned integer in little-endian 4908func (d *D) FieldU30LE(name string, sms ...scalar.Mapper) uint64 { 4909 return d.FieldScalarU30LE(name, sms...).ActualU() 4910} 4911 4912// Reader U31LE 4913 4914// TryU31LE tries to read 31 bit unsigned integer in little-endian 4915func (d *D) TryU31LE() (uint64, error) { return d.tryUE(31, LittleEndian) } 4916 4917// U31LE reads 31 bit unsigned integer in little-endian 4918func (d *D) U31LE() uint64 { 4919 v, err := d.tryUE(31, LittleEndian) 4920 if err != nil { 4921 panic(IOError{Err: err, Op: "U31LE", Pos: d.Pos()}) 4922 } 4923 return v 4924} 4925 4926// TryFieldScalarU31LE tries to add a field and read 31 bit unsigned integer in little-endian 4927func (d *D) TryFieldScalarU31LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 4928 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 4929 v, err := d.tryUE(31, LittleEndian) 4930 s.Actual = v 4931 return s, err 4932 }, sms...) 4933 if err != nil { 4934 return nil, err 4935 } 4936 return s, err 4937} 4938 4939// FieldScalarU31LE adds a field and reads 31 bit unsigned integer in little-endian 4940func (d *D) FieldScalarU31LE(name string, sms ...scalar.Mapper) *scalar.S { 4941 s, err := d.TryFieldScalarU31LE(name, sms...) 4942 if err != nil { 4943 panic(IOError{Err: err, Name: name, Op: "U31LE", Pos: d.Pos()}) 4944 } 4945 return s 4946} 4947 4948// TryFieldU31LE tries to add a field and read 31 bit unsigned integer in little-endian 4949func (d *D) TryFieldU31LE(name string, sms ...scalar.Mapper) (uint64, error) { 4950 s, err := d.TryFieldScalarU31LE(name, sms...) 4951 return s.ActualU(), err 4952} 4953 4954// FieldU31LE adds a field and reads 31 bit unsigned integer in little-endian 4955func (d *D) FieldU31LE(name string, sms ...scalar.Mapper) uint64 { 4956 return d.FieldScalarU31LE(name, sms...).ActualU() 4957} 4958 4959// Reader U32LE 4960 4961// TryU32LE tries to read 32 bit unsigned integer in little-endian 4962func (d *D) TryU32LE() (uint64, error) { return d.tryUE(32, LittleEndian) } 4963 4964// U32LE reads 32 bit unsigned integer in little-endian 4965func (d *D) U32LE() uint64 { 4966 v, err := d.tryUE(32, LittleEndian) 4967 if err != nil { 4968 panic(IOError{Err: err, Op: "U32LE", Pos: d.Pos()}) 4969 } 4970 return v 4971} 4972 4973// TryFieldScalarU32LE tries to add a field and read 32 bit unsigned integer in little-endian 4974func (d *D) TryFieldScalarU32LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 4975 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 4976 v, err := d.tryUE(32, LittleEndian) 4977 s.Actual = v 4978 return s, err 4979 }, sms...) 4980 if err != nil { 4981 return nil, err 4982 } 4983 return s, err 4984} 4985 4986// FieldScalarU32LE adds a field and reads 32 bit unsigned integer in little-endian 4987func (d *D) FieldScalarU32LE(name string, sms ...scalar.Mapper) *scalar.S { 4988 s, err := d.TryFieldScalarU32LE(name, sms...) 4989 if err != nil { 4990 panic(IOError{Err: err, Name: name, Op: "U32LE", Pos: d.Pos()}) 4991 } 4992 return s 4993} 4994 4995// TryFieldU32LE tries to add a field and read 32 bit unsigned integer in little-endian 4996func (d *D) TryFieldU32LE(name string, sms ...scalar.Mapper) (uint64, error) { 4997 s, err := d.TryFieldScalarU32LE(name, sms...) 4998 return s.ActualU(), err 4999} 5000 5001// FieldU32LE adds a field and reads 32 bit unsigned integer in little-endian 5002func (d *D) FieldU32LE(name string, sms ...scalar.Mapper) uint64 { 5003 return d.FieldScalarU32LE(name, sms...).ActualU() 5004} 5005 5006// Reader U33LE 5007 5008// TryU33LE tries to read 33 bit unsigned integer in little-endian 5009func (d *D) TryU33LE() (uint64, error) { return d.tryUE(33, LittleEndian) } 5010 5011// U33LE reads 33 bit unsigned integer in little-endian 5012func (d *D) U33LE() uint64 { 5013 v, err := d.tryUE(33, LittleEndian) 5014 if err != nil { 5015 panic(IOError{Err: err, Op: "U33LE", Pos: d.Pos()}) 5016 } 5017 return v 5018} 5019 5020// TryFieldScalarU33LE tries to add a field and read 33 bit unsigned integer in little-endian 5021func (d *D) TryFieldScalarU33LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 5022 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 5023 v, err := d.tryUE(33, LittleEndian) 5024 s.Actual = v 5025 return s, err 5026 }, sms...) 5027 if err != nil { 5028 return nil, err 5029 } 5030 return s, err 5031} 5032 5033// FieldScalarU33LE adds a field and reads 33 bit unsigned integer in little-endian 5034func (d *D) FieldScalarU33LE(name string, sms ...scalar.Mapper) *scalar.S { 5035 s, err := d.TryFieldScalarU33LE(name, sms...) 5036 if err != nil { 5037 panic(IOError{Err: err, Name: name, Op: "U33LE", Pos: d.Pos()}) 5038 } 5039 return s 5040} 5041 5042// TryFieldU33LE tries to add a field and read 33 bit unsigned integer in little-endian 5043func (d *D) TryFieldU33LE(name string, sms ...scalar.Mapper) (uint64, error) { 5044 s, err := d.TryFieldScalarU33LE(name, sms...) 5045 return s.ActualU(), err 5046} 5047 5048// FieldU33LE adds a field and reads 33 bit unsigned integer in little-endian 5049func (d *D) FieldU33LE(name string, sms ...scalar.Mapper) uint64 { 5050 return d.FieldScalarU33LE(name, sms...).ActualU() 5051} 5052 5053// Reader U34LE 5054 5055// TryU34LE tries to read 34 bit unsigned integer in little-endian 5056func (d *D) TryU34LE() (uint64, error) { return d.tryUE(34, LittleEndian) } 5057 5058// U34LE reads 34 bit unsigned integer in little-endian 5059func (d *D) U34LE() uint64 { 5060 v, err := d.tryUE(34, LittleEndian) 5061 if err != nil { 5062 panic(IOError{Err: err, Op: "U34LE", Pos: d.Pos()}) 5063 } 5064 return v 5065} 5066 5067// TryFieldScalarU34LE tries to add a field and read 34 bit unsigned integer in little-endian 5068func (d *D) TryFieldScalarU34LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 5069 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 5070 v, err := d.tryUE(34, LittleEndian) 5071 s.Actual = v 5072 return s, err 5073 }, sms...) 5074 if err != nil { 5075 return nil, err 5076 } 5077 return s, err 5078} 5079 5080// FieldScalarU34LE adds a field and reads 34 bit unsigned integer in little-endian 5081func (d *D) FieldScalarU34LE(name string, sms ...scalar.Mapper) *scalar.S { 5082 s, err := d.TryFieldScalarU34LE(name, sms...) 5083 if err != nil { 5084 panic(IOError{Err: err, Name: name, Op: "U34LE", Pos: d.Pos()}) 5085 } 5086 return s 5087} 5088 5089// TryFieldU34LE tries to add a field and read 34 bit unsigned integer in little-endian 5090func (d *D) TryFieldU34LE(name string, sms ...scalar.Mapper) (uint64, error) { 5091 s, err := d.TryFieldScalarU34LE(name, sms...) 5092 return s.ActualU(), err 5093} 5094 5095// FieldU34LE adds a field and reads 34 bit unsigned integer in little-endian 5096func (d *D) FieldU34LE(name string, sms ...scalar.Mapper) uint64 { 5097 return d.FieldScalarU34LE(name, sms...).ActualU() 5098} 5099 5100// Reader U35LE 5101 5102// TryU35LE tries to read 35 bit unsigned integer in little-endian 5103func (d *D) TryU35LE() (uint64, error) { return d.tryUE(35, LittleEndian) } 5104 5105// U35LE reads 35 bit unsigned integer in little-endian 5106func (d *D) U35LE() uint64 { 5107 v, err := d.tryUE(35, LittleEndian) 5108 if err != nil { 5109 panic(IOError{Err: err, Op: "U35LE", Pos: d.Pos()}) 5110 } 5111 return v 5112} 5113 5114// TryFieldScalarU35LE tries to add a field and read 35 bit unsigned integer in little-endian 5115func (d *D) TryFieldScalarU35LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 5116 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 5117 v, err := d.tryUE(35, LittleEndian) 5118 s.Actual = v 5119 return s, err 5120 }, sms...) 5121 if err != nil { 5122 return nil, err 5123 } 5124 return s, err 5125} 5126 5127// FieldScalarU35LE adds a field and reads 35 bit unsigned integer in little-endian 5128func (d *D) FieldScalarU35LE(name string, sms ...scalar.Mapper) *scalar.S { 5129 s, err := d.TryFieldScalarU35LE(name, sms...) 5130 if err != nil { 5131 panic(IOError{Err: err, Name: name, Op: "U35LE", Pos: d.Pos()}) 5132 } 5133 return s 5134} 5135 5136// TryFieldU35LE tries to add a field and read 35 bit unsigned integer in little-endian 5137func (d *D) TryFieldU35LE(name string, sms ...scalar.Mapper) (uint64, error) { 5138 s, err := d.TryFieldScalarU35LE(name, sms...) 5139 return s.ActualU(), err 5140} 5141 5142// FieldU35LE adds a field and reads 35 bit unsigned integer in little-endian 5143func (d *D) FieldU35LE(name string, sms ...scalar.Mapper) uint64 { 5144 return d.FieldScalarU35LE(name, sms...).ActualU() 5145} 5146 5147// Reader U36LE 5148 5149// TryU36LE tries to read 36 bit unsigned integer in little-endian 5150func (d *D) TryU36LE() (uint64, error) { return d.tryUE(36, LittleEndian) } 5151 5152// U36LE reads 36 bit unsigned integer in little-endian 5153func (d *D) U36LE() uint64 { 5154 v, err := d.tryUE(36, LittleEndian) 5155 if err != nil { 5156 panic(IOError{Err: err, Op: "U36LE", Pos: d.Pos()}) 5157 } 5158 return v 5159} 5160 5161// TryFieldScalarU36LE tries to add a field and read 36 bit unsigned integer in little-endian 5162func (d *D) TryFieldScalarU36LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 5163 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 5164 v, err := d.tryUE(36, LittleEndian) 5165 s.Actual = v 5166 return s, err 5167 }, sms...) 5168 if err != nil { 5169 return nil, err 5170 } 5171 return s, err 5172} 5173 5174// FieldScalarU36LE adds a field and reads 36 bit unsigned integer in little-endian 5175func (d *D) FieldScalarU36LE(name string, sms ...scalar.Mapper) *scalar.S { 5176 s, err := d.TryFieldScalarU36LE(name, sms...) 5177 if err != nil { 5178 panic(IOError{Err: err, Name: name, Op: "U36LE", Pos: d.Pos()}) 5179 } 5180 return s 5181} 5182 5183// TryFieldU36LE tries to add a field and read 36 bit unsigned integer in little-endian 5184func (d *D) TryFieldU36LE(name string, sms ...scalar.Mapper) (uint64, error) { 5185 s, err := d.TryFieldScalarU36LE(name, sms...) 5186 return s.ActualU(), err 5187} 5188 5189// FieldU36LE adds a field and reads 36 bit unsigned integer in little-endian 5190func (d *D) FieldU36LE(name string, sms ...scalar.Mapper) uint64 { 5191 return d.FieldScalarU36LE(name, sms...).ActualU() 5192} 5193 5194// Reader U37LE 5195 5196// TryU37LE tries to read 37 bit unsigned integer in little-endian 5197func (d *D) TryU37LE() (uint64, error) { return d.tryUE(37, LittleEndian) } 5198 5199// U37LE reads 37 bit unsigned integer in little-endian 5200func (d *D) U37LE() uint64 { 5201 v, err := d.tryUE(37, LittleEndian) 5202 if err != nil { 5203 panic(IOError{Err: err, Op: "U37LE", Pos: d.Pos()}) 5204 } 5205 return v 5206} 5207 5208// TryFieldScalarU37LE tries to add a field and read 37 bit unsigned integer in little-endian 5209func (d *D) TryFieldScalarU37LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 5210 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 5211 v, err := d.tryUE(37, LittleEndian) 5212 s.Actual = v 5213 return s, err 5214 }, sms...) 5215 if err != nil { 5216 return nil, err 5217 } 5218 return s, err 5219} 5220 5221// FieldScalarU37LE adds a field and reads 37 bit unsigned integer in little-endian 5222func (d *D) FieldScalarU37LE(name string, sms ...scalar.Mapper) *scalar.S { 5223 s, err := d.TryFieldScalarU37LE(name, sms...) 5224 if err != nil { 5225 panic(IOError{Err: err, Name: name, Op: "U37LE", Pos: d.Pos()}) 5226 } 5227 return s 5228} 5229 5230// TryFieldU37LE tries to add a field and read 37 bit unsigned integer in little-endian 5231func (d *D) TryFieldU37LE(name string, sms ...scalar.Mapper) (uint64, error) { 5232 s, err := d.TryFieldScalarU37LE(name, sms...) 5233 return s.ActualU(), err 5234} 5235 5236// FieldU37LE adds a field and reads 37 bit unsigned integer in little-endian 5237func (d *D) FieldU37LE(name string, sms ...scalar.Mapper) uint64 { 5238 return d.FieldScalarU37LE(name, sms...).ActualU() 5239} 5240 5241// Reader U38LE 5242 5243// TryU38LE tries to read 38 bit unsigned integer in little-endian 5244func (d *D) TryU38LE() (uint64, error) { return d.tryUE(38, LittleEndian) } 5245 5246// U38LE reads 38 bit unsigned integer in little-endian 5247func (d *D) U38LE() uint64 { 5248 v, err := d.tryUE(38, LittleEndian) 5249 if err != nil { 5250 panic(IOError{Err: err, Op: "U38LE", Pos: d.Pos()}) 5251 } 5252 return v 5253} 5254 5255// TryFieldScalarU38LE tries to add a field and read 38 bit unsigned integer in little-endian 5256func (d *D) TryFieldScalarU38LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 5257 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 5258 v, err := d.tryUE(38, LittleEndian) 5259 s.Actual = v 5260 return s, err 5261 }, sms...) 5262 if err != nil { 5263 return nil, err 5264 } 5265 return s, err 5266} 5267 5268// FieldScalarU38LE adds a field and reads 38 bit unsigned integer in little-endian 5269func (d *D) FieldScalarU38LE(name string, sms ...scalar.Mapper) *scalar.S { 5270 s, err := d.TryFieldScalarU38LE(name, sms...) 5271 if err != nil { 5272 panic(IOError{Err: err, Name: name, Op: "U38LE", Pos: d.Pos()}) 5273 } 5274 return s 5275} 5276 5277// TryFieldU38LE tries to add a field and read 38 bit unsigned integer in little-endian 5278func (d *D) TryFieldU38LE(name string, sms ...scalar.Mapper) (uint64, error) { 5279 s, err := d.TryFieldScalarU38LE(name, sms...) 5280 return s.ActualU(), err 5281} 5282 5283// FieldU38LE adds a field and reads 38 bit unsigned integer in little-endian 5284func (d *D) FieldU38LE(name string, sms ...scalar.Mapper) uint64 { 5285 return d.FieldScalarU38LE(name, sms...).ActualU() 5286} 5287 5288// Reader U39LE 5289 5290// TryU39LE tries to read 39 bit unsigned integer in little-endian 5291func (d *D) TryU39LE() (uint64, error) { return d.tryUE(39, LittleEndian) } 5292 5293// U39LE reads 39 bit unsigned integer in little-endian 5294func (d *D) U39LE() uint64 { 5295 v, err := d.tryUE(39, LittleEndian) 5296 if err != nil { 5297 panic(IOError{Err: err, Op: "U39LE", Pos: d.Pos()}) 5298 } 5299 return v 5300} 5301 5302// TryFieldScalarU39LE tries to add a field and read 39 bit unsigned integer in little-endian 5303func (d *D) TryFieldScalarU39LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 5304 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 5305 v, err := d.tryUE(39, LittleEndian) 5306 s.Actual = v 5307 return s, err 5308 }, sms...) 5309 if err != nil { 5310 return nil, err 5311 } 5312 return s, err 5313} 5314 5315// FieldScalarU39LE adds a field and reads 39 bit unsigned integer in little-endian 5316func (d *D) FieldScalarU39LE(name string, sms ...scalar.Mapper) *scalar.S { 5317 s, err := d.TryFieldScalarU39LE(name, sms...) 5318 if err != nil { 5319 panic(IOError{Err: err, Name: name, Op: "U39LE", Pos: d.Pos()}) 5320 } 5321 return s 5322} 5323 5324// TryFieldU39LE tries to add a field and read 39 bit unsigned integer in little-endian 5325func (d *D) TryFieldU39LE(name string, sms ...scalar.Mapper) (uint64, error) { 5326 s, err := d.TryFieldScalarU39LE(name, sms...) 5327 return s.ActualU(), err 5328} 5329 5330// FieldU39LE adds a field and reads 39 bit unsigned integer in little-endian 5331func (d *D) FieldU39LE(name string, sms ...scalar.Mapper) uint64 { 5332 return d.FieldScalarU39LE(name, sms...).ActualU() 5333} 5334 5335// Reader U40LE 5336 5337// TryU40LE tries to read 40 bit unsigned integer in little-endian 5338func (d *D) TryU40LE() (uint64, error) { return d.tryUE(40, LittleEndian) } 5339 5340// U40LE reads 40 bit unsigned integer in little-endian 5341func (d *D) U40LE() uint64 { 5342 v, err := d.tryUE(40, LittleEndian) 5343 if err != nil { 5344 panic(IOError{Err: err, Op: "U40LE", Pos: d.Pos()}) 5345 } 5346 return v 5347} 5348 5349// TryFieldScalarU40LE tries to add a field and read 40 bit unsigned integer in little-endian 5350func (d *D) TryFieldScalarU40LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 5351 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 5352 v, err := d.tryUE(40, LittleEndian) 5353 s.Actual = v 5354 return s, err 5355 }, sms...) 5356 if err != nil { 5357 return nil, err 5358 } 5359 return s, err 5360} 5361 5362// FieldScalarU40LE adds a field and reads 40 bit unsigned integer in little-endian 5363func (d *D) FieldScalarU40LE(name string, sms ...scalar.Mapper) *scalar.S { 5364 s, err := d.TryFieldScalarU40LE(name, sms...) 5365 if err != nil { 5366 panic(IOError{Err: err, Name: name, Op: "U40LE", Pos: d.Pos()}) 5367 } 5368 return s 5369} 5370 5371// TryFieldU40LE tries to add a field and read 40 bit unsigned integer in little-endian 5372func (d *D) TryFieldU40LE(name string, sms ...scalar.Mapper) (uint64, error) { 5373 s, err := d.TryFieldScalarU40LE(name, sms...) 5374 return s.ActualU(), err 5375} 5376 5377// FieldU40LE adds a field and reads 40 bit unsigned integer in little-endian 5378func (d *D) FieldU40LE(name string, sms ...scalar.Mapper) uint64 { 5379 return d.FieldScalarU40LE(name, sms...).ActualU() 5380} 5381 5382// Reader U41LE 5383 5384// TryU41LE tries to read 41 bit unsigned integer in little-endian 5385func (d *D) TryU41LE() (uint64, error) { return d.tryUE(41, LittleEndian) } 5386 5387// U41LE reads 41 bit unsigned integer in little-endian 5388func (d *D) U41LE() uint64 { 5389 v, err := d.tryUE(41, LittleEndian) 5390 if err != nil { 5391 panic(IOError{Err: err, Op: "U41LE", Pos: d.Pos()}) 5392 } 5393 return v 5394} 5395 5396// TryFieldScalarU41LE tries to add a field and read 41 bit unsigned integer in little-endian 5397func (d *D) TryFieldScalarU41LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 5398 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 5399 v, err := d.tryUE(41, LittleEndian) 5400 s.Actual = v 5401 return s, err 5402 }, sms...) 5403 if err != nil { 5404 return nil, err 5405 } 5406 return s, err 5407} 5408 5409// FieldScalarU41LE adds a field and reads 41 bit unsigned integer in little-endian 5410func (d *D) FieldScalarU41LE(name string, sms ...scalar.Mapper) *scalar.S { 5411 s, err := d.TryFieldScalarU41LE(name, sms...) 5412 if err != nil { 5413 panic(IOError{Err: err, Name: name, Op: "U41LE", Pos: d.Pos()}) 5414 } 5415 return s 5416} 5417 5418// TryFieldU41LE tries to add a field and read 41 bit unsigned integer in little-endian 5419func (d *D) TryFieldU41LE(name string, sms ...scalar.Mapper) (uint64, error) { 5420 s, err := d.TryFieldScalarU41LE(name, sms...) 5421 return s.ActualU(), err 5422} 5423 5424// FieldU41LE adds a field and reads 41 bit unsigned integer in little-endian 5425func (d *D) FieldU41LE(name string, sms ...scalar.Mapper) uint64 { 5426 return d.FieldScalarU41LE(name, sms...).ActualU() 5427} 5428 5429// Reader U42LE 5430 5431// TryU42LE tries to read 42 bit unsigned integer in little-endian 5432func (d *D) TryU42LE() (uint64, error) { return d.tryUE(42, LittleEndian) } 5433 5434// U42LE reads 42 bit unsigned integer in little-endian 5435func (d *D) U42LE() uint64 { 5436 v, err := d.tryUE(42, LittleEndian) 5437 if err != nil { 5438 panic(IOError{Err: err, Op: "U42LE", Pos: d.Pos()}) 5439 } 5440 return v 5441} 5442 5443// TryFieldScalarU42LE tries to add a field and read 42 bit unsigned integer in little-endian 5444func (d *D) TryFieldScalarU42LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 5445 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 5446 v, err := d.tryUE(42, LittleEndian) 5447 s.Actual = v 5448 return s, err 5449 }, sms...) 5450 if err != nil { 5451 return nil, err 5452 } 5453 return s, err 5454} 5455 5456// FieldScalarU42LE adds a field and reads 42 bit unsigned integer in little-endian 5457func (d *D) FieldScalarU42LE(name string, sms ...scalar.Mapper) *scalar.S { 5458 s, err := d.TryFieldScalarU42LE(name, sms...) 5459 if err != nil { 5460 panic(IOError{Err: err, Name: name, Op: "U42LE", Pos: d.Pos()}) 5461 } 5462 return s 5463} 5464 5465// TryFieldU42LE tries to add a field and read 42 bit unsigned integer in little-endian 5466func (d *D) TryFieldU42LE(name string, sms ...scalar.Mapper) (uint64, error) { 5467 s, err := d.TryFieldScalarU42LE(name, sms...) 5468 return s.ActualU(), err 5469} 5470 5471// FieldU42LE adds a field and reads 42 bit unsigned integer in little-endian 5472func (d *D) FieldU42LE(name string, sms ...scalar.Mapper) uint64 { 5473 return d.FieldScalarU42LE(name, sms...).ActualU() 5474} 5475 5476// Reader U43LE 5477 5478// TryU43LE tries to read 43 bit unsigned integer in little-endian 5479func (d *D) TryU43LE() (uint64, error) { return d.tryUE(43, LittleEndian) } 5480 5481// U43LE reads 43 bit unsigned integer in little-endian 5482func (d *D) U43LE() uint64 { 5483 v, err := d.tryUE(43, LittleEndian) 5484 if err != nil { 5485 panic(IOError{Err: err, Op: "U43LE", Pos: d.Pos()}) 5486 } 5487 return v 5488} 5489 5490// TryFieldScalarU43LE tries to add a field and read 43 bit unsigned integer in little-endian 5491func (d *D) TryFieldScalarU43LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 5492 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 5493 v, err := d.tryUE(43, LittleEndian) 5494 s.Actual = v 5495 return s, err 5496 }, sms...) 5497 if err != nil { 5498 return nil, err 5499 } 5500 return s, err 5501} 5502 5503// FieldScalarU43LE adds a field and reads 43 bit unsigned integer in little-endian 5504func (d *D) FieldScalarU43LE(name string, sms ...scalar.Mapper) *scalar.S { 5505 s, err := d.TryFieldScalarU43LE(name, sms...) 5506 if err != nil { 5507 panic(IOError{Err: err, Name: name, Op: "U43LE", Pos: d.Pos()}) 5508 } 5509 return s 5510} 5511 5512// TryFieldU43LE tries to add a field and read 43 bit unsigned integer in little-endian 5513func (d *D) TryFieldU43LE(name string, sms ...scalar.Mapper) (uint64, error) { 5514 s, err := d.TryFieldScalarU43LE(name, sms...) 5515 return s.ActualU(), err 5516} 5517 5518// FieldU43LE adds a field and reads 43 bit unsigned integer in little-endian 5519func (d *D) FieldU43LE(name string, sms ...scalar.Mapper) uint64 { 5520 return d.FieldScalarU43LE(name, sms...).ActualU() 5521} 5522 5523// Reader U44LE 5524 5525// TryU44LE tries to read 44 bit unsigned integer in little-endian 5526func (d *D) TryU44LE() (uint64, error) { return d.tryUE(44, LittleEndian) } 5527 5528// U44LE reads 44 bit unsigned integer in little-endian 5529func (d *D) U44LE() uint64 { 5530 v, err := d.tryUE(44, LittleEndian) 5531 if err != nil { 5532 panic(IOError{Err: err, Op: "U44LE", Pos: d.Pos()}) 5533 } 5534 return v 5535} 5536 5537// TryFieldScalarU44LE tries to add a field and read 44 bit unsigned integer in little-endian 5538func (d *D) TryFieldScalarU44LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 5539 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 5540 v, err := d.tryUE(44, LittleEndian) 5541 s.Actual = v 5542 return s, err 5543 }, sms...) 5544 if err != nil { 5545 return nil, err 5546 } 5547 return s, err 5548} 5549 5550// FieldScalarU44LE adds a field and reads 44 bit unsigned integer in little-endian 5551func (d *D) FieldScalarU44LE(name string, sms ...scalar.Mapper) *scalar.S { 5552 s, err := d.TryFieldScalarU44LE(name, sms...) 5553 if err != nil { 5554 panic(IOError{Err: err, Name: name, Op: "U44LE", Pos: d.Pos()}) 5555 } 5556 return s 5557} 5558 5559// TryFieldU44LE tries to add a field and read 44 bit unsigned integer in little-endian 5560func (d *D) TryFieldU44LE(name string, sms ...scalar.Mapper) (uint64, error) { 5561 s, err := d.TryFieldScalarU44LE(name, sms...) 5562 return s.ActualU(), err 5563} 5564 5565// FieldU44LE adds a field and reads 44 bit unsigned integer in little-endian 5566func (d *D) FieldU44LE(name string, sms ...scalar.Mapper) uint64 { 5567 return d.FieldScalarU44LE(name, sms...).ActualU() 5568} 5569 5570// Reader U45LE 5571 5572// TryU45LE tries to read 45 bit unsigned integer in little-endian 5573func (d *D) TryU45LE() (uint64, error) { return d.tryUE(45, LittleEndian) } 5574 5575// U45LE reads 45 bit unsigned integer in little-endian 5576func (d *D) U45LE() uint64 { 5577 v, err := d.tryUE(45, LittleEndian) 5578 if err != nil { 5579 panic(IOError{Err: err, Op: "U45LE", Pos: d.Pos()}) 5580 } 5581 return v 5582} 5583 5584// TryFieldScalarU45LE tries to add a field and read 45 bit unsigned integer in little-endian 5585func (d *D) TryFieldScalarU45LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 5586 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 5587 v, err := d.tryUE(45, LittleEndian) 5588 s.Actual = v 5589 return s, err 5590 }, sms...) 5591 if err != nil { 5592 return nil, err 5593 } 5594 return s, err 5595} 5596 5597// FieldScalarU45LE adds a field and reads 45 bit unsigned integer in little-endian 5598func (d *D) FieldScalarU45LE(name string, sms ...scalar.Mapper) *scalar.S { 5599 s, err := d.TryFieldScalarU45LE(name, sms...) 5600 if err != nil { 5601 panic(IOError{Err: err, Name: name, Op: "U45LE", Pos: d.Pos()}) 5602 } 5603 return s 5604} 5605 5606// TryFieldU45LE tries to add a field and read 45 bit unsigned integer in little-endian 5607func (d *D) TryFieldU45LE(name string, sms ...scalar.Mapper) (uint64, error) { 5608 s, err := d.TryFieldScalarU45LE(name, sms...) 5609 return s.ActualU(), err 5610} 5611 5612// FieldU45LE adds a field and reads 45 bit unsigned integer in little-endian 5613func (d *D) FieldU45LE(name string, sms ...scalar.Mapper) uint64 { 5614 return d.FieldScalarU45LE(name, sms...).ActualU() 5615} 5616 5617// Reader U46LE 5618 5619// TryU46LE tries to read 46 bit unsigned integer in little-endian 5620func (d *D) TryU46LE() (uint64, error) { return d.tryUE(46, LittleEndian) } 5621 5622// U46LE reads 46 bit unsigned integer in little-endian 5623func (d *D) U46LE() uint64 { 5624 v, err := d.tryUE(46, LittleEndian) 5625 if err != nil { 5626 panic(IOError{Err: err, Op: "U46LE", Pos: d.Pos()}) 5627 } 5628 return v 5629} 5630 5631// TryFieldScalarU46LE tries to add a field and read 46 bit unsigned integer in little-endian 5632func (d *D) TryFieldScalarU46LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 5633 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 5634 v, err := d.tryUE(46, LittleEndian) 5635 s.Actual = v 5636 return s, err 5637 }, sms...) 5638 if err != nil { 5639 return nil, err 5640 } 5641 return s, err 5642} 5643 5644// FieldScalarU46LE adds a field and reads 46 bit unsigned integer in little-endian 5645func (d *D) FieldScalarU46LE(name string, sms ...scalar.Mapper) *scalar.S { 5646 s, err := d.TryFieldScalarU46LE(name, sms...) 5647 if err != nil { 5648 panic(IOError{Err: err, Name: name, Op: "U46LE", Pos: d.Pos()}) 5649 } 5650 return s 5651} 5652 5653// TryFieldU46LE tries to add a field and read 46 bit unsigned integer in little-endian 5654func (d *D) TryFieldU46LE(name string, sms ...scalar.Mapper) (uint64, error) { 5655 s, err := d.TryFieldScalarU46LE(name, sms...) 5656 return s.ActualU(), err 5657} 5658 5659// FieldU46LE adds a field and reads 46 bit unsigned integer in little-endian 5660func (d *D) FieldU46LE(name string, sms ...scalar.Mapper) uint64 { 5661 return d.FieldScalarU46LE(name, sms...).ActualU() 5662} 5663 5664// Reader U47LE 5665 5666// TryU47LE tries to read 47 bit unsigned integer in little-endian 5667func (d *D) TryU47LE() (uint64, error) { return d.tryUE(47, LittleEndian) } 5668 5669// U47LE reads 47 bit unsigned integer in little-endian 5670func (d *D) U47LE() uint64 { 5671 v, err := d.tryUE(47, LittleEndian) 5672 if err != nil { 5673 panic(IOError{Err: err, Op: "U47LE", Pos: d.Pos()}) 5674 } 5675 return v 5676} 5677 5678// TryFieldScalarU47LE tries to add a field and read 47 bit unsigned integer in little-endian 5679func (d *D) TryFieldScalarU47LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 5680 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 5681 v, err := d.tryUE(47, LittleEndian) 5682 s.Actual = v 5683 return s, err 5684 }, sms...) 5685 if err != nil { 5686 return nil, err 5687 } 5688 return s, err 5689} 5690 5691// FieldScalarU47LE adds a field and reads 47 bit unsigned integer in little-endian 5692func (d *D) FieldScalarU47LE(name string, sms ...scalar.Mapper) *scalar.S { 5693 s, err := d.TryFieldScalarU47LE(name, sms...) 5694 if err != nil { 5695 panic(IOError{Err: err, Name: name, Op: "U47LE", Pos: d.Pos()}) 5696 } 5697 return s 5698} 5699 5700// TryFieldU47LE tries to add a field and read 47 bit unsigned integer in little-endian 5701func (d *D) TryFieldU47LE(name string, sms ...scalar.Mapper) (uint64, error) { 5702 s, err := d.TryFieldScalarU47LE(name, sms...) 5703 return s.ActualU(), err 5704} 5705 5706// FieldU47LE adds a field and reads 47 bit unsigned integer in little-endian 5707func (d *D) FieldU47LE(name string, sms ...scalar.Mapper) uint64 { 5708 return d.FieldScalarU47LE(name, sms...).ActualU() 5709} 5710 5711// Reader U48LE 5712 5713// TryU48LE tries to read 48 bit unsigned integer in little-endian 5714func (d *D) TryU48LE() (uint64, error) { return d.tryUE(48, LittleEndian) } 5715 5716// U48LE reads 48 bit unsigned integer in little-endian 5717func (d *D) U48LE() uint64 { 5718 v, err := d.tryUE(48, LittleEndian) 5719 if err != nil { 5720 panic(IOError{Err: err, Op: "U48LE", Pos: d.Pos()}) 5721 } 5722 return v 5723} 5724 5725// TryFieldScalarU48LE tries to add a field and read 48 bit unsigned integer in little-endian 5726func (d *D) TryFieldScalarU48LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 5727 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 5728 v, err := d.tryUE(48, LittleEndian) 5729 s.Actual = v 5730 return s, err 5731 }, sms...) 5732 if err != nil { 5733 return nil, err 5734 } 5735 return s, err 5736} 5737 5738// FieldScalarU48LE adds a field and reads 48 bit unsigned integer in little-endian 5739func (d *D) FieldScalarU48LE(name string, sms ...scalar.Mapper) *scalar.S { 5740 s, err := d.TryFieldScalarU48LE(name, sms...) 5741 if err != nil { 5742 panic(IOError{Err: err, Name: name, Op: "U48LE", Pos: d.Pos()}) 5743 } 5744 return s 5745} 5746 5747// TryFieldU48LE tries to add a field and read 48 bit unsigned integer in little-endian 5748func (d *D) TryFieldU48LE(name string, sms ...scalar.Mapper) (uint64, error) { 5749 s, err := d.TryFieldScalarU48LE(name, sms...) 5750 return s.ActualU(), err 5751} 5752 5753// FieldU48LE adds a field and reads 48 bit unsigned integer in little-endian 5754func (d *D) FieldU48LE(name string, sms ...scalar.Mapper) uint64 { 5755 return d.FieldScalarU48LE(name, sms...).ActualU() 5756} 5757 5758// Reader U49LE 5759 5760// TryU49LE tries to read 49 bit unsigned integer in little-endian 5761func (d *D) TryU49LE() (uint64, error) { return d.tryUE(49, LittleEndian) } 5762 5763// U49LE reads 49 bit unsigned integer in little-endian 5764func (d *D) U49LE() uint64 { 5765 v, err := d.tryUE(49, LittleEndian) 5766 if err != nil { 5767 panic(IOError{Err: err, Op: "U49LE", Pos: d.Pos()}) 5768 } 5769 return v 5770} 5771 5772// TryFieldScalarU49LE tries to add a field and read 49 bit unsigned integer in little-endian 5773func (d *D) TryFieldScalarU49LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 5774 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 5775 v, err := d.tryUE(49, LittleEndian) 5776 s.Actual = v 5777 return s, err 5778 }, sms...) 5779 if err != nil { 5780 return nil, err 5781 } 5782 return s, err 5783} 5784 5785// FieldScalarU49LE adds a field and reads 49 bit unsigned integer in little-endian 5786func (d *D) FieldScalarU49LE(name string, sms ...scalar.Mapper) *scalar.S { 5787 s, err := d.TryFieldScalarU49LE(name, sms...) 5788 if err != nil { 5789 panic(IOError{Err: err, Name: name, Op: "U49LE", Pos: d.Pos()}) 5790 } 5791 return s 5792} 5793 5794// TryFieldU49LE tries to add a field and read 49 bit unsigned integer in little-endian 5795func (d *D) TryFieldU49LE(name string, sms ...scalar.Mapper) (uint64, error) { 5796 s, err := d.TryFieldScalarU49LE(name, sms...) 5797 return s.ActualU(), err 5798} 5799 5800// FieldU49LE adds a field and reads 49 bit unsigned integer in little-endian 5801func (d *D) FieldU49LE(name string, sms ...scalar.Mapper) uint64 { 5802 return d.FieldScalarU49LE(name, sms...).ActualU() 5803} 5804 5805// Reader U50LE 5806 5807// TryU50LE tries to read 50 bit unsigned integer in little-endian 5808func (d *D) TryU50LE() (uint64, error) { return d.tryUE(50, LittleEndian) } 5809 5810// U50LE reads 50 bit unsigned integer in little-endian 5811func (d *D) U50LE() uint64 { 5812 v, err := d.tryUE(50, LittleEndian) 5813 if err != nil { 5814 panic(IOError{Err: err, Op: "U50LE", Pos: d.Pos()}) 5815 } 5816 return v 5817} 5818 5819// TryFieldScalarU50LE tries to add a field and read 50 bit unsigned integer in little-endian 5820func (d *D) TryFieldScalarU50LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 5821 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 5822 v, err := d.tryUE(50, LittleEndian) 5823 s.Actual = v 5824 return s, err 5825 }, sms...) 5826 if err != nil { 5827 return nil, err 5828 } 5829 return s, err 5830} 5831 5832// FieldScalarU50LE adds a field and reads 50 bit unsigned integer in little-endian 5833func (d *D) FieldScalarU50LE(name string, sms ...scalar.Mapper) *scalar.S { 5834 s, err := d.TryFieldScalarU50LE(name, sms...) 5835 if err != nil { 5836 panic(IOError{Err: err, Name: name, Op: "U50LE", Pos: d.Pos()}) 5837 } 5838 return s 5839} 5840 5841// TryFieldU50LE tries to add a field and read 50 bit unsigned integer in little-endian 5842func (d *D) TryFieldU50LE(name string, sms ...scalar.Mapper) (uint64, error) { 5843 s, err := d.TryFieldScalarU50LE(name, sms...) 5844 return s.ActualU(), err 5845} 5846 5847// FieldU50LE adds a field and reads 50 bit unsigned integer in little-endian 5848func (d *D) FieldU50LE(name string, sms ...scalar.Mapper) uint64 { 5849 return d.FieldScalarU50LE(name, sms...).ActualU() 5850} 5851 5852// Reader U51LE 5853 5854// TryU51LE tries to read 51 bit unsigned integer in little-endian 5855func (d *D) TryU51LE() (uint64, error) { return d.tryUE(51, LittleEndian) } 5856 5857// U51LE reads 51 bit unsigned integer in little-endian 5858func (d *D) U51LE() uint64 { 5859 v, err := d.tryUE(51, LittleEndian) 5860 if err != nil { 5861 panic(IOError{Err: err, Op: "U51LE", Pos: d.Pos()}) 5862 } 5863 return v 5864} 5865 5866// TryFieldScalarU51LE tries to add a field and read 51 bit unsigned integer in little-endian 5867func (d *D) TryFieldScalarU51LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 5868 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 5869 v, err := d.tryUE(51, LittleEndian) 5870 s.Actual = v 5871 return s, err 5872 }, sms...) 5873 if err != nil { 5874 return nil, err 5875 } 5876 return s, err 5877} 5878 5879// FieldScalarU51LE adds a field and reads 51 bit unsigned integer in little-endian 5880func (d *D) FieldScalarU51LE(name string, sms ...scalar.Mapper) *scalar.S { 5881 s, err := d.TryFieldScalarU51LE(name, sms...) 5882 if err != nil { 5883 panic(IOError{Err: err, Name: name, Op: "U51LE", Pos: d.Pos()}) 5884 } 5885 return s 5886} 5887 5888// TryFieldU51LE tries to add a field and read 51 bit unsigned integer in little-endian 5889func (d *D) TryFieldU51LE(name string, sms ...scalar.Mapper) (uint64, error) { 5890 s, err := d.TryFieldScalarU51LE(name, sms...) 5891 return s.ActualU(), err 5892} 5893 5894// FieldU51LE adds a field and reads 51 bit unsigned integer in little-endian 5895func (d *D) FieldU51LE(name string, sms ...scalar.Mapper) uint64 { 5896 return d.FieldScalarU51LE(name, sms...).ActualU() 5897} 5898 5899// Reader U52LE 5900 5901// TryU52LE tries to read 52 bit unsigned integer in little-endian 5902func (d *D) TryU52LE() (uint64, error) { return d.tryUE(52, LittleEndian) } 5903 5904// U52LE reads 52 bit unsigned integer in little-endian 5905func (d *D) U52LE() uint64 { 5906 v, err := d.tryUE(52, LittleEndian) 5907 if err != nil { 5908 panic(IOError{Err: err, Op: "U52LE", Pos: d.Pos()}) 5909 } 5910 return v 5911} 5912 5913// TryFieldScalarU52LE tries to add a field and read 52 bit unsigned integer in little-endian 5914func (d *D) TryFieldScalarU52LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 5915 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 5916 v, err := d.tryUE(52, LittleEndian) 5917 s.Actual = v 5918 return s, err 5919 }, sms...) 5920 if err != nil { 5921 return nil, err 5922 } 5923 return s, err 5924} 5925 5926// FieldScalarU52LE adds a field and reads 52 bit unsigned integer in little-endian 5927func (d *D) FieldScalarU52LE(name string, sms ...scalar.Mapper) *scalar.S { 5928 s, err := d.TryFieldScalarU52LE(name, sms...) 5929 if err != nil { 5930 panic(IOError{Err: err, Name: name, Op: "U52LE", Pos: d.Pos()}) 5931 } 5932 return s 5933} 5934 5935// TryFieldU52LE tries to add a field and read 52 bit unsigned integer in little-endian 5936func (d *D) TryFieldU52LE(name string, sms ...scalar.Mapper) (uint64, error) { 5937 s, err := d.TryFieldScalarU52LE(name, sms...) 5938 return s.ActualU(), err 5939} 5940 5941// FieldU52LE adds a field and reads 52 bit unsigned integer in little-endian 5942func (d *D) FieldU52LE(name string, sms ...scalar.Mapper) uint64 { 5943 return d.FieldScalarU52LE(name, sms...).ActualU() 5944} 5945 5946// Reader U53LE 5947 5948// TryU53LE tries to read 53 bit unsigned integer in little-endian 5949func (d *D) TryU53LE() (uint64, error) { return d.tryUE(53, LittleEndian) } 5950 5951// U53LE reads 53 bit unsigned integer in little-endian 5952func (d *D) U53LE() uint64 { 5953 v, err := d.tryUE(53, LittleEndian) 5954 if err != nil { 5955 panic(IOError{Err: err, Op: "U53LE", Pos: d.Pos()}) 5956 } 5957 return v 5958} 5959 5960// TryFieldScalarU53LE tries to add a field and read 53 bit unsigned integer in little-endian 5961func (d *D) TryFieldScalarU53LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 5962 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 5963 v, err := d.tryUE(53, LittleEndian) 5964 s.Actual = v 5965 return s, err 5966 }, sms...) 5967 if err != nil { 5968 return nil, err 5969 } 5970 return s, err 5971} 5972 5973// FieldScalarU53LE adds a field and reads 53 bit unsigned integer in little-endian 5974func (d *D) FieldScalarU53LE(name string, sms ...scalar.Mapper) *scalar.S { 5975 s, err := d.TryFieldScalarU53LE(name, sms...) 5976 if err != nil { 5977 panic(IOError{Err: err, Name: name, Op: "U53LE", Pos: d.Pos()}) 5978 } 5979 return s 5980} 5981 5982// TryFieldU53LE tries to add a field and read 53 bit unsigned integer in little-endian 5983func (d *D) TryFieldU53LE(name string, sms ...scalar.Mapper) (uint64, error) { 5984 s, err := d.TryFieldScalarU53LE(name, sms...) 5985 return s.ActualU(), err 5986} 5987 5988// FieldU53LE adds a field and reads 53 bit unsigned integer in little-endian 5989func (d *D) FieldU53LE(name string, sms ...scalar.Mapper) uint64 { 5990 return d.FieldScalarU53LE(name, sms...).ActualU() 5991} 5992 5993// Reader U54LE 5994 5995// TryU54LE tries to read 54 bit unsigned integer in little-endian 5996func (d *D) TryU54LE() (uint64, error) { return d.tryUE(54, LittleEndian) } 5997 5998// U54LE reads 54 bit unsigned integer in little-endian 5999func (d *D) U54LE() uint64 { 6000 v, err := d.tryUE(54, LittleEndian) 6001 if err != nil { 6002 panic(IOError{Err: err, Op: "U54LE", Pos: d.Pos()}) 6003 } 6004 return v 6005} 6006 6007// TryFieldScalarU54LE tries to add a field and read 54 bit unsigned integer in little-endian 6008func (d *D) TryFieldScalarU54LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 6009 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 6010 v, err := d.tryUE(54, LittleEndian) 6011 s.Actual = v 6012 return s, err 6013 }, sms...) 6014 if err != nil { 6015 return nil, err 6016 } 6017 return s, err 6018} 6019 6020// FieldScalarU54LE adds a field and reads 54 bit unsigned integer in little-endian 6021func (d *D) FieldScalarU54LE(name string, sms ...scalar.Mapper) *scalar.S { 6022 s, err := d.TryFieldScalarU54LE(name, sms...) 6023 if err != nil { 6024 panic(IOError{Err: err, Name: name, Op: "U54LE", Pos: d.Pos()}) 6025 } 6026 return s 6027} 6028 6029// TryFieldU54LE tries to add a field and read 54 bit unsigned integer in little-endian 6030func (d *D) TryFieldU54LE(name string, sms ...scalar.Mapper) (uint64, error) { 6031 s, err := d.TryFieldScalarU54LE(name, sms...) 6032 return s.ActualU(), err 6033} 6034 6035// FieldU54LE adds a field and reads 54 bit unsigned integer in little-endian 6036func (d *D) FieldU54LE(name string, sms ...scalar.Mapper) uint64 { 6037 return d.FieldScalarU54LE(name, sms...).ActualU() 6038} 6039 6040// Reader U55LE 6041 6042// TryU55LE tries to read 55 bit unsigned integer in little-endian 6043func (d *D) TryU55LE() (uint64, error) { return d.tryUE(55, LittleEndian) } 6044 6045// U55LE reads 55 bit unsigned integer in little-endian 6046func (d *D) U55LE() uint64 { 6047 v, err := d.tryUE(55, LittleEndian) 6048 if err != nil { 6049 panic(IOError{Err: err, Op: "U55LE", Pos: d.Pos()}) 6050 } 6051 return v 6052} 6053 6054// TryFieldScalarU55LE tries to add a field and read 55 bit unsigned integer in little-endian 6055func (d *D) TryFieldScalarU55LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 6056 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 6057 v, err := d.tryUE(55, LittleEndian) 6058 s.Actual = v 6059 return s, err 6060 }, sms...) 6061 if err != nil { 6062 return nil, err 6063 } 6064 return s, err 6065} 6066 6067// FieldScalarU55LE adds a field and reads 55 bit unsigned integer in little-endian 6068func (d *D) FieldScalarU55LE(name string, sms ...scalar.Mapper) *scalar.S { 6069 s, err := d.TryFieldScalarU55LE(name, sms...) 6070 if err != nil { 6071 panic(IOError{Err: err, Name: name, Op: "U55LE", Pos: d.Pos()}) 6072 } 6073 return s 6074} 6075 6076// TryFieldU55LE tries to add a field and read 55 bit unsigned integer in little-endian 6077func (d *D) TryFieldU55LE(name string, sms ...scalar.Mapper) (uint64, error) { 6078 s, err := d.TryFieldScalarU55LE(name, sms...) 6079 return s.ActualU(), err 6080} 6081 6082// FieldU55LE adds a field and reads 55 bit unsigned integer in little-endian 6083func (d *D) FieldU55LE(name string, sms ...scalar.Mapper) uint64 { 6084 return d.FieldScalarU55LE(name, sms...).ActualU() 6085} 6086 6087// Reader U56LE 6088 6089// TryU56LE tries to read 56 bit unsigned integer in little-endian 6090func (d *D) TryU56LE() (uint64, error) { return d.tryUE(56, LittleEndian) } 6091 6092// U56LE reads 56 bit unsigned integer in little-endian 6093func (d *D) U56LE() uint64 { 6094 v, err := d.tryUE(56, LittleEndian) 6095 if err != nil { 6096 panic(IOError{Err: err, Op: "U56LE", Pos: d.Pos()}) 6097 } 6098 return v 6099} 6100 6101// TryFieldScalarU56LE tries to add a field and read 56 bit unsigned integer in little-endian 6102func (d *D) TryFieldScalarU56LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 6103 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 6104 v, err := d.tryUE(56, LittleEndian) 6105 s.Actual = v 6106 return s, err 6107 }, sms...) 6108 if err != nil { 6109 return nil, err 6110 } 6111 return s, err 6112} 6113 6114// FieldScalarU56LE adds a field and reads 56 bit unsigned integer in little-endian 6115func (d *D) FieldScalarU56LE(name string, sms ...scalar.Mapper) *scalar.S { 6116 s, err := d.TryFieldScalarU56LE(name, sms...) 6117 if err != nil { 6118 panic(IOError{Err: err, Name: name, Op: "U56LE", Pos: d.Pos()}) 6119 } 6120 return s 6121} 6122 6123// TryFieldU56LE tries to add a field and read 56 bit unsigned integer in little-endian 6124func (d *D) TryFieldU56LE(name string, sms ...scalar.Mapper) (uint64, error) { 6125 s, err := d.TryFieldScalarU56LE(name, sms...) 6126 return s.ActualU(), err 6127} 6128 6129// FieldU56LE adds a field and reads 56 bit unsigned integer in little-endian 6130func (d *D) FieldU56LE(name string, sms ...scalar.Mapper) uint64 { 6131 return d.FieldScalarU56LE(name, sms...).ActualU() 6132} 6133 6134// Reader U57LE 6135 6136// TryU57LE tries to read 57 bit unsigned integer in little-endian 6137func (d *D) TryU57LE() (uint64, error) { return d.tryUE(57, LittleEndian) } 6138 6139// U57LE reads 57 bit unsigned integer in little-endian 6140func (d *D) U57LE() uint64 { 6141 v, err := d.tryUE(57, LittleEndian) 6142 if err != nil { 6143 panic(IOError{Err: err, Op: "U57LE", Pos: d.Pos()}) 6144 } 6145 return v 6146} 6147 6148// TryFieldScalarU57LE tries to add a field and read 57 bit unsigned integer in little-endian 6149func (d *D) TryFieldScalarU57LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 6150 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 6151 v, err := d.tryUE(57, LittleEndian) 6152 s.Actual = v 6153 return s, err 6154 }, sms...) 6155 if err != nil { 6156 return nil, err 6157 } 6158 return s, err 6159} 6160 6161// FieldScalarU57LE adds a field and reads 57 bit unsigned integer in little-endian 6162func (d *D) FieldScalarU57LE(name string, sms ...scalar.Mapper) *scalar.S { 6163 s, err := d.TryFieldScalarU57LE(name, sms...) 6164 if err != nil { 6165 panic(IOError{Err: err, Name: name, Op: "U57LE", Pos: d.Pos()}) 6166 } 6167 return s 6168} 6169 6170// TryFieldU57LE tries to add a field and read 57 bit unsigned integer in little-endian 6171func (d *D) TryFieldU57LE(name string, sms ...scalar.Mapper) (uint64, error) { 6172 s, err := d.TryFieldScalarU57LE(name, sms...) 6173 return s.ActualU(), err 6174} 6175 6176// FieldU57LE adds a field and reads 57 bit unsigned integer in little-endian 6177func (d *D) FieldU57LE(name string, sms ...scalar.Mapper) uint64 { 6178 return d.FieldScalarU57LE(name, sms...).ActualU() 6179} 6180 6181// Reader U58LE 6182 6183// TryU58LE tries to read 58 bit unsigned integer in little-endian 6184func (d *D) TryU58LE() (uint64, error) { return d.tryUE(58, LittleEndian) } 6185 6186// U58LE reads 58 bit unsigned integer in little-endian 6187func (d *D) U58LE() uint64 { 6188 v, err := d.tryUE(58, LittleEndian) 6189 if err != nil { 6190 panic(IOError{Err: err, Op: "U58LE", Pos: d.Pos()}) 6191 } 6192 return v 6193} 6194 6195// TryFieldScalarU58LE tries to add a field and read 58 bit unsigned integer in little-endian 6196func (d *D) TryFieldScalarU58LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 6197 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 6198 v, err := d.tryUE(58, LittleEndian) 6199 s.Actual = v 6200 return s, err 6201 }, sms...) 6202 if err != nil { 6203 return nil, err 6204 } 6205 return s, err 6206} 6207 6208// FieldScalarU58LE adds a field and reads 58 bit unsigned integer in little-endian 6209func (d *D) FieldScalarU58LE(name string, sms ...scalar.Mapper) *scalar.S { 6210 s, err := d.TryFieldScalarU58LE(name, sms...) 6211 if err != nil { 6212 panic(IOError{Err: err, Name: name, Op: "U58LE", Pos: d.Pos()}) 6213 } 6214 return s 6215} 6216 6217// TryFieldU58LE tries to add a field and read 58 bit unsigned integer in little-endian 6218func (d *D) TryFieldU58LE(name string, sms ...scalar.Mapper) (uint64, error) { 6219 s, err := d.TryFieldScalarU58LE(name, sms...) 6220 return s.ActualU(), err 6221} 6222 6223// FieldU58LE adds a field and reads 58 bit unsigned integer in little-endian 6224func (d *D) FieldU58LE(name string, sms ...scalar.Mapper) uint64 { 6225 return d.FieldScalarU58LE(name, sms...).ActualU() 6226} 6227 6228// Reader U59LE 6229 6230// TryU59LE tries to read 59 bit unsigned integer in little-endian 6231func (d *D) TryU59LE() (uint64, error) { return d.tryUE(59, LittleEndian) } 6232 6233// U59LE reads 59 bit unsigned integer in little-endian 6234func (d *D) U59LE() uint64 { 6235 v, err := d.tryUE(59, LittleEndian) 6236 if err != nil { 6237 panic(IOError{Err: err, Op: "U59LE", Pos: d.Pos()}) 6238 } 6239 return v 6240} 6241 6242// TryFieldScalarU59LE tries to add a field and read 59 bit unsigned integer in little-endian 6243func (d *D) TryFieldScalarU59LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 6244 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 6245 v, err := d.tryUE(59, LittleEndian) 6246 s.Actual = v 6247 return s, err 6248 }, sms...) 6249 if err != nil { 6250 return nil, err 6251 } 6252 return s, err 6253} 6254 6255// FieldScalarU59LE adds a field and reads 59 bit unsigned integer in little-endian 6256func (d *D) FieldScalarU59LE(name string, sms ...scalar.Mapper) *scalar.S { 6257 s, err := d.TryFieldScalarU59LE(name, sms...) 6258 if err != nil { 6259 panic(IOError{Err: err, Name: name, Op: "U59LE", Pos: d.Pos()}) 6260 } 6261 return s 6262} 6263 6264// TryFieldU59LE tries to add a field and read 59 bit unsigned integer in little-endian 6265func (d *D) TryFieldU59LE(name string, sms ...scalar.Mapper) (uint64, error) { 6266 s, err := d.TryFieldScalarU59LE(name, sms...) 6267 return s.ActualU(), err 6268} 6269 6270// FieldU59LE adds a field and reads 59 bit unsigned integer in little-endian 6271func (d *D) FieldU59LE(name string, sms ...scalar.Mapper) uint64 { 6272 return d.FieldScalarU59LE(name, sms...).ActualU() 6273} 6274 6275// Reader U60LE 6276 6277// TryU60LE tries to read 60 bit unsigned integer in little-endian 6278func (d *D) TryU60LE() (uint64, error) { return d.tryUE(60, LittleEndian) } 6279 6280// U60LE reads 60 bit unsigned integer in little-endian 6281func (d *D) U60LE() uint64 { 6282 v, err := d.tryUE(60, LittleEndian) 6283 if err != nil { 6284 panic(IOError{Err: err, Op: "U60LE", Pos: d.Pos()}) 6285 } 6286 return v 6287} 6288 6289// TryFieldScalarU60LE tries to add a field and read 60 bit unsigned integer in little-endian 6290func (d *D) TryFieldScalarU60LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 6291 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 6292 v, err := d.tryUE(60, LittleEndian) 6293 s.Actual = v 6294 return s, err 6295 }, sms...) 6296 if err != nil { 6297 return nil, err 6298 } 6299 return s, err 6300} 6301 6302// FieldScalarU60LE adds a field and reads 60 bit unsigned integer in little-endian 6303func (d *D) FieldScalarU60LE(name string, sms ...scalar.Mapper) *scalar.S { 6304 s, err := d.TryFieldScalarU60LE(name, sms...) 6305 if err != nil { 6306 panic(IOError{Err: err, Name: name, Op: "U60LE", Pos: d.Pos()}) 6307 } 6308 return s 6309} 6310 6311// TryFieldU60LE tries to add a field and read 60 bit unsigned integer in little-endian 6312func (d *D) TryFieldU60LE(name string, sms ...scalar.Mapper) (uint64, error) { 6313 s, err := d.TryFieldScalarU60LE(name, sms...) 6314 return s.ActualU(), err 6315} 6316 6317// FieldU60LE adds a field and reads 60 bit unsigned integer in little-endian 6318func (d *D) FieldU60LE(name string, sms ...scalar.Mapper) uint64 { 6319 return d.FieldScalarU60LE(name, sms...).ActualU() 6320} 6321 6322// Reader U61LE 6323 6324// TryU61LE tries to read 61 bit unsigned integer in little-endian 6325func (d *D) TryU61LE() (uint64, error) { return d.tryUE(61, LittleEndian) } 6326 6327// U61LE reads 61 bit unsigned integer in little-endian 6328func (d *D) U61LE() uint64 { 6329 v, err := d.tryUE(61, LittleEndian) 6330 if err != nil { 6331 panic(IOError{Err: err, Op: "U61LE", Pos: d.Pos()}) 6332 } 6333 return v 6334} 6335 6336// TryFieldScalarU61LE tries to add a field and read 61 bit unsigned integer in little-endian 6337func (d *D) TryFieldScalarU61LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 6338 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 6339 v, err := d.tryUE(61, LittleEndian) 6340 s.Actual = v 6341 return s, err 6342 }, sms...) 6343 if err != nil { 6344 return nil, err 6345 } 6346 return s, err 6347} 6348 6349// FieldScalarU61LE adds a field and reads 61 bit unsigned integer in little-endian 6350func (d *D) FieldScalarU61LE(name string, sms ...scalar.Mapper) *scalar.S { 6351 s, err := d.TryFieldScalarU61LE(name, sms...) 6352 if err != nil { 6353 panic(IOError{Err: err, Name: name, Op: "U61LE", Pos: d.Pos()}) 6354 } 6355 return s 6356} 6357 6358// TryFieldU61LE tries to add a field and read 61 bit unsigned integer in little-endian 6359func (d *D) TryFieldU61LE(name string, sms ...scalar.Mapper) (uint64, error) { 6360 s, err := d.TryFieldScalarU61LE(name, sms...) 6361 return s.ActualU(), err 6362} 6363 6364// FieldU61LE adds a field and reads 61 bit unsigned integer in little-endian 6365func (d *D) FieldU61LE(name string, sms ...scalar.Mapper) uint64 { 6366 return d.FieldScalarU61LE(name, sms...).ActualU() 6367} 6368 6369// Reader U62LE 6370 6371// TryU62LE tries to read 62 bit unsigned integer in little-endian 6372func (d *D) TryU62LE() (uint64, error) { return d.tryUE(62, LittleEndian) } 6373 6374// U62LE reads 62 bit unsigned integer in little-endian 6375func (d *D) U62LE() uint64 { 6376 v, err := d.tryUE(62, LittleEndian) 6377 if err != nil { 6378 panic(IOError{Err: err, Op: "U62LE", Pos: d.Pos()}) 6379 } 6380 return v 6381} 6382 6383// TryFieldScalarU62LE tries to add a field and read 62 bit unsigned integer in little-endian 6384func (d *D) TryFieldScalarU62LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 6385 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 6386 v, err := d.tryUE(62, LittleEndian) 6387 s.Actual = v 6388 return s, err 6389 }, sms...) 6390 if err != nil { 6391 return nil, err 6392 } 6393 return s, err 6394} 6395 6396// FieldScalarU62LE adds a field and reads 62 bit unsigned integer in little-endian 6397func (d *D) FieldScalarU62LE(name string, sms ...scalar.Mapper) *scalar.S { 6398 s, err := d.TryFieldScalarU62LE(name, sms...) 6399 if err != nil { 6400 panic(IOError{Err: err, Name: name, Op: "U62LE", Pos: d.Pos()}) 6401 } 6402 return s 6403} 6404 6405// TryFieldU62LE tries to add a field and read 62 bit unsigned integer in little-endian 6406func (d *D) TryFieldU62LE(name string, sms ...scalar.Mapper) (uint64, error) { 6407 s, err := d.TryFieldScalarU62LE(name, sms...) 6408 return s.ActualU(), err 6409} 6410 6411// FieldU62LE adds a field and reads 62 bit unsigned integer in little-endian 6412func (d *D) FieldU62LE(name string, sms ...scalar.Mapper) uint64 { 6413 return d.FieldScalarU62LE(name, sms...).ActualU() 6414} 6415 6416// Reader U63LE 6417 6418// TryU63LE tries to read 63 bit unsigned integer in little-endian 6419func (d *D) TryU63LE() (uint64, error) { return d.tryUE(63, LittleEndian) } 6420 6421// U63LE reads 63 bit unsigned integer in little-endian 6422func (d *D) U63LE() uint64 { 6423 v, err := d.tryUE(63, LittleEndian) 6424 if err != nil { 6425 panic(IOError{Err: err, Op: "U63LE", Pos: d.Pos()}) 6426 } 6427 return v 6428} 6429 6430// TryFieldScalarU63LE tries to add a field and read 63 bit unsigned integer in little-endian 6431func (d *D) TryFieldScalarU63LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 6432 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 6433 v, err := d.tryUE(63, LittleEndian) 6434 s.Actual = v 6435 return s, err 6436 }, sms...) 6437 if err != nil { 6438 return nil, err 6439 } 6440 return s, err 6441} 6442 6443// FieldScalarU63LE adds a field and reads 63 bit unsigned integer in little-endian 6444func (d *D) FieldScalarU63LE(name string, sms ...scalar.Mapper) *scalar.S { 6445 s, err := d.TryFieldScalarU63LE(name, sms...) 6446 if err != nil { 6447 panic(IOError{Err: err, Name: name, Op: "U63LE", Pos: d.Pos()}) 6448 } 6449 return s 6450} 6451 6452// TryFieldU63LE tries to add a field and read 63 bit unsigned integer in little-endian 6453func (d *D) TryFieldU63LE(name string, sms ...scalar.Mapper) (uint64, error) { 6454 s, err := d.TryFieldScalarU63LE(name, sms...) 6455 return s.ActualU(), err 6456} 6457 6458// FieldU63LE adds a field and reads 63 bit unsigned integer in little-endian 6459func (d *D) FieldU63LE(name string, sms ...scalar.Mapper) uint64 { 6460 return d.FieldScalarU63LE(name, sms...).ActualU() 6461} 6462 6463// Reader U64LE 6464 6465// TryU64LE tries to read 64 bit unsigned integer in little-endian 6466func (d *D) TryU64LE() (uint64, error) { return d.tryUE(64, LittleEndian) } 6467 6468// U64LE reads 64 bit unsigned integer in little-endian 6469func (d *D) U64LE() uint64 { 6470 v, err := d.tryUE(64, LittleEndian) 6471 if err != nil { 6472 panic(IOError{Err: err, Op: "U64LE", Pos: d.Pos()}) 6473 } 6474 return v 6475} 6476 6477// TryFieldScalarU64LE tries to add a field and read 64 bit unsigned integer in little-endian 6478func (d *D) TryFieldScalarU64LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 6479 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 6480 v, err := d.tryUE(64, LittleEndian) 6481 s.Actual = v 6482 return s, err 6483 }, sms...) 6484 if err != nil { 6485 return nil, err 6486 } 6487 return s, err 6488} 6489 6490// FieldScalarU64LE adds a field and reads 64 bit unsigned integer in little-endian 6491func (d *D) FieldScalarU64LE(name string, sms ...scalar.Mapper) *scalar.S { 6492 s, err := d.TryFieldScalarU64LE(name, sms...) 6493 if err != nil { 6494 panic(IOError{Err: err, Name: name, Op: "U64LE", Pos: d.Pos()}) 6495 } 6496 return s 6497} 6498 6499// TryFieldU64LE tries to add a field and read 64 bit unsigned integer in little-endian 6500func (d *D) TryFieldU64LE(name string, sms ...scalar.Mapper) (uint64, error) { 6501 s, err := d.TryFieldScalarU64LE(name, sms...) 6502 return s.ActualU(), err 6503} 6504 6505// FieldU64LE adds a field and reads 64 bit unsigned integer in little-endian 6506func (d *D) FieldU64LE(name string, sms ...scalar.Mapper) uint64 { 6507 return d.FieldScalarU64LE(name, sms...).ActualU() 6508} 6509 6510// Reader U8BE 6511 6512// TryU8BE tries to read 8 bit unsigned integer in big-endian 6513func (d *D) TryU8BE() (uint64, error) { return d.tryUE(8, BigEndian) } 6514 6515// U8BE reads 8 bit unsigned integer in big-endian 6516func (d *D) U8BE() uint64 { 6517 v, err := d.tryUE(8, BigEndian) 6518 if err != nil { 6519 panic(IOError{Err: err, Op: "U8BE", Pos: d.Pos()}) 6520 } 6521 return v 6522} 6523 6524// TryFieldScalarU8BE tries to add a field and read 8 bit unsigned integer in big-endian 6525func (d *D) TryFieldScalarU8BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 6526 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 6527 v, err := d.tryUE(8, BigEndian) 6528 s.Actual = v 6529 return s, err 6530 }, sms...) 6531 if err != nil { 6532 return nil, err 6533 } 6534 return s, err 6535} 6536 6537// FieldScalarU8BE adds a field and reads 8 bit unsigned integer in big-endian 6538func (d *D) FieldScalarU8BE(name string, sms ...scalar.Mapper) *scalar.S { 6539 s, err := d.TryFieldScalarU8BE(name, sms...) 6540 if err != nil { 6541 panic(IOError{Err: err, Name: name, Op: "U8BE", Pos: d.Pos()}) 6542 } 6543 return s 6544} 6545 6546// TryFieldU8BE tries to add a field and read 8 bit unsigned integer in big-endian 6547func (d *D) TryFieldU8BE(name string, sms ...scalar.Mapper) (uint64, error) { 6548 s, err := d.TryFieldScalarU8BE(name, sms...) 6549 return s.ActualU(), err 6550} 6551 6552// FieldU8BE adds a field and reads 8 bit unsigned integer in big-endian 6553func (d *D) FieldU8BE(name string, sms ...scalar.Mapper) uint64 { 6554 return d.FieldScalarU8BE(name, sms...).ActualU() 6555} 6556 6557// Reader U9BE 6558 6559// TryU9BE tries to read 9 bit unsigned integer in big-endian 6560func (d *D) TryU9BE() (uint64, error) { return d.tryUE(9, BigEndian) } 6561 6562// U9BE reads 9 bit unsigned integer in big-endian 6563func (d *D) U9BE() uint64 { 6564 v, err := d.tryUE(9, BigEndian) 6565 if err != nil { 6566 panic(IOError{Err: err, Op: "U9BE", Pos: d.Pos()}) 6567 } 6568 return v 6569} 6570 6571// TryFieldScalarU9BE tries to add a field and read 9 bit unsigned integer in big-endian 6572func (d *D) TryFieldScalarU9BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 6573 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 6574 v, err := d.tryUE(9, BigEndian) 6575 s.Actual = v 6576 return s, err 6577 }, sms...) 6578 if err != nil { 6579 return nil, err 6580 } 6581 return s, err 6582} 6583 6584// FieldScalarU9BE adds a field and reads 9 bit unsigned integer in big-endian 6585func (d *D) FieldScalarU9BE(name string, sms ...scalar.Mapper) *scalar.S { 6586 s, err := d.TryFieldScalarU9BE(name, sms...) 6587 if err != nil { 6588 panic(IOError{Err: err, Name: name, Op: "U9BE", Pos: d.Pos()}) 6589 } 6590 return s 6591} 6592 6593// TryFieldU9BE tries to add a field and read 9 bit unsigned integer in big-endian 6594func (d *D) TryFieldU9BE(name string, sms ...scalar.Mapper) (uint64, error) { 6595 s, err := d.TryFieldScalarU9BE(name, sms...) 6596 return s.ActualU(), err 6597} 6598 6599// FieldU9BE adds a field and reads 9 bit unsigned integer in big-endian 6600func (d *D) FieldU9BE(name string, sms ...scalar.Mapper) uint64 { 6601 return d.FieldScalarU9BE(name, sms...).ActualU() 6602} 6603 6604// Reader U10BE 6605 6606// TryU10BE tries to read 10 bit unsigned integer in big-endian 6607func (d *D) TryU10BE() (uint64, error) { return d.tryUE(10, BigEndian) } 6608 6609// U10BE reads 10 bit unsigned integer in big-endian 6610func (d *D) U10BE() uint64 { 6611 v, err := d.tryUE(10, BigEndian) 6612 if err != nil { 6613 panic(IOError{Err: err, Op: "U10BE", Pos: d.Pos()}) 6614 } 6615 return v 6616} 6617 6618// TryFieldScalarU10BE tries to add a field and read 10 bit unsigned integer in big-endian 6619func (d *D) TryFieldScalarU10BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 6620 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 6621 v, err := d.tryUE(10, BigEndian) 6622 s.Actual = v 6623 return s, err 6624 }, sms...) 6625 if err != nil { 6626 return nil, err 6627 } 6628 return s, err 6629} 6630 6631// FieldScalarU10BE adds a field and reads 10 bit unsigned integer in big-endian 6632func (d *D) FieldScalarU10BE(name string, sms ...scalar.Mapper) *scalar.S { 6633 s, err := d.TryFieldScalarU10BE(name, sms...) 6634 if err != nil { 6635 panic(IOError{Err: err, Name: name, Op: "U10BE", Pos: d.Pos()}) 6636 } 6637 return s 6638} 6639 6640// TryFieldU10BE tries to add a field and read 10 bit unsigned integer in big-endian 6641func (d *D) TryFieldU10BE(name string, sms ...scalar.Mapper) (uint64, error) { 6642 s, err := d.TryFieldScalarU10BE(name, sms...) 6643 return s.ActualU(), err 6644} 6645 6646// FieldU10BE adds a field and reads 10 bit unsigned integer in big-endian 6647func (d *D) FieldU10BE(name string, sms ...scalar.Mapper) uint64 { 6648 return d.FieldScalarU10BE(name, sms...).ActualU() 6649} 6650 6651// Reader U11BE 6652 6653// TryU11BE tries to read 11 bit unsigned integer in big-endian 6654func (d *D) TryU11BE() (uint64, error) { return d.tryUE(11, BigEndian) } 6655 6656// U11BE reads 11 bit unsigned integer in big-endian 6657func (d *D) U11BE() uint64 { 6658 v, err := d.tryUE(11, BigEndian) 6659 if err != nil { 6660 panic(IOError{Err: err, Op: "U11BE", Pos: d.Pos()}) 6661 } 6662 return v 6663} 6664 6665// TryFieldScalarU11BE tries to add a field and read 11 bit unsigned integer in big-endian 6666func (d *D) TryFieldScalarU11BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 6667 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 6668 v, err := d.tryUE(11, BigEndian) 6669 s.Actual = v 6670 return s, err 6671 }, sms...) 6672 if err != nil { 6673 return nil, err 6674 } 6675 return s, err 6676} 6677 6678// FieldScalarU11BE adds a field and reads 11 bit unsigned integer in big-endian 6679func (d *D) FieldScalarU11BE(name string, sms ...scalar.Mapper) *scalar.S { 6680 s, err := d.TryFieldScalarU11BE(name, sms...) 6681 if err != nil { 6682 panic(IOError{Err: err, Name: name, Op: "U11BE", Pos: d.Pos()}) 6683 } 6684 return s 6685} 6686 6687// TryFieldU11BE tries to add a field and read 11 bit unsigned integer in big-endian 6688func (d *D) TryFieldU11BE(name string, sms ...scalar.Mapper) (uint64, error) { 6689 s, err := d.TryFieldScalarU11BE(name, sms...) 6690 return s.ActualU(), err 6691} 6692 6693// FieldU11BE adds a field and reads 11 bit unsigned integer in big-endian 6694func (d *D) FieldU11BE(name string, sms ...scalar.Mapper) uint64 { 6695 return d.FieldScalarU11BE(name, sms...).ActualU() 6696} 6697 6698// Reader U12BE 6699 6700// TryU12BE tries to read 12 bit unsigned integer in big-endian 6701func (d *D) TryU12BE() (uint64, error) { return d.tryUE(12, BigEndian) } 6702 6703// U12BE reads 12 bit unsigned integer in big-endian 6704func (d *D) U12BE() uint64 { 6705 v, err := d.tryUE(12, BigEndian) 6706 if err != nil { 6707 panic(IOError{Err: err, Op: "U12BE", Pos: d.Pos()}) 6708 } 6709 return v 6710} 6711 6712// TryFieldScalarU12BE tries to add a field and read 12 bit unsigned integer in big-endian 6713func (d *D) TryFieldScalarU12BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 6714 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 6715 v, err := d.tryUE(12, BigEndian) 6716 s.Actual = v 6717 return s, err 6718 }, sms...) 6719 if err != nil { 6720 return nil, err 6721 } 6722 return s, err 6723} 6724 6725// FieldScalarU12BE adds a field and reads 12 bit unsigned integer in big-endian 6726func (d *D) FieldScalarU12BE(name string, sms ...scalar.Mapper) *scalar.S { 6727 s, err := d.TryFieldScalarU12BE(name, sms...) 6728 if err != nil { 6729 panic(IOError{Err: err, Name: name, Op: "U12BE", Pos: d.Pos()}) 6730 } 6731 return s 6732} 6733 6734// TryFieldU12BE tries to add a field and read 12 bit unsigned integer in big-endian 6735func (d *D) TryFieldU12BE(name string, sms ...scalar.Mapper) (uint64, error) { 6736 s, err := d.TryFieldScalarU12BE(name, sms...) 6737 return s.ActualU(), err 6738} 6739 6740// FieldU12BE adds a field and reads 12 bit unsigned integer in big-endian 6741func (d *D) FieldU12BE(name string, sms ...scalar.Mapper) uint64 { 6742 return d.FieldScalarU12BE(name, sms...).ActualU() 6743} 6744 6745// Reader U13BE 6746 6747// TryU13BE tries to read 13 bit unsigned integer in big-endian 6748func (d *D) TryU13BE() (uint64, error) { return d.tryUE(13, BigEndian) } 6749 6750// U13BE reads 13 bit unsigned integer in big-endian 6751func (d *D) U13BE() uint64 { 6752 v, err := d.tryUE(13, BigEndian) 6753 if err != nil { 6754 panic(IOError{Err: err, Op: "U13BE", Pos: d.Pos()}) 6755 } 6756 return v 6757} 6758 6759// TryFieldScalarU13BE tries to add a field and read 13 bit unsigned integer in big-endian 6760func (d *D) TryFieldScalarU13BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 6761 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 6762 v, err := d.tryUE(13, BigEndian) 6763 s.Actual = v 6764 return s, err 6765 }, sms...) 6766 if err != nil { 6767 return nil, err 6768 } 6769 return s, err 6770} 6771 6772// FieldScalarU13BE adds a field and reads 13 bit unsigned integer in big-endian 6773func (d *D) FieldScalarU13BE(name string, sms ...scalar.Mapper) *scalar.S { 6774 s, err := d.TryFieldScalarU13BE(name, sms...) 6775 if err != nil { 6776 panic(IOError{Err: err, Name: name, Op: "U13BE", Pos: d.Pos()}) 6777 } 6778 return s 6779} 6780 6781// TryFieldU13BE tries to add a field and read 13 bit unsigned integer in big-endian 6782func (d *D) TryFieldU13BE(name string, sms ...scalar.Mapper) (uint64, error) { 6783 s, err := d.TryFieldScalarU13BE(name, sms...) 6784 return s.ActualU(), err 6785} 6786 6787// FieldU13BE adds a field and reads 13 bit unsigned integer in big-endian 6788func (d *D) FieldU13BE(name string, sms ...scalar.Mapper) uint64 { 6789 return d.FieldScalarU13BE(name, sms...).ActualU() 6790} 6791 6792// Reader U14BE 6793 6794// TryU14BE tries to read 14 bit unsigned integer in big-endian 6795func (d *D) TryU14BE() (uint64, error) { return d.tryUE(14, BigEndian) } 6796 6797// U14BE reads 14 bit unsigned integer in big-endian 6798func (d *D) U14BE() uint64 { 6799 v, err := d.tryUE(14, BigEndian) 6800 if err != nil { 6801 panic(IOError{Err: err, Op: "U14BE", Pos: d.Pos()}) 6802 } 6803 return v 6804} 6805 6806// TryFieldScalarU14BE tries to add a field and read 14 bit unsigned integer in big-endian 6807func (d *D) TryFieldScalarU14BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 6808 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 6809 v, err := d.tryUE(14, BigEndian) 6810 s.Actual = v 6811 return s, err 6812 }, sms...) 6813 if err != nil { 6814 return nil, err 6815 } 6816 return s, err 6817} 6818 6819// FieldScalarU14BE adds a field and reads 14 bit unsigned integer in big-endian 6820func (d *D) FieldScalarU14BE(name string, sms ...scalar.Mapper) *scalar.S { 6821 s, err := d.TryFieldScalarU14BE(name, sms...) 6822 if err != nil { 6823 panic(IOError{Err: err, Name: name, Op: "U14BE", Pos: d.Pos()}) 6824 } 6825 return s 6826} 6827 6828// TryFieldU14BE tries to add a field and read 14 bit unsigned integer in big-endian 6829func (d *D) TryFieldU14BE(name string, sms ...scalar.Mapper) (uint64, error) { 6830 s, err := d.TryFieldScalarU14BE(name, sms...) 6831 return s.ActualU(), err 6832} 6833 6834// FieldU14BE adds a field and reads 14 bit unsigned integer in big-endian 6835func (d *D) FieldU14BE(name string, sms ...scalar.Mapper) uint64 { 6836 return d.FieldScalarU14BE(name, sms...).ActualU() 6837} 6838 6839// Reader U15BE 6840 6841// TryU15BE tries to read 15 bit unsigned integer in big-endian 6842func (d *D) TryU15BE() (uint64, error) { return d.tryUE(15, BigEndian) } 6843 6844// U15BE reads 15 bit unsigned integer in big-endian 6845func (d *D) U15BE() uint64 { 6846 v, err := d.tryUE(15, BigEndian) 6847 if err != nil { 6848 panic(IOError{Err: err, Op: "U15BE", Pos: d.Pos()}) 6849 } 6850 return v 6851} 6852 6853// TryFieldScalarU15BE tries to add a field and read 15 bit unsigned integer in big-endian 6854func (d *D) TryFieldScalarU15BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 6855 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 6856 v, err := d.tryUE(15, BigEndian) 6857 s.Actual = v 6858 return s, err 6859 }, sms...) 6860 if err != nil { 6861 return nil, err 6862 } 6863 return s, err 6864} 6865 6866// FieldScalarU15BE adds a field and reads 15 bit unsigned integer in big-endian 6867func (d *D) FieldScalarU15BE(name string, sms ...scalar.Mapper) *scalar.S { 6868 s, err := d.TryFieldScalarU15BE(name, sms...) 6869 if err != nil { 6870 panic(IOError{Err: err, Name: name, Op: "U15BE", Pos: d.Pos()}) 6871 } 6872 return s 6873} 6874 6875// TryFieldU15BE tries to add a field and read 15 bit unsigned integer in big-endian 6876func (d *D) TryFieldU15BE(name string, sms ...scalar.Mapper) (uint64, error) { 6877 s, err := d.TryFieldScalarU15BE(name, sms...) 6878 return s.ActualU(), err 6879} 6880 6881// FieldU15BE adds a field and reads 15 bit unsigned integer in big-endian 6882func (d *D) FieldU15BE(name string, sms ...scalar.Mapper) uint64 { 6883 return d.FieldScalarU15BE(name, sms...).ActualU() 6884} 6885 6886// Reader U16BE 6887 6888// TryU16BE tries to read 16 bit unsigned integer in big-endian 6889func (d *D) TryU16BE() (uint64, error) { return d.tryUE(16, BigEndian) } 6890 6891// U16BE reads 16 bit unsigned integer in big-endian 6892func (d *D) U16BE() uint64 { 6893 v, err := d.tryUE(16, BigEndian) 6894 if err != nil { 6895 panic(IOError{Err: err, Op: "U16BE", Pos: d.Pos()}) 6896 } 6897 return v 6898} 6899 6900// TryFieldScalarU16BE tries to add a field and read 16 bit unsigned integer in big-endian 6901func (d *D) TryFieldScalarU16BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 6902 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 6903 v, err := d.tryUE(16, BigEndian) 6904 s.Actual = v 6905 return s, err 6906 }, sms...) 6907 if err != nil { 6908 return nil, err 6909 } 6910 return s, err 6911} 6912 6913// FieldScalarU16BE adds a field and reads 16 bit unsigned integer in big-endian 6914func (d *D) FieldScalarU16BE(name string, sms ...scalar.Mapper) *scalar.S { 6915 s, err := d.TryFieldScalarU16BE(name, sms...) 6916 if err != nil { 6917 panic(IOError{Err: err, Name: name, Op: "U16BE", Pos: d.Pos()}) 6918 } 6919 return s 6920} 6921 6922// TryFieldU16BE tries to add a field and read 16 bit unsigned integer in big-endian 6923func (d *D) TryFieldU16BE(name string, sms ...scalar.Mapper) (uint64, error) { 6924 s, err := d.TryFieldScalarU16BE(name, sms...) 6925 return s.ActualU(), err 6926} 6927 6928// FieldU16BE adds a field and reads 16 bit unsigned integer in big-endian 6929func (d *D) FieldU16BE(name string, sms ...scalar.Mapper) uint64 { 6930 return d.FieldScalarU16BE(name, sms...).ActualU() 6931} 6932 6933// Reader U17BE 6934 6935// TryU17BE tries to read 17 bit unsigned integer in big-endian 6936func (d *D) TryU17BE() (uint64, error) { return d.tryUE(17, BigEndian) } 6937 6938// U17BE reads 17 bit unsigned integer in big-endian 6939func (d *D) U17BE() uint64 { 6940 v, err := d.tryUE(17, BigEndian) 6941 if err != nil { 6942 panic(IOError{Err: err, Op: "U17BE", Pos: d.Pos()}) 6943 } 6944 return v 6945} 6946 6947// TryFieldScalarU17BE tries to add a field and read 17 bit unsigned integer in big-endian 6948func (d *D) TryFieldScalarU17BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 6949 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 6950 v, err := d.tryUE(17, BigEndian) 6951 s.Actual = v 6952 return s, err 6953 }, sms...) 6954 if err != nil { 6955 return nil, err 6956 } 6957 return s, err 6958} 6959 6960// FieldScalarU17BE adds a field and reads 17 bit unsigned integer in big-endian 6961func (d *D) FieldScalarU17BE(name string, sms ...scalar.Mapper) *scalar.S { 6962 s, err := d.TryFieldScalarU17BE(name, sms...) 6963 if err != nil { 6964 panic(IOError{Err: err, Name: name, Op: "U17BE", Pos: d.Pos()}) 6965 } 6966 return s 6967} 6968 6969// TryFieldU17BE tries to add a field and read 17 bit unsigned integer in big-endian 6970func (d *D) TryFieldU17BE(name string, sms ...scalar.Mapper) (uint64, error) { 6971 s, err := d.TryFieldScalarU17BE(name, sms...) 6972 return s.ActualU(), err 6973} 6974 6975// FieldU17BE adds a field and reads 17 bit unsigned integer in big-endian 6976func (d *D) FieldU17BE(name string, sms ...scalar.Mapper) uint64 { 6977 return d.FieldScalarU17BE(name, sms...).ActualU() 6978} 6979 6980// Reader U18BE 6981 6982// TryU18BE tries to read 18 bit unsigned integer in big-endian 6983func (d *D) TryU18BE() (uint64, error) { return d.tryUE(18, BigEndian) } 6984 6985// U18BE reads 18 bit unsigned integer in big-endian 6986func (d *D) U18BE() uint64 { 6987 v, err := d.tryUE(18, BigEndian) 6988 if err != nil { 6989 panic(IOError{Err: err, Op: "U18BE", Pos: d.Pos()}) 6990 } 6991 return v 6992} 6993 6994// TryFieldScalarU18BE tries to add a field and read 18 bit unsigned integer in big-endian 6995func (d *D) TryFieldScalarU18BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 6996 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 6997 v, err := d.tryUE(18, BigEndian) 6998 s.Actual = v 6999 return s, err 7000 }, sms...) 7001 if err != nil { 7002 return nil, err 7003 } 7004 return s, err 7005} 7006 7007// FieldScalarU18BE adds a field and reads 18 bit unsigned integer in big-endian 7008func (d *D) FieldScalarU18BE(name string, sms ...scalar.Mapper) *scalar.S { 7009 s, err := d.TryFieldScalarU18BE(name, sms...) 7010 if err != nil { 7011 panic(IOError{Err: err, Name: name, Op: "U18BE", Pos: d.Pos()}) 7012 } 7013 return s 7014} 7015 7016// TryFieldU18BE tries to add a field and read 18 bit unsigned integer in big-endian 7017func (d *D) TryFieldU18BE(name string, sms ...scalar.Mapper) (uint64, error) { 7018 s, err := d.TryFieldScalarU18BE(name, sms...) 7019 return s.ActualU(), err 7020} 7021 7022// FieldU18BE adds a field and reads 18 bit unsigned integer in big-endian 7023func (d *D) FieldU18BE(name string, sms ...scalar.Mapper) uint64 { 7024 return d.FieldScalarU18BE(name, sms...).ActualU() 7025} 7026 7027// Reader U19BE 7028 7029// TryU19BE tries to read 19 bit unsigned integer in big-endian 7030func (d *D) TryU19BE() (uint64, error) { return d.tryUE(19, BigEndian) } 7031 7032// U19BE reads 19 bit unsigned integer in big-endian 7033func (d *D) U19BE() uint64 { 7034 v, err := d.tryUE(19, BigEndian) 7035 if err != nil { 7036 panic(IOError{Err: err, Op: "U19BE", Pos: d.Pos()}) 7037 } 7038 return v 7039} 7040 7041// TryFieldScalarU19BE tries to add a field and read 19 bit unsigned integer in big-endian 7042func (d *D) TryFieldScalarU19BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 7043 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 7044 v, err := d.tryUE(19, BigEndian) 7045 s.Actual = v 7046 return s, err 7047 }, sms...) 7048 if err != nil { 7049 return nil, err 7050 } 7051 return s, err 7052} 7053 7054// FieldScalarU19BE adds a field and reads 19 bit unsigned integer in big-endian 7055func (d *D) FieldScalarU19BE(name string, sms ...scalar.Mapper) *scalar.S { 7056 s, err := d.TryFieldScalarU19BE(name, sms...) 7057 if err != nil { 7058 panic(IOError{Err: err, Name: name, Op: "U19BE", Pos: d.Pos()}) 7059 } 7060 return s 7061} 7062 7063// TryFieldU19BE tries to add a field and read 19 bit unsigned integer in big-endian 7064func (d *D) TryFieldU19BE(name string, sms ...scalar.Mapper) (uint64, error) { 7065 s, err := d.TryFieldScalarU19BE(name, sms...) 7066 return s.ActualU(), err 7067} 7068 7069// FieldU19BE adds a field and reads 19 bit unsigned integer in big-endian 7070func (d *D) FieldU19BE(name string, sms ...scalar.Mapper) uint64 { 7071 return d.FieldScalarU19BE(name, sms...).ActualU() 7072} 7073 7074// Reader U20BE 7075 7076// TryU20BE tries to read 20 bit unsigned integer in big-endian 7077func (d *D) TryU20BE() (uint64, error) { return d.tryUE(20, BigEndian) } 7078 7079// U20BE reads 20 bit unsigned integer in big-endian 7080func (d *D) U20BE() uint64 { 7081 v, err := d.tryUE(20, BigEndian) 7082 if err != nil { 7083 panic(IOError{Err: err, Op: "U20BE", Pos: d.Pos()}) 7084 } 7085 return v 7086} 7087 7088// TryFieldScalarU20BE tries to add a field and read 20 bit unsigned integer in big-endian 7089func (d *D) TryFieldScalarU20BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 7090 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 7091 v, err := d.tryUE(20, BigEndian) 7092 s.Actual = v 7093 return s, err 7094 }, sms...) 7095 if err != nil { 7096 return nil, err 7097 } 7098 return s, err 7099} 7100 7101// FieldScalarU20BE adds a field and reads 20 bit unsigned integer in big-endian 7102func (d *D) FieldScalarU20BE(name string, sms ...scalar.Mapper) *scalar.S { 7103 s, err := d.TryFieldScalarU20BE(name, sms...) 7104 if err != nil { 7105 panic(IOError{Err: err, Name: name, Op: "U20BE", Pos: d.Pos()}) 7106 } 7107 return s 7108} 7109 7110// TryFieldU20BE tries to add a field and read 20 bit unsigned integer in big-endian 7111func (d *D) TryFieldU20BE(name string, sms ...scalar.Mapper) (uint64, error) { 7112 s, err := d.TryFieldScalarU20BE(name, sms...) 7113 return s.ActualU(), err 7114} 7115 7116// FieldU20BE adds a field and reads 20 bit unsigned integer in big-endian 7117func (d *D) FieldU20BE(name string, sms ...scalar.Mapper) uint64 { 7118 return d.FieldScalarU20BE(name, sms...).ActualU() 7119} 7120 7121// Reader U21BE 7122 7123// TryU21BE tries to read 21 bit unsigned integer in big-endian 7124func (d *D) TryU21BE() (uint64, error) { return d.tryUE(21, BigEndian) } 7125 7126// U21BE reads 21 bit unsigned integer in big-endian 7127func (d *D) U21BE() uint64 { 7128 v, err := d.tryUE(21, BigEndian) 7129 if err != nil { 7130 panic(IOError{Err: err, Op: "U21BE", Pos: d.Pos()}) 7131 } 7132 return v 7133} 7134 7135// TryFieldScalarU21BE tries to add a field and read 21 bit unsigned integer in big-endian 7136func (d *D) TryFieldScalarU21BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 7137 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 7138 v, err := d.tryUE(21, BigEndian) 7139 s.Actual = v 7140 return s, err 7141 }, sms...) 7142 if err != nil { 7143 return nil, err 7144 } 7145 return s, err 7146} 7147 7148// FieldScalarU21BE adds a field and reads 21 bit unsigned integer in big-endian 7149func (d *D) FieldScalarU21BE(name string, sms ...scalar.Mapper) *scalar.S { 7150 s, err := d.TryFieldScalarU21BE(name, sms...) 7151 if err != nil { 7152 panic(IOError{Err: err, Name: name, Op: "U21BE", Pos: d.Pos()}) 7153 } 7154 return s 7155} 7156 7157// TryFieldU21BE tries to add a field and read 21 bit unsigned integer in big-endian 7158func (d *D) TryFieldU21BE(name string, sms ...scalar.Mapper) (uint64, error) { 7159 s, err := d.TryFieldScalarU21BE(name, sms...) 7160 return s.ActualU(), err 7161} 7162 7163// FieldU21BE adds a field and reads 21 bit unsigned integer in big-endian 7164func (d *D) FieldU21BE(name string, sms ...scalar.Mapper) uint64 { 7165 return d.FieldScalarU21BE(name, sms...).ActualU() 7166} 7167 7168// Reader U22BE 7169 7170// TryU22BE tries to read 22 bit unsigned integer in big-endian 7171func (d *D) TryU22BE() (uint64, error) { return d.tryUE(22, BigEndian) } 7172 7173// U22BE reads 22 bit unsigned integer in big-endian 7174func (d *D) U22BE() uint64 { 7175 v, err := d.tryUE(22, BigEndian) 7176 if err != nil { 7177 panic(IOError{Err: err, Op: "U22BE", Pos: d.Pos()}) 7178 } 7179 return v 7180} 7181 7182// TryFieldScalarU22BE tries to add a field and read 22 bit unsigned integer in big-endian 7183func (d *D) TryFieldScalarU22BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 7184 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 7185 v, err := d.tryUE(22, BigEndian) 7186 s.Actual = v 7187 return s, err 7188 }, sms...) 7189 if err != nil { 7190 return nil, err 7191 } 7192 return s, err 7193} 7194 7195// FieldScalarU22BE adds a field and reads 22 bit unsigned integer in big-endian 7196func (d *D) FieldScalarU22BE(name string, sms ...scalar.Mapper) *scalar.S { 7197 s, err := d.TryFieldScalarU22BE(name, sms...) 7198 if err != nil { 7199 panic(IOError{Err: err, Name: name, Op: "U22BE", Pos: d.Pos()}) 7200 } 7201 return s 7202} 7203 7204// TryFieldU22BE tries to add a field and read 22 bit unsigned integer in big-endian 7205func (d *D) TryFieldU22BE(name string, sms ...scalar.Mapper) (uint64, error) { 7206 s, err := d.TryFieldScalarU22BE(name, sms...) 7207 return s.ActualU(), err 7208} 7209 7210// FieldU22BE adds a field and reads 22 bit unsigned integer in big-endian 7211func (d *D) FieldU22BE(name string, sms ...scalar.Mapper) uint64 { 7212 return d.FieldScalarU22BE(name, sms...).ActualU() 7213} 7214 7215// Reader U23BE 7216 7217// TryU23BE tries to read 23 bit unsigned integer in big-endian 7218func (d *D) TryU23BE() (uint64, error) { return d.tryUE(23, BigEndian) } 7219 7220// U23BE reads 23 bit unsigned integer in big-endian 7221func (d *D) U23BE() uint64 { 7222 v, err := d.tryUE(23, BigEndian) 7223 if err != nil { 7224 panic(IOError{Err: err, Op: "U23BE", Pos: d.Pos()}) 7225 } 7226 return v 7227} 7228 7229// TryFieldScalarU23BE tries to add a field and read 23 bit unsigned integer in big-endian 7230func (d *D) TryFieldScalarU23BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 7231 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 7232 v, err := d.tryUE(23, BigEndian) 7233 s.Actual = v 7234 return s, err 7235 }, sms...) 7236 if err != nil { 7237 return nil, err 7238 } 7239 return s, err 7240} 7241 7242// FieldScalarU23BE adds a field and reads 23 bit unsigned integer in big-endian 7243func (d *D) FieldScalarU23BE(name string, sms ...scalar.Mapper) *scalar.S { 7244 s, err := d.TryFieldScalarU23BE(name, sms...) 7245 if err != nil { 7246 panic(IOError{Err: err, Name: name, Op: "U23BE", Pos: d.Pos()}) 7247 } 7248 return s 7249} 7250 7251// TryFieldU23BE tries to add a field and read 23 bit unsigned integer in big-endian 7252func (d *D) TryFieldU23BE(name string, sms ...scalar.Mapper) (uint64, error) { 7253 s, err := d.TryFieldScalarU23BE(name, sms...) 7254 return s.ActualU(), err 7255} 7256 7257// FieldU23BE adds a field and reads 23 bit unsigned integer in big-endian 7258func (d *D) FieldU23BE(name string, sms ...scalar.Mapper) uint64 { 7259 return d.FieldScalarU23BE(name, sms...).ActualU() 7260} 7261 7262// Reader U24BE 7263 7264// TryU24BE tries to read 24 bit unsigned integer in big-endian 7265func (d *D) TryU24BE() (uint64, error) { return d.tryUE(24, BigEndian) } 7266 7267// U24BE reads 24 bit unsigned integer in big-endian 7268func (d *D) U24BE() uint64 { 7269 v, err := d.tryUE(24, BigEndian) 7270 if err != nil { 7271 panic(IOError{Err: err, Op: "U24BE", Pos: d.Pos()}) 7272 } 7273 return v 7274} 7275 7276// TryFieldScalarU24BE tries to add a field and read 24 bit unsigned integer in big-endian 7277func (d *D) TryFieldScalarU24BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 7278 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 7279 v, err := d.tryUE(24, BigEndian) 7280 s.Actual = v 7281 return s, err 7282 }, sms...) 7283 if err != nil { 7284 return nil, err 7285 } 7286 return s, err 7287} 7288 7289// FieldScalarU24BE adds a field and reads 24 bit unsigned integer in big-endian 7290func (d *D) FieldScalarU24BE(name string, sms ...scalar.Mapper) *scalar.S { 7291 s, err := d.TryFieldScalarU24BE(name, sms...) 7292 if err != nil { 7293 panic(IOError{Err: err, Name: name, Op: "U24BE", Pos: d.Pos()}) 7294 } 7295 return s 7296} 7297 7298// TryFieldU24BE tries to add a field and read 24 bit unsigned integer in big-endian 7299func (d *D) TryFieldU24BE(name string, sms ...scalar.Mapper) (uint64, error) { 7300 s, err := d.TryFieldScalarU24BE(name, sms...) 7301 return s.ActualU(), err 7302} 7303 7304// FieldU24BE adds a field and reads 24 bit unsigned integer in big-endian 7305func (d *D) FieldU24BE(name string, sms ...scalar.Mapper) uint64 { 7306 return d.FieldScalarU24BE(name, sms...).ActualU() 7307} 7308 7309// Reader U25BE 7310 7311// TryU25BE tries to read 25 bit unsigned integer in big-endian 7312func (d *D) TryU25BE() (uint64, error) { return d.tryUE(25, BigEndian) } 7313 7314// U25BE reads 25 bit unsigned integer in big-endian 7315func (d *D) U25BE() uint64 { 7316 v, err := d.tryUE(25, BigEndian) 7317 if err != nil { 7318 panic(IOError{Err: err, Op: "U25BE", Pos: d.Pos()}) 7319 } 7320 return v 7321} 7322 7323// TryFieldScalarU25BE tries to add a field and read 25 bit unsigned integer in big-endian 7324func (d *D) TryFieldScalarU25BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 7325 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 7326 v, err := d.tryUE(25, BigEndian) 7327 s.Actual = v 7328 return s, err 7329 }, sms...) 7330 if err != nil { 7331 return nil, err 7332 } 7333 return s, err 7334} 7335 7336// FieldScalarU25BE adds a field and reads 25 bit unsigned integer in big-endian 7337func (d *D) FieldScalarU25BE(name string, sms ...scalar.Mapper) *scalar.S { 7338 s, err := d.TryFieldScalarU25BE(name, sms...) 7339 if err != nil { 7340 panic(IOError{Err: err, Name: name, Op: "U25BE", Pos: d.Pos()}) 7341 } 7342 return s 7343} 7344 7345// TryFieldU25BE tries to add a field and read 25 bit unsigned integer in big-endian 7346func (d *D) TryFieldU25BE(name string, sms ...scalar.Mapper) (uint64, error) { 7347 s, err := d.TryFieldScalarU25BE(name, sms...) 7348 return s.ActualU(), err 7349} 7350 7351// FieldU25BE adds a field and reads 25 bit unsigned integer in big-endian 7352func (d *D) FieldU25BE(name string, sms ...scalar.Mapper) uint64 { 7353 return d.FieldScalarU25BE(name, sms...).ActualU() 7354} 7355 7356// Reader U26BE 7357 7358// TryU26BE tries to read 26 bit unsigned integer in big-endian 7359func (d *D) TryU26BE() (uint64, error) { return d.tryUE(26, BigEndian) } 7360 7361// U26BE reads 26 bit unsigned integer in big-endian 7362func (d *D) U26BE() uint64 { 7363 v, err := d.tryUE(26, BigEndian) 7364 if err != nil { 7365 panic(IOError{Err: err, Op: "U26BE", Pos: d.Pos()}) 7366 } 7367 return v 7368} 7369 7370// TryFieldScalarU26BE tries to add a field and read 26 bit unsigned integer in big-endian 7371func (d *D) TryFieldScalarU26BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 7372 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 7373 v, err := d.tryUE(26, BigEndian) 7374 s.Actual = v 7375 return s, err 7376 }, sms...) 7377 if err != nil { 7378 return nil, err 7379 } 7380 return s, err 7381} 7382 7383// FieldScalarU26BE adds a field and reads 26 bit unsigned integer in big-endian 7384func (d *D) FieldScalarU26BE(name string, sms ...scalar.Mapper) *scalar.S { 7385 s, err := d.TryFieldScalarU26BE(name, sms...) 7386 if err != nil { 7387 panic(IOError{Err: err, Name: name, Op: "U26BE", Pos: d.Pos()}) 7388 } 7389 return s 7390} 7391 7392// TryFieldU26BE tries to add a field and read 26 bit unsigned integer in big-endian 7393func (d *D) TryFieldU26BE(name string, sms ...scalar.Mapper) (uint64, error) { 7394 s, err := d.TryFieldScalarU26BE(name, sms...) 7395 return s.ActualU(), err 7396} 7397 7398// FieldU26BE adds a field and reads 26 bit unsigned integer in big-endian 7399func (d *D) FieldU26BE(name string, sms ...scalar.Mapper) uint64 { 7400 return d.FieldScalarU26BE(name, sms...).ActualU() 7401} 7402 7403// Reader U27BE 7404 7405// TryU27BE tries to read 27 bit unsigned integer in big-endian 7406func (d *D) TryU27BE() (uint64, error) { return d.tryUE(27, BigEndian) } 7407 7408// U27BE reads 27 bit unsigned integer in big-endian 7409func (d *D) U27BE() uint64 { 7410 v, err := d.tryUE(27, BigEndian) 7411 if err != nil { 7412 panic(IOError{Err: err, Op: "U27BE", Pos: d.Pos()}) 7413 } 7414 return v 7415} 7416 7417// TryFieldScalarU27BE tries to add a field and read 27 bit unsigned integer in big-endian 7418func (d *D) TryFieldScalarU27BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 7419 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 7420 v, err := d.tryUE(27, BigEndian) 7421 s.Actual = v 7422 return s, err 7423 }, sms...) 7424 if err != nil { 7425 return nil, err 7426 } 7427 return s, err 7428} 7429 7430// FieldScalarU27BE adds a field and reads 27 bit unsigned integer in big-endian 7431func (d *D) FieldScalarU27BE(name string, sms ...scalar.Mapper) *scalar.S { 7432 s, err := d.TryFieldScalarU27BE(name, sms...) 7433 if err != nil { 7434 panic(IOError{Err: err, Name: name, Op: "U27BE", Pos: d.Pos()}) 7435 } 7436 return s 7437} 7438 7439// TryFieldU27BE tries to add a field and read 27 bit unsigned integer in big-endian 7440func (d *D) TryFieldU27BE(name string, sms ...scalar.Mapper) (uint64, error) { 7441 s, err := d.TryFieldScalarU27BE(name, sms...) 7442 return s.ActualU(), err 7443} 7444 7445// FieldU27BE adds a field and reads 27 bit unsigned integer in big-endian 7446func (d *D) FieldU27BE(name string, sms ...scalar.Mapper) uint64 { 7447 return d.FieldScalarU27BE(name, sms...).ActualU() 7448} 7449 7450// Reader U28BE 7451 7452// TryU28BE tries to read 28 bit unsigned integer in big-endian 7453func (d *D) TryU28BE() (uint64, error) { return d.tryUE(28, BigEndian) } 7454 7455// U28BE reads 28 bit unsigned integer in big-endian 7456func (d *D) U28BE() uint64 { 7457 v, err := d.tryUE(28, BigEndian) 7458 if err != nil { 7459 panic(IOError{Err: err, Op: "U28BE", Pos: d.Pos()}) 7460 } 7461 return v 7462} 7463 7464// TryFieldScalarU28BE tries to add a field and read 28 bit unsigned integer in big-endian 7465func (d *D) TryFieldScalarU28BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 7466 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 7467 v, err := d.tryUE(28, BigEndian) 7468 s.Actual = v 7469 return s, err 7470 }, sms...) 7471 if err != nil { 7472 return nil, err 7473 } 7474 return s, err 7475} 7476 7477// FieldScalarU28BE adds a field and reads 28 bit unsigned integer in big-endian 7478func (d *D) FieldScalarU28BE(name string, sms ...scalar.Mapper) *scalar.S { 7479 s, err := d.TryFieldScalarU28BE(name, sms...) 7480 if err != nil { 7481 panic(IOError{Err: err, Name: name, Op: "U28BE", Pos: d.Pos()}) 7482 } 7483 return s 7484} 7485 7486// TryFieldU28BE tries to add a field and read 28 bit unsigned integer in big-endian 7487func (d *D) TryFieldU28BE(name string, sms ...scalar.Mapper) (uint64, error) { 7488 s, err := d.TryFieldScalarU28BE(name, sms...) 7489 return s.ActualU(), err 7490} 7491 7492// FieldU28BE adds a field and reads 28 bit unsigned integer in big-endian 7493func (d *D) FieldU28BE(name string, sms ...scalar.Mapper) uint64 { 7494 return d.FieldScalarU28BE(name, sms...).ActualU() 7495} 7496 7497// Reader U29BE 7498 7499// TryU29BE tries to read 29 bit unsigned integer in big-endian 7500func (d *D) TryU29BE() (uint64, error) { return d.tryUE(29, BigEndian) } 7501 7502// U29BE reads 29 bit unsigned integer in big-endian 7503func (d *D) U29BE() uint64 { 7504 v, err := d.tryUE(29, BigEndian) 7505 if err != nil { 7506 panic(IOError{Err: err, Op: "U29BE", Pos: d.Pos()}) 7507 } 7508 return v 7509} 7510 7511// TryFieldScalarU29BE tries to add a field and read 29 bit unsigned integer in big-endian 7512func (d *D) TryFieldScalarU29BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 7513 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 7514 v, err := d.tryUE(29, BigEndian) 7515 s.Actual = v 7516 return s, err 7517 }, sms...) 7518 if err != nil { 7519 return nil, err 7520 } 7521 return s, err 7522} 7523 7524// FieldScalarU29BE adds a field and reads 29 bit unsigned integer in big-endian 7525func (d *D) FieldScalarU29BE(name string, sms ...scalar.Mapper) *scalar.S { 7526 s, err := d.TryFieldScalarU29BE(name, sms...) 7527 if err != nil { 7528 panic(IOError{Err: err, Name: name, Op: "U29BE", Pos: d.Pos()}) 7529 } 7530 return s 7531} 7532 7533// TryFieldU29BE tries to add a field and read 29 bit unsigned integer in big-endian 7534func (d *D) TryFieldU29BE(name string, sms ...scalar.Mapper) (uint64, error) { 7535 s, err := d.TryFieldScalarU29BE(name, sms...) 7536 return s.ActualU(), err 7537} 7538 7539// FieldU29BE adds a field and reads 29 bit unsigned integer in big-endian 7540func (d *D) FieldU29BE(name string, sms ...scalar.Mapper) uint64 { 7541 return d.FieldScalarU29BE(name, sms...).ActualU() 7542} 7543 7544// Reader U30BE 7545 7546// TryU30BE tries to read 30 bit unsigned integer in big-endian 7547func (d *D) TryU30BE() (uint64, error) { return d.tryUE(30, BigEndian) } 7548 7549// U30BE reads 30 bit unsigned integer in big-endian 7550func (d *D) U30BE() uint64 { 7551 v, err := d.tryUE(30, BigEndian) 7552 if err != nil { 7553 panic(IOError{Err: err, Op: "U30BE", Pos: d.Pos()}) 7554 } 7555 return v 7556} 7557 7558// TryFieldScalarU30BE tries to add a field and read 30 bit unsigned integer in big-endian 7559func (d *D) TryFieldScalarU30BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 7560 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 7561 v, err := d.tryUE(30, BigEndian) 7562 s.Actual = v 7563 return s, err 7564 }, sms...) 7565 if err != nil { 7566 return nil, err 7567 } 7568 return s, err 7569} 7570 7571// FieldScalarU30BE adds a field and reads 30 bit unsigned integer in big-endian 7572func (d *D) FieldScalarU30BE(name string, sms ...scalar.Mapper) *scalar.S { 7573 s, err := d.TryFieldScalarU30BE(name, sms...) 7574 if err != nil { 7575 panic(IOError{Err: err, Name: name, Op: "U30BE", Pos: d.Pos()}) 7576 } 7577 return s 7578} 7579 7580// TryFieldU30BE tries to add a field and read 30 bit unsigned integer in big-endian 7581func (d *D) TryFieldU30BE(name string, sms ...scalar.Mapper) (uint64, error) { 7582 s, err := d.TryFieldScalarU30BE(name, sms...) 7583 return s.ActualU(), err 7584} 7585 7586// FieldU30BE adds a field and reads 30 bit unsigned integer in big-endian 7587func (d *D) FieldU30BE(name string, sms ...scalar.Mapper) uint64 { 7588 return d.FieldScalarU30BE(name, sms...).ActualU() 7589} 7590 7591// Reader U31BE 7592 7593// TryU31BE tries to read 31 bit unsigned integer in big-endian 7594func (d *D) TryU31BE() (uint64, error) { return d.tryUE(31, BigEndian) } 7595 7596// U31BE reads 31 bit unsigned integer in big-endian 7597func (d *D) U31BE() uint64 { 7598 v, err := d.tryUE(31, BigEndian) 7599 if err != nil { 7600 panic(IOError{Err: err, Op: "U31BE", Pos: d.Pos()}) 7601 } 7602 return v 7603} 7604 7605// TryFieldScalarU31BE tries to add a field and read 31 bit unsigned integer in big-endian 7606func (d *D) TryFieldScalarU31BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 7607 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 7608 v, err := d.tryUE(31, BigEndian) 7609 s.Actual = v 7610 return s, err 7611 }, sms...) 7612 if err != nil { 7613 return nil, err 7614 } 7615 return s, err 7616} 7617 7618// FieldScalarU31BE adds a field and reads 31 bit unsigned integer in big-endian 7619func (d *D) FieldScalarU31BE(name string, sms ...scalar.Mapper) *scalar.S { 7620 s, err := d.TryFieldScalarU31BE(name, sms...) 7621 if err != nil { 7622 panic(IOError{Err: err, Name: name, Op: "U31BE", Pos: d.Pos()}) 7623 } 7624 return s 7625} 7626 7627// TryFieldU31BE tries to add a field and read 31 bit unsigned integer in big-endian 7628func (d *D) TryFieldU31BE(name string, sms ...scalar.Mapper) (uint64, error) { 7629 s, err := d.TryFieldScalarU31BE(name, sms...) 7630 return s.ActualU(), err 7631} 7632 7633// FieldU31BE adds a field and reads 31 bit unsigned integer in big-endian 7634func (d *D) FieldU31BE(name string, sms ...scalar.Mapper) uint64 { 7635 return d.FieldScalarU31BE(name, sms...).ActualU() 7636} 7637 7638// Reader U32BE 7639 7640// TryU32BE tries to read 32 bit unsigned integer in big-endian 7641func (d *D) TryU32BE() (uint64, error) { return d.tryUE(32, BigEndian) } 7642 7643// U32BE reads 32 bit unsigned integer in big-endian 7644func (d *D) U32BE() uint64 { 7645 v, err := d.tryUE(32, BigEndian) 7646 if err != nil { 7647 panic(IOError{Err: err, Op: "U32BE", Pos: d.Pos()}) 7648 } 7649 return v 7650} 7651 7652// TryFieldScalarU32BE tries to add a field and read 32 bit unsigned integer in big-endian 7653func (d *D) TryFieldScalarU32BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 7654 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 7655 v, err := d.tryUE(32, BigEndian) 7656 s.Actual = v 7657 return s, err 7658 }, sms...) 7659 if err != nil { 7660 return nil, err 7661 } 7662 return s, err 7663} 7664 7665// FieldScalarU32BE adds a field and reads 32 bit unsigned integer in big-endian 7666func (d *D) FieldScalarU32BE(name string, sms ...scalar.Mapper) *scalar.S { 7667 s, err := d.TryFieldScalarU32BE(name, sms...) 7668 if err != nil { 7669 panic(IOError{Err: err, Name: name, Op: "U32BE", Pos: d.Pos()}) 7670 } 7671 return s 7672} 7673 7674// TryFieldU32BE tries to add a field and read 32 bit unsigned integer in big-endian 7675func (d *D) TryFieldU32BE(name string, sms ...scalar.Mapper) (uint64, error) { 7676 s, err := d.TryFieldScalarU32BE(name, sms...) 7677 return s.ActualU(), err 7678} 7679 7680// FieldU32BE adds a field and reads 32 bit unsigned integer in big-endian 7681func (d *D) FieldU32BE(name string, sms ...scalar.Mapper) uint64 { 7682 return d.FieldScalarU32BE(name, sms...).ActualU() 7683} 7684 7685// Reader U33BE 7686 7687// TryU33BE tries to read 33 bit unsigned integer in big-endian 7688func (d *D) TryU33BE() (uint64, error) { return d.tryUE(33, BigEndian) } 7689 7690// U33BE reads 33 bit unsigned integer in big-endian 7691func (d *D) U33BE() uint64 { 7692 v, err := d.tryUE(33, BigEndian) 7693 if err != nil { 7694 panic(IOError{Err: err, Op: "U33BE", Pos: d.Pos()}) 7695 } 7696 return v 7697} 7698 7699// TryFieldScalarU33BE tries to add a field and read 33 bit unsigned integer in big-endian 7700func (d *D) TryFieldScalarU33BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 7701 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 7702 v, err := d.tryUE(33, BigEndian) 7703 s.Actual = v 7704 return s, err 7705 }, sms...) 7706 if err != nil { 7707 return nil, err 7708 } 7709 return s, err 7710} 7711 7712// FieldScalarU33BE adds a field and reads 33 bit unsigned integer in big-endian 7713func (d *D) FieldScalarU33BE(name string, sms ...scalar.Mapper) *scalar.S { 7714 s, err := d.TryFieldScalarU33BE(name, sms...) 7715 if err != nil { 7716 panic(IOError{Err: err, Name: name, Op: "U33BE", Pos: d.Pos()}) 7717 } 7718 return s 7719} 7720 7721// TryFieldU33BE tries to add a field and read 33 bit unsigned integer in big-endian 7722func (d *D) TryFieldU33BE(name string, sms ...scalar.Mapper) (uint64, error) { 7723 s, err := d.TryFieldScalarU33BE(name, sms...) 7724 return s.ActualU(), err 7725} 7726 7727// FieldU33BE adds a field and reads 33 bit unsigned integer in big-endian 7728func (d *D) FieldU33BE(name string, sms ...scalar.Mapper) uint64 { 7729 return d.FieldScalarU33BE(name, sms...).ActualU() 7730} 7731 7732// Reader U34BE 7733 7734// TryU34BE tries to read 34 bit unsigned integer in big-endian 7735func (d *D) TryU34BE() (uint64, error) { return d.tryUE(34, BigEndian) } 7736 7737// U34BE reads 34 bit unsigned integer in big-endian 7738func (d *D) U34BE() uint64 { 7739 v, err := d.tryUE(34, BigEndian) 7740 if err != nil { 7741 panic(IOError{Err: err, Op: "U34BE", Pos: d.Pos()}) 7742 } 7743 return v 7744} 7745 7746// TryFieldScalarU34BE tries to add a field and read 34 bit unsigned integer in big-endian 7747func (d *D) TryFieldScalarU34BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 7748 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 7749 v, err := d.tryUE(34, BigEndian) 7750 s.Actual = v 7751 return s, err 7752 }, sms...) 7753 if err != nil { 7754 return nil, err 7755 } 7756 return s, err 7757} 7758 7759// FieldScalarU34BE adds a field and reads 34 bit unsigned integer in big-endian 7760func (d *D) FieldScalarU34BE(name string, sms ...scalar.Mapper) *scalar.S { 7761 s, err := d.TryFieldScalarU34BE(name, sms...) 7762 if err != nil { 7763 panic(IOError{Err: err, Name: name, Op: "U34BE", Pos: d.Pos()}) 7764 } 7765 return s 7766} 7767 7768// TryFieldU34BE tries to add a field and read 34 bit unsigned integer in big-endian 7769func (d *D) TryFieldU34BE(name string, sms ...scalar.Mapper) (uint64, error) { 7770 s, err := d.TryFieldScalarU34BE(name, sms...) 7771 return s.ActualU(), err 7772} 7773 7774// FieldU34BE adds a field and reads 34 bit unsigned integer in big-endian 7775func (d *D) FieldU34BE(name string, sms ...scalar.Mapper) uint64 { 7776 return d.FieldScalarU34BE(name, sms...).ActualU() 7777} 7778 7779// Reader U35BE 7780 7781// TryU35BE tries to read 35 bit unsigned integer in big-endian 7782func (d *D) TryU35BE() (uint64, error) { return d.tryUE(35, BigEndian) } 7783 7784// U35BE reads 35 bit unsigned integer in big-endian 7785func (d *D) U35BE() uint64 { 7786 v, err := d.tryUE(35, BigEndian) 7787 if err != nil { 7788 panic(IOError{Err: err, Op: "U35BE", Pos: d.Pos()}) 7789 } 7790 return v 7791} 7792 7793// TryFieldScalarU35BE tries to add a field and read 35 bit unsigned integer in big-endian 7794func (d *D) TryFieldScalarU35BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 7795 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 7796 v, err := d.tryUE(35, BigEndian) 7797 s.Actual = v 7798 return s, err 7799 }, sms...) 7800 if err != nil { 7801 return nil, err 7802 } 7803 return s, err 7804} 7805 7806// FieldScalarU35BE adds a field and reads 35 bit unsigned integer in big-endian 7807func (d *D) FieldScalarU35BE(name string, sms ...scalar.Mapper) *scalar.S { 7808 s, err := d.TryFieldScalarU35BE(name, sms...) 7809 if err != nil { 7810 panic(IOError{Err: err, Name: name, Op: "U35BE", Pos: d.Pos()}) 7811 } 7812 return s 7813} 7814 7815// TryFieldU35BE tries to add a field and read 35 bit unsigned integer in big-endian 7816func (d *D) TryFieldU35BE(name string, sms ...scalar.Mapper) (uint64, error) { 7817 s, err := d.TryFieldScalarU35BE(name, sms...) 7818 return s.ActualU(), err 7819} 7820 7821// FieldU35BE adds a field and reads 35 bit unsigned integer in big-endian 7822func (d *D) FieldU35BE(name string, sms ...scalar.Mapper) uint64 { 7823 return d.FieldScalarU35BE(name, sms...).ActualU() 7824} 7825 7826// Reader U36BE 7827 7828// TryU36BE tries to read 36 bit unsigned integer in big-endian 7829func (d *D) TryU36BE() (uint64, error) { return d.tryUE(36, BigEndian) } 7830 7831// U36BE reads 36 bit unsigned integer in big-endian 7832func (d *D) U36BE() uint64 { 7833 v, err := d.tryUE(36, BigEndian) 7834 if err != nil { 7835 panic(IOError{Err: err, Op: "U36BE", Pos: d.Pos()}) 7836 } 7837 return v 7838} 7839 7840// TryFieldScalarU36BE tries to add a field and read 36 bit unsigned integer in big-endian 7841func (d *D) TryFieldScalarU36BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 7842 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 7843 v, err := d.tryUE(36, BigEndian) 7844 s.Actual = v 7845 return s, err 7846 }, sms...) 7847 if err != nil { 7848 return nil, err 7849 } 7850 return s, err 7851} 7852 7853// FieldScalarU36BE adds a field and reads 36 bit unsigned integer in big-endian 7854func (d *D) FieldScalarU36BE(name string, sms ...scalar.Mapper) *scalar.S { 7855 s, err := d.TryFieldScalarU36BE(name, sms...) 7856 if err != nil { 7857 panic(IOError{Err: err, Name: name, Op: "U36BE", Pos: d.Pos()}) 7858 } 7859 return s 7860} 7861 7862// TryFieldU36BE tries to add a field and read 36 bit unsigned integer in big-endian 7863func (d *D) TryFieldU36BE(name string, sms ...scalar.Mapper) (uint64, error) { 7864 s, err := d.TryFieldScalarU36BE(name, sms...) 7865 return s.ActualU(), err 7866} 7867 7868// FieldU36BE adds a field and reads 36 bit unsigned integer in big-endian 7869func (d *D) FieldU36BE(name string, sms ...scalar.Mapper) uint64 { 7870 return d.FieldScalarU36BE(name, sms...).ActualU() 7871} 7872 7873// Reader U37BE 7874 7875// TryU37BE tries to read 37 bit unsigned integer in big-endian 7876func (d *D) TryU37BE() (uint64, error) { return d.tryUE(37, BigEndian) } 7877 7878// U37BE reads 37 bit unsigned integer in big-endian 7879func (d *D) U37BE() uint64 { 7880 v, err := d.tryUE(37, BigEndian) 7881 if err != nil { 7882 panic(IOError{Err: err, Op: "U37BE", Pos: d.Pos()}) 7883 } 7884 return v 7885} 7886 7887// TryFieldScalarU37BE tries to add a field and read 37 bit unsigned integer in big-endian 7888func (d *D) TryFieldScalarU37BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 7889 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 7890 v, err := d.tryUE(37, BigEndian) 7891 s.Actual = v 7892 return s, err 7893 }, sms...) 7894 if err != nil { 7895 return nil, err 7896 } 7897 return s, err 7898} 7899 7900// FieldScalarU37BE adds a field and reads 37 bit unsigned integer in big-endian 7901func (d *D) FieldScalarU37BE(name string, sms ...scalar.Mapper) *scalar.S { 7902 s, err := d.TryFieldScalarU37BE(name, sms...) 7903 if err != nil { 7904 panic(IOError{Err: err, Name: name, Op: "U37BE", Pos: d.Pos()}) 7905 } 7906 return s 7907} 7908 7909// TryFieldU37BE tries to add a field and read 37 bit unsigned integer in big-endian 7910func (d *D) TryFieldU37BE(name string, sms ...scalar.Mapper) (uint64, error) { 7911 s, err := d.TryFieldScalarU37BE(name, sms...) 7912 return s.ActualU(), err 7913} 7914 7915// FieldU37BE adds a field and reads 37 bit unsigned integer in big-endian 7916func (d *D) FieldU37BE(name string, sms ...scalar.Mapper) uint64 { 7917 return d.FieldScalarU37BE(name, sms...).ActualU() 7918} 7919 7920// Reader U38BE 7921 7922// TryU38BE tries to read 38 bit unsigned integer in big-endian 7923func (d *D) TryU38BE() (uint64, error) { return d.tryUE(38, BigEndian) } 7924 7925// U38BE reads 38 bit unsigned integer in big-endian 7926func (d *D) U38BE() uint64 { 7927 v, err := d.tryUE(38, BigEndian) 7928 if err != nil { 7929 panic(IOError{Err: err, Op: "U38BE", Pos: d.Pos()}) 7930 } 7931 return v 7932} 7933 7934// TryFieldScalarU38BE tries to add a field and read 38 bit unsigned integer in big-endian 7935func (d *D) TryFieldScalarU38BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 7936 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 7937 v, err := d.tryUE(38, BigEndian) 7938 s.Actual = v 7939 return s, err 7940 }, sms...) 7941 if err != nil { 7942 return nil, err 7943 } 7944 return s, err 7945} 7946 7947// FieldScalarU38BE adds a field and reads 38 bit unsigned integer in big-endian 7948func (d *D) FieldScalarU38BE(name string, sms ...scalar.Mapper) *scalar.S { 7949 s, err := d.TryFieldScalarU38BE(name, sms...) 7950 if err != nil { 7951 panic(IOError{Err: err, Name: name, Op: "U38BE", Pos: d.Pos()}) 7952 } 7953 return s 7954} 7955 7956// TryFieldU38BE tries to add a field and read 38 bit unsigned integer in big-endian 7957func (d *D) TryFieldU38BE(name string, sms ...scalar.Mapper) (uint64, error) { 7958 s, err := d.TryFieldScalarU38BE(name, sms...) 7959 return s.ActualU(), err 7960} 7961 7962// FieldU38BE adds a field and reads 38 bit unsigned integer in big-endian 7963func (d *D) FieldU38BE(name string, sms ...scalar.Mapper) uint64 { 7964 return d.FieldScalarU38BE(name, sms...).ActualU() 7965} 7966 7967// Reader U39BE 7968 7969// TryU39BE tries to read 39 bit unsigned integer in big-endian 7970func (d *D) TryU39BE() (uint64, error) { return d.tryUE(39, BigEndian) } 7971 7972// U39BE reads 39 bit unsigned integer in big-endian 7973func (d *D) U39BE() uint64 { 7974 v, err := d.tryUE(39, BigEndian) 7975 if err != nil { 7976 panic(IOError{Err: err, Op: "U39BE", Pos: d.Pos()}) 7977 } 7978 return v 7979} 7980 7981// TryFieldScalarU39BE tries to add a field and read 39 bit unsigned integer in big-endian 7982func (d *D) TryFieldScalarU39BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 7983 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 7984 v, err := d.tryUE(39, BigEndian) 7985 s.Actual = v 7986 return s, err 7987 }, sms...) 7988 if err != nil { 7989 return nil, err 7990 } 7991 return s, err 7992} 7993 7994// FieldScalarU39BE adds a field and reads 39 bit unsigned integer in big-endian 7995func (d *D) FieldScalarU39BE(name string, sms ...scalar.Mapper) *scalar.S { 7996 s, err := d.TryFieldScalarU39BE(name, sms...) 7997 if err != nil { 7998 panic(IOError{Err: err, Name: name, Op: "U39BE", Pos: d.Pos()}) 7999 } 8000 return s 8001} 8002 8003// TryFieldU39BE tries to add a field and read 39 bit unsigned integer in big-endian 8004func (d *D) TryFieldU39BE(name string, sms ...scalar.Mapper) (uint64, error) { 8005 s, err := d.TryFieldScalarU39BE(name, sms...) 8006 return s.ActualU(), err 8007} 8008 8009// FieldU39BE adds a field and reads 39 bit unsigned integer in big-endian 8010func (d *D) FieldU39BE(name string, sms ...scalar.Mapper) uint64 { 8011 return d.FieldScalarU39BE(name, sms...).ActualU() 8012} 8013 8014// Reader U40BE 8015 8016// TryU40BE tries to read 40 bit unsigned integer in big-endian 8017func (d *D) TryU40BE() (uint64, error) { return d.tryUE(40, BigEndian) } 8018 8019// U40BE reads 40 bit unsigned integer in big-endian 8020func (d *D) U40BE() uint64 { 8021 v, err := d.tryUE(40, BigEndian) 8022 if err != nil { 8023 panic(IOError{Err: err, Op: "U40BE", Pos: d.Pos()}) 8024 } 8025 return v 8026} 8027 8028// TryFieldScalarU40BE tries to add a field and read 40 bit unsigned integer in big-endian 8029func (d *D) TryFieldScalarU40BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 8030 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 8031 v, err := d.tryUE(40, BigEndian) 8032 s.Actual = v 8033 return s, err 8034 }, sms...) 8035 if err != nil { 8036 return nil, err 8037 } 8038 return s, err 8039} 8040 8041// FieldScalarU40BE adds a field and reads 40 bit unsigned integer in big-endian 8042func (d *D) FieldScalarU40BE(name string, sms ...scalar.Mapper) *scalar.S { 8043 s, err := d.TryFieldScalarU40BE(name, sms...) 8044 if err != nil { 8045 panic(IOError{Err: err, Name: name, Op: "U40BE", Pos: d.Pos()}) 8046 } 8047 return s 8048} 8049 8050// TryFieldU40BE tries to add a field and read 40 bit unsigned integer in big-endian 8051func (d *D) TryFieldU40BE(name string, sms ...scalar.Mapper) (uint64, error) { 8052 s, err := d.TryFieldScalarU40BE(name, sms...) 8053 return s.ActualU(), err 8054} 8055 8056// FieldU40BE adds a field and reads 40 bit unsigned integer in big-endian 8057func (d *D) FieldU40BE(name string, sms ...scalar.Mapper) uint64 { 8058 return d.FieldScalarU40BE(name, sms...).ActualU() 8059} 8060 8061// Reader U41BE 8062 8063// TryU41BE tries to read 41 bit unsigned integer in big-endian 8064func (d *D) TryU41BE() (uint64, error) { return d.tryUE(41, BigEndian) } 8065 8066// U41BE reads 41 bit unsigned integer in big-endian 8067func (d *D) U41BE() uint64 { 8068 v, err := d.tryUE(41, BigEndian) 8069 if err != nil { 8070 panic(IOError{Err: err, Op: "U41BE", Pos: d.Pos()}) 8071 } 8072 return v 8073} 8074 8075// TryFieldScalarU41BE tries to add a field and read 41 bit unsigned integer in big-endian 8076func (d *D) TryFieldScalarU41BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 8077 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 8078 v, err := d.tryUE(41, BigEndian) 8079 s.Actual = v 8080 return s, err 8081 }, sms...) 8082 if err != nil { 8083 return nil, err 8084 } 8085 return s, err 8086} 8087 8088// FieldScalarU41BE adds a field and reads 41 bit unsigned integer in big-endian 8089func (d *D) FieldScalarU41BE(name string, sms ...scalar.Mapper) *scalar.S { 8090 s, err := d.TryFieldScalarU41BE(name, sms...) 8091 if err != nil { 8092 panic(IOError{Err: err, Name: name, Op: "U41BE", Pos: d.Pos()}) 8093 } 8094 return s 8095} 8096 8097// TryFieldU41BE tries to add a field and read 41 bit unsigned integer in big-endian 8098func (d *D) TryFieldU41BE(name string, sms ...scalar.Mapper) (uint64, error) { 8099 s, err := d.TryFieldScalarU41BE(name, sms...) 8100 return s.ActualU(), err 8101} 8102 8103// FieldU41BE adds a field and reads 41 bit unsigned integer in big-endian 8104func (d *D) FieldU41BE(name string, sms ...scalar.Mapper) uint64 { 8105 return d.FieldScalarU41BE(name, sms...).ActualU() 8106} 8107 8108// Reader U42BE 8109 8110// TryU42BE tries to read 42 bit unsigned integer in big-endian 8111func (d *D) TryU42BE() (uint64, error) { return d.tryUE(42, BigEndian) } 8112 8113// U42BE reads 42 bit unsigned integer in big-endian 8114func (d *D) U42BE() uint64 { 8115 v, err := d.tryUE(42, BigEndian) 8116 if err != nil { 8117 panic(IOError{Err: err, Op: "U42BE", Pos: d.Pos()}) 8118 } 8119 return v 8120} 8121 8122// TryFieldScalarU42BE tries to add a field and read 42 bit unsigned integer in big-endian 8123func (d *D) TryFieldScalarU42BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 8124 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 8125 v, err := d.tryUE(42, BigEndian) 8126 s.Actual = v 8127 return s, err 8128 }, sms...) 8129 if err != nil { 8130 return nil, err 8131 } 8132 return s, err 8133} 8134 8135// FieldScalarU42BE adds a field and reads 42 bit unsigned integer in big-endian 8136func (d *D) FieldScalarU42BE(name string, sms ...scalar.Mapper) *scalar.S { 8137 s, err := d.TryFieldScalarU42BE(name, sms...) 8138 if err != nil { 8139 panic(IOError{Err: err, Name: name, Op: "U42BE", Pos: d.Pos()}) 8140 } 8141 return s 8142} 8143 8144// TryFieldU42BE tries to add a field and read 42 bit unsigned integer in big-endian 8145func (d *D) TryFieldU42BE(name string, sms ...scalar.Mapper) (uint64, error) { 8146 s, err := d.TryFieldScalarU42BE(name, sms...) 8147 return s.ActualU(), err 8148} 8149 8150// FieldU42BE adds a field and reads 42 bit unsigned integer in big-endian 8151func (d *D) FieldU42BE(name string, sms ...scalar.Mapper) uint64 { 8152 return d.FieldScalarU42BE(name, sms...).ActualU() 8153} 8154 8155// Reader U43BE 8156 8157// TryU43BE tries to read 43 bit unsigned integer in big-endian 8158func (d *D) TryU43BE() (uint64, error) { return d.tryUE(43, BigEndian) } 8159 8160// U43BE reads 43 bit unsigned integer in big-endian 8161func (d *D) U43BE() uint64 { 8162 v, err := d.tryUE(43, BigEndian) 8163 if err != nil { 8164 panic(IOError{Err: err, Op: "U43BE", Pos: d.Pos()}) 8165 } 8166 return v 8167} 8168 8169// TryFieldScalarU43BE tries to add a field and read 43 bit unsigned integer in big-endian 8170func (d *D) TryFieldScalarU43BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 8171 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 8172 v, err := d.tryUE(43, BigEndian) 8173 s.Actual = v 8174 return s, err 8175 }, sms...) 8176 if err != nil { 8177 return nil, err 8178 } 8179 return s, err 8180} 8181 8182// FieldScalarU43BE adds a field and reads 43 bit unsigned integer in big-endian 8183func (d *D) FieldScalarU43BE(name string, sms ...scalar.Mapper) *scalar.S { 8184 s, err := d.TryFieldScalarU43BE(name, sms...) 8185 if err != nil { 8186 panic(IOError{Err: err, Name: name, Op: "U43BE", Pos: d.Pos()}) 8187 } 8188 return s 8189} 8190 8191// TryFieldU43BE tries to add a field and read 43 bit unsigned integer in big-endian 8192func (d *D) TryFieldU43BE(name string, sms ...scalar.Mapper) (uint64, error) { 8193 s, err := d.TryFieldScalarU43BE(name, sms...) 8194 return s.ActualU(), err 8195} 8196 8197// FieldU43BE adds a field and reads 43 bit unsigned integer in big-endian 8198func (d *D) FieldU43BE(name string, sms ...scalar.Mapper) uint64 { 8199 return d.FieldScalarU43BE(name, sms...).ActualU() 8200} 8201 8202// Reader U44BE 8203 8204// TryU44BE tries to read 44 bit unsigned integer in big-endian 8205func (d *D) TryU44BE() (uint64, error) { return d.tryUE(44, BigEndian) } 8206 8207// U44BE reads 44 bit unsigned integer in big-endian 8208func (d *D) U44BE() uint64 { 8209 v, err := d.tryUE(44, BigEndian) 8210 if err != nil { 8211 panic(IOError{Err: err, Op: "U44BE", Pos: d.Pos()}) 8212 } 8213 return v 8214} 8215 8216// TryFieldScalarU44BE tries to add a field and read 44 bit unsigned integer in big-endian 8217func (d *D) TryFieldScalarU44BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 8218 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 8219 v, err := d.tryUE(44, BigEndian) 8220 s.Actual = v 8221 return s, err 8222 }, sms...) 8223 if err != nil { 8224 return nil, err 8225 } 8226 return s, err 8227} 8228 8229// FieldScalarU44BE adds a field and reads 44 bit unsigned integer in big-endian 8230func (d *D) FieldScalarU44BE(name string, sms ...scalar.Mapper) *scalar.S { 8231 s, err := d.TryFieldScalarU44BE(name, sms...) 8232 if err != nil { 8233 panic(IOError{Err: err, Name: name, Op: "U44BE", Pos: d.Pos()}) 8234 } 8235 return s 8236} 8237 8238// TryFieldU44BE tries to add a field and read 44 bit unsigned integer in big-endian 8239func (d *D) TryFieldU44BE(name string, sms ...scalar.Mapper) (uint64, error) { 8240 s, err := d.TryFieldScalarU44BE(name, sms...) 8241 return s.ActualU(), err 8242} 8243 8244// FieldU44BE adds a field and reads 44 bit unsigned integer in big-endian 8245func (d *D) FieldU44BE(name string, sms ...scalar.Mapper) uint64 { 8246 return d.FieldScalarU44BE(name, sms...).ActualU() 8247} 8248 8249// Reader U45BE 8250 8251// TryU45BE tries to read 45 bit unsigned integer in big-endian 8252func (d *D) TryU45BE() (uint64, error) { return d.tryUE(45, BigEndian) } 8253 8254// U45BE reads 45 bit unsigned integer in big-endian 8255func (d *D) U45BE() uint64 { 8256 v, err := d.tryUE(45, BigEndian) 8257 if err != nil { 8258 panic(IOError{Err: err, Op: "U45BE", Pos: d.Pos()}) 8259 } 8260 return v 8261} 8262 8263// TryFieldScalarU45BE tries to add a field and read 45 bit unsigned integer in big-endian 8264func (d *D) TryFieldScalarU45BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 8265 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 8266 v, err := d.tryUE(45, BigEndian) 8267 s.Actual = v 8268 return s, err 8269 }, sms...) 8270 if err != nil { 8271 return nil, err 8272 } 8273 return s, err 8274} 8275 8276// FieldScalarU45BE adds a field and reads 45 bit unsigned integer in big-endian 8277func (d *D) FieldScalarU45BE(name string, sms ...scalar.Mapper) *scalar.S { 8278 s, err := d.TryFieldScalarU45BE(name, sms...) 8279 if err != nil { 8280 panic(IOError{Err: err, Name: name, Op: "U45BE", Pos: d.Pos()}) 8281 } 8282 return s 8283} 8284 8285// TryFieldU45BE tries to add a field and read 45 bit unsigned integer in big-endian 8286func (d *D) TryFieldU45BE(name string, sms ...scalar.Mapper) (uint64, error) { 8287 s, err := d.TryFieldScalarU45BE(name, sms...) 8288 return s.ActualU(), err 8289} 8290 8291// FieldU45BE adds a field and reads 45 bit unsigned integer in big-endian 8292func (d *D) FieldU45BE(name string, sms ...scalar.Mapper) uint64 { 8293 return d.FieldScalarU45BE(name, sms...).ActualU() 8294} 8295 8296// Reader U46BE 8297 8298// TryU46BE tries to read 46 bit unsigned integer in big-endian 8299func (d *D) TryU46BE() (uint64, error) { return d.tryUE(46, BigEndian) } 8300 8301// U46BE reads 46 bit unsigned integer in big-endian 8302func (d *D) U46BE() uint64 { 8303 v, err := d.tryUE(46, BigEndian) 8304 if err != nil { 8305 panic(IOError{Err: err, Op: "U46BE", Pos: d.Pos()}) 8306 } 8307 return v 8308} 8309 8310// TryFieldScalarU46BE tries to add a field and read 46 bit unsigned integer in big-endian 8311func (d *D) TryFieldScalarU46BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 8312 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 8313 v, err := d.tryUE(46, BigEndian) 8314 s.Actual = v 8315 return s, err 8316 }, sms...) 8317 if err != nil { 8318 return nil, err 8319 } 8320 return s, err 8321} 8322 8323// FieldScalarU46BE adds a field and reads 46 bit unsigned integer in big-endian 8324func (d *D) FieldScalarU46BE(name string, sms ...scalar.Mapper) *scalar.S { 8325 s, err := d.TryFieldScalarU46BE(name, sms...) 8326 if err != nil { 8327 panic(IOError{Err: err, Name: name, Op: "U46BE", Pos: d.Pos()}) 8328 } 8329 return s 8330} 8331 8332// TryFieldU46BE tries to add a field and read 46 bit unsigned integer in big-endian 8333func (d *D) TryFieldU46BE(name string, sms ...scalar.Mapper) (uint64, error) { 8334 s, err := d.TryFieldScalarU46BE(name, sms...) 8335 return s.ActualU(), err 8336} 8337 8338// FieldU46BE adds a field and reads 46 bit unsigned integer in big-endian 8339func (d *D) FieldU46BE(name string, sms ...scalar.Mapper) uint64 { 8340 return d.FieldScalarU46BE(name, sms...).ActualU() 8341} 8342 8343// Reader U47BE 8344 8345// TryU47BE tries to read 47 bit unsigned integer in big-endian 8346func (d *D) TryU47BE() (uint64, error) { return d.tryUE(47, BigEndian) } 8347 8348// U47BE reads 47 bit unsigned integer in big-endian 8349func (d *D) U47BE() uint64 { 8350 v, err := d.tryUE(47, BigEndian) 8351 if err != nil { 8352 panic(IOError{Err: err, Op: "U47BE", Pos: d.Pos()}) 8353 } 8354 return v 8355} 8356 8357// TryFieldScalarU47BE tries to add a field and read 47 bit unsigned integer in big-endian 8358func (d *D) TryFieldScalarU47BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 8359 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 8360 v, err := d.tryUE(47, BigEndian) 8361 s.Actual = v 8362 return s, err 8363 }, sms...) 8364 if err != nil { 8365 return nil, err 8366 } 8367 return s, err 8368} 8369 8370// FieldScalarU47BE adds a field and reads 47 bit unsigned integer in big-endian 8371func (d *D) FieldScalarU47BE(name string, sms ...scalar.Mapper) *scalar.S { 8372 s, err := d.TryFieldScalarU47BE(name, sms...) 8373 if err != nil { 8374 panic(IOError{Err: err, Name: name, Op: "U47BE", Pos: d.Pos()}) 8375 } 8376 return s 8377} 8378 8379// TryFieldU47BE tries to add a field and read 47 bit unsigned integer in big-endian 8380func (d *D) TryFieldU47BE(name string, sms ...scalar.Mapper) (uint64, error) { 8381 s, err := d.TryFieldScalarU47BE(name, sms...) 8382 return s.ActualU(), err 8383} 8384 8385// FieldU47BE adds a field and reads 47 bit unsigned integer in big-endian 8386func (d *D) FieldU47BE(name string, sms ...scalar.Mapper) uint64 { 8387 return d.FieldScalarU47BE(name, sms...).ActualU() 8388} 8389 8390// Reader U48BE 8391 8392// TryU48BE tries to read 48 bit unsigned integer in big-endian 8393func (d *D) TryU48BE() (uint64, error) { return d.tryUE(48, BigEndian) } 8394 8395// U48BE reads 48 bit unsigned integer in big-endian 8396func (d *D) U48BE() uint64 { 8397 v, err := d.tryUE(48, BigEndian) 8398 if err != nil { 8399 panic(IOError{Err: err, Op: "U48BE", Pos: d.Pos()}) 8400 } 8401 return v 8402} 8403 8404// TryFieldScalarU48BE tries to add a field and read 48 bit unsigned integer in big-endian 8405func (d *D) TryFieldScalarU48BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 8406 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 8407 v, err := d.tryUE(48, BigEndian) 8408 s.Actual = v 8409 return s, err 8410 }, sms...) 8411 if err != nil { 8412 return nil, err 8413 } 8414 return s, err 8415} 8416 8417// FieldScalarU48BE adds a field and reads 48 bit unsigned integer in big-endian 8418func (d *D) FieldScalarU48BE(name string, sms ...scalar.Mapper) *scalar.S { 8419 s, err := d.TryFieldScalarU48BE(name, sms...) 8420 if err != nil { 8421 panic(IOError{Err: err, Name: name, Op: "U48BE", Pos: d.Pos()}) 8422 } 8423 return s 8424} 8425 8426// TryFieldU48BE tries to add a field and read 48 bit unsigned integer in big-endian 8427func (d *D) TryFieldU48BE(name string, sms ...scalar.Mapper) (uint64, error) { 8428 s, err := d.TryFieldScalarU48BE(name, sms...) 8429 return s.ActualU(), err 8430} 8431 8432// FieldU48BE adds a field and reads 48 bit unsigned integer in big-endian 8433func (d *D) FieldU48BE(name string, sms ...scalar.Mapper) uint64 { 8434 return d.FieldScalarU48BE(name, sms...).ActualU() 8435} 8436 8437// Reader U49BE 8438 8439// TryU49BE tries to read 49 bit unsigned integer in big-endian 8440func (d *D) TryU49BE() (uint64, error) { return d.tryUE(49, BigEndian) } 8441 8442// U49BE reads 49 bit unsigned integer in big-endian 8443func (d *D) U49BE() uint64 { 8444 v, err := d.tryUE(49, BigEndian) 8445 if err != nil { 8446 panic(IOError{Err: err, Op: "U49BE", Pos: d.Pos()}) 8447 } 8448 return v 8449} 8450 8451// TryFieldScalarU49BE tries to add a field and read 49 bit unsigned integer in big-endian 8452func (d *D) TryFieldScalarU49BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 8453 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 8454 v, err := d.tryUE(49, BigEndian) 8455 s.Actual = v 8456 return s, err 8457 }, sms...) 8458 if err != nil { 8459 return nil, err 8460 } 8461 return s, err 8462} 8463 8464// FieldScalarU49BE adds a field and reads 49 bit unsigned integer in big-endian 8465func (d *D) FieldScalarU49BE(name string, sms ...scalar.Mapper) *scalar.S { 8466 s, err := d.TryFieldScalarU49BE(name, sms...) 8467 if err != nil { 8468 panic(IOError{Err: err, Name: name, Op: "U49BE", Pos: d.Pos()}) 8469 } 8470 return s 8471} 8472 8473// TryFieldU49BE tries to add a field and read 49 bit unsigned integer in big-endian 8474func (d *D) TryFieldU49BE(name string, sms ...scalar.Mapper) (uint64, error) { 8475 s, err := d.TryFieldScalarU49BE(name, sms...) 8476 return s.ActualU(), err 8477} 8478 8479// FieldU49BE adds a field and reads 49 bit unsigned integer in big-endian 8480func (d *D) FieldU49BE(name string, sms ...scalar.Mapper) uint64 { 8481 return d.FieldScalarU49BE(name, sms...).ActualU() 8482} 8483 8484// Reader U50BE 8485 8486// TryU50BE tries to read 50 bit unsigned integer in big-endian 8487func (d *D) TryU50BE() (uint64, error) { return d.tryUE(50, BigEndian) } 8488 8489// U50BE reads 50 bit unsigned integer in big-endian 8490func (d *D) U50BE() uint64 { 8491 v, err := d.tryUE(50, BigEndian) 8492 if err != nil { 8493 panic(IOError{Err: err, Op: "U50BE", Pos: d.Pos()}) 8494 } 8495 return v 8496} 8497 8498// TryFieldScalarU50BE tries to add a field and read 50 bit unsigned integer in big-endian 8499func (d *D) TryFieldScalarU50BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 8500 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 8501 v, err := d.tryUE(50, BigEndian) 8502 s.Actual = v 8503 return s, err 8504 }, sms...) 8505 if err != nil { 8506 return nil, err 8507 } 8508 return s, err 8509} 8510 8511// FieldScalarU50BE adds a field and reads 50 bit unsigned integer in big-endian 8512func (d *D) FieldScalarU50BE(name string, sms ...scalar.Mapper) *scalar.S { 8513 s, err := d.TryFieldScalarU50BE(name, sms...) 8514 if err != nil { 8515 panic(IOError{Err: err, Name: name, Op: "U50BE", Pos: d.Pos()}) 8516 } 8517 return s 8518} 8519 8520// TryFieldU50BE tries to add a field and read 50 bit unsigned integer in big-endian 8521func (d *D) TryFieldU50BE(name string, sms ...scalar.Mapper) (uint64, error) { 8522 s, err := d.TryFieldScalarU50BE(name, sms...) 8523 return s.ActualU(), err 8524} 8525 8526// FieldU50BE adds a field and reads 50 bit unsigned integer in big-endian 8527func (d *D) FieldU50BE(name string, sms ...scalar.Mapper) uint64 { 8528 return d.FieldScalarU50BE(name, sms...).ActualU() 8529} 8530 8531// Reader U51BE 8532 8533// TryU51BE tries to read 51 bit unsigned integer in big-endian 8534func (d *D) TryU51BE() (uint64, error) { return d.tryUE(51, BigEndian) } 8535 8536// U51BE reads 51 bit unsigned integer in big-endian 8537func (d *D) U51BE() uint64 { 8538 v, err := d.tryUE(51, BigEndian) 8539 if err != nil { 8540 panic(IOError{Err: err, Op: "U51BE", Pos: d.Pos()}) 8541 } 8542 return v 8543} 8544 8545// TryFieldScalarU51BE tries to add a field and read 51 bit unsigned integer in big-endian 8546func (d *D) TryFieldScalarU51BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 8547 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 8548 v, err := d.tryUE(51, BigEndian) 8549 s.Actual = v 8550 return s, err 8551 }, sms...) 8552 if err != nil { 8553 return nil, err 8554 } 8555 return s, err 8556} 8557 8558// FieldScalarU51BE adds a field and reads 51 bit unsigned integer in big-endian 8559func (d *D) FieldScalarU51BE(name string, sms ...scalar.Mapper) *scalar.S { 8560 s, err := d.TryFieldScalarU51BE(name, sms...) 8561 if err != nil { 8562 panic(IOError{Err: err, Name: name, Op: "U51BE", Pos: d.Pos()}) 8563 } 8564 return s 8565} 8566 8567// TryFieldU51BE tries to add a field and read 51 bit unsigned integer in big-endian 8568func (d *D) TryFieldU51BE(name string, sms ...scalar.Mapper) (uint64, error) { 8569 s, err := d.TryFieldScalarU51BE(name, sms...) 8570 return s.ActualU(), err 8571} 8572 8573// FieldU51BE adds a field and reads 51 bit unsigned integer in big-endian 8574func (d *D) FieldU51BE(name string, sms ...scalar.Mapper) uint64 { 8575 return d.FieldScalarU51BE(name, sms...).ActualU() 8576} 8577 8578// Reader U52BE 8579 8580// TryU52BE tries to read 52 bit unsigned integer in big-endian 8581func (d *D) TryU52BE() (uint64, error) { return d.tryUE(52, BigEndian) } 8582 8583// U52BE reads 52 bit unsigned integer in big-endian 8584func (d *D) U52BE() uint64 { 8585 v, err := d.tryUE(52, BigEndian) 8586 if err != nil { 8587 panic(IOError{Err: err, Op: "U52BE", Pos: d.Pos()}) 8588 } 8589 return v 8590} 8591 8592// TryFieldScalarU52BE tries to add a field and read 52 bit unsigned integer in big-endian 8593func (d *D) TryFieldScalarU52BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 8594 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 8595 v, err := d.tryUE(52, BigEndian) 8596 s.Actual = v 8597 return s, err 8598 }, sms...) 8599 if err != nil { 8600 return nil, err 8601 } 8602 return s, err 8603} 8604 8605// FieldScalarU52BE adds a field and reads 52 bit unsigned integer in big-endian 8606func (d *D) FieldScalarU52BE(name string, sms ...scalar.Mapper) *scalar.S { 8607 s, err := d.TryFieldScalarU52BE(name, sms...) 8608 if err != nil { 8609 panic(IOError{Err: err, Name: name, Op: "U52BE", Pos: d.Pos()}) 8610 } 8611 return s 8612} 8613 8614// TryFieldU52BE tries to add a field and read 52 bit unsigned integer in big-endian 8615func (d *D) TryFieldU52BE(name string, sms ...scalar.Mapper) (uint64, error) { 8616 s, err := d.TryFieldScalarU52BE(name, sms...) 8617 return s.ActualU(), err 8618} 8619 8620// FieldU52BE adds a field and reads 52 bit unsigned integer in big-endian 8621func (d *D) FieldU52BE(name string, sms ...scalar.Mapper) uint64 { 8622 return d.FieldScalarU52BE(name, sms...).ActualU() 8623} 8624 8625// Reader U53BE 8626 8627// TryU53BE tries to read 53 bit unsigned integer in big-endian 8628func (d *D) TryU53BE() (uint64, error) { return d.tryUE(53, BigEndian) } 8629 8630// U53BE reads 53 bit unsigned integer in big-endian 8631func (d *D) U53BE() uint64 { 8632 v, err := d.tryUE(53, BigEndian) 8633 if err != nil { 8634 panic(IOError{Err: err, Op: "U53BE", Pos: d.Pos()}) 8635 } 8636 return v 8637} 8638 8639// TryFieldScalarU53BE tries to add a field and read 53 bit unsigned integer in big-endian 8640func (d *D) TryFieldScalarU53BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 8641 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 8642 v, err := d.tryUE(53, BigEndian) 8643 s.Actual = v 8644 return s, err 8645 }, sms...) 8646 if err != nil { 8647 return nil, err 8648 } 8649 return s, err 8650} 8651 8652// FieldScalarU53BE adds a field and reads 53 bit unsigned integer in big-endian 8653func (d *D) FieldScalarU53BE(name string, sms ...scalar.Mapper) *scalar.S { 8654 s, err := d.TryFieldScalarU53BE(name, sms...) 8655 if err != nil { 8656 panic(IOError{Err: err, Name: name, Op: "U53BE", Pos: d.Pos()}) 8657 } 8658 return s 8659} 8660 8661// TryFieldU53BE tries to add a field and read 53 bit unsigned integer in big-endian 8662func (d *D) TryFieldU53BE(name string, sms ...scalar.Mapper) (uint64, error) { 8663 s, err := d.TryFieldScalarU53BE(name, sms...) 8664 return s.ActualU(), err 8665} 8666 8667// FieldU53BE adds a field and reads 53 bit unsigned integer in big-endian 8668func (d *D) FieldU53BE(name string, sms ...scalar.Mapper) uint64 { 8669 return d.FieldScalarU53BE(name, sms...).ActualU() 8670} 8671 8672// Reader U54BE 8673 8674// TryU54BE tries to read 54 bit unsigned integer in big-endian 8675func (d *D) TryU54BE() (uint64, error) { return d.tryUE(54, BigEndian) } 8676 8677// U54BE reads 54 bit unsigned integer in big-endian 8678func (d *D) U54BE() uint64 { 8679 v, err := d.tryUE(54, BigEndian) 8680 if err != nil { 8681 panic(IOError{Err: err, Op: "U54BE", Pos: d.Pos()}) 8682 } 8683 return v 8684} 8685 8686// TryFieldScalarU54BE tries to add a field and read 54 bit unsigned integer in big-endian 8687func (d *D) TryFieldScalarU54BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 8688 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 8689 v, err := d.tryUE(54, BigEndian) 8690 s.Actual = v 8691 return s, err 8692 }, sms...) 8693 if err != nil { 8694 return nil, err 8695 } 8696 return s, err 8697} 8698 8699// FieldScalarU54BE adds a field and reads 54 bit unsigned integer in big-endian 8700func (d *D) FieldScalarU54BE(name string, sms ...scalar.Mapper) *scalar.S { 8701 s, err := d.TryFieldScalarU54BE(name, sms...) 8702 if err != nil { 8703 panic(IOError{Err: err, Name: name, Op: "U54BE", Pos: d.Pos()}) 8704 } 8705 return s 8706} 8707 8708// TryFieldU54BE tries to add a field and read 54 bit unsigned integer in big-endian 8709func (d *D) TryFieldU54BE(name string, sms ...scalar.Mapper) (uint64, error) { 8710 s, err := d.TryFieldScalarU54BE(name, sms...) 8711 return s.ActualU(), err 8712} 8713 8714// FieldU54BE adds a field and reads 54 bit unsigned integer in big-endian 8715func (d *D) FieldU54BE(name string, sms ...scalar.Mapper) uint64 { 8716 return d.FieldScalarU54BE(name, sms...).ActualU() 8717} 8718 8719// Reader U55BE 8720 8721// TryU55BE tries to read 55 bit unsigned integer in big-endian 8722func (d *D) TryU55BE() (uint64, error) { return d.tryUE(55, BigEndian) } 8723 8724// U55BE reads 55 bit unsigned integer in big-endian 8725func (d *D) U55BE() uint64 { 8726 v, err := d.tryUE(55, BigEndian) 8727 if err != nil { 8728 panic(IOError{Err: err, Op: "U55BE", Pos: d.Pos()}) 8729 } 8730 return v 8731} 8732 8733// TryFieldScalarU55BE tries to add a field and read 55 bit unsigned integer in big-endian 8734func (d *D) TryFieldScalarU55BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 8735 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 8736 v, err := d.tryUE(55, BigEndian) 8737 s.Actual = v 8738 return s, err 8739 }, sms...) 8740 if err != nil { 8741 return nil, err 8742 } 8743 return s, err 8744} 8745 8746// FieldScalarU55BE adds a field and reads 55 bit unsigned integer in big-endian 8747func (d *D) FieldScalarU55BE(name string, sms ...scalar.Mapper) *scalar.S { 8748 s, err := d.TryFieldScalarU55BE(name, sms...) 8749 if err != nil { 8750 panic(IOError{Err: err, Name: name, Op: "U55BE", Pos: d.Pos()}) 8751 } 8752 return s 8753} 8754 8755// TryFieldU55BE tries to add a field and read 55 bit unsigned integer in big-endian 8756func (d *D) TryFieldU55BE(name string, sms ...scalar.Mapper) (uint64, error) { 8757 s, err := d.TryFieldScalarU55BE(name, sms...) 8758 return s.ActualU(), err 8759} 8760 8761// FieldU55BE adds a field and reads 55 bit unsigned integer in big-endian 8762func (d *D) FieldU55BE(name string, sms ...scalar.Mapper) uint64 { 8763 return d.FieldScalarU55BE(name, sms...).ActualU() 8764} 8765 8766// Reader U56BE 8767 8768// TryU56BE tries to read 56 bit unsigned integer in big-endian 8769func (d *D) TryU56BE() (uint64, error) { return d.tryUE(56, BigEndian) } 8770 8771// U56BE reads 56 bit unsigned integer in big-endian 8772func (d *D) U56BE() uint64 { 8773 v, err := d.tryUE(56, BigEndian) 8774 if err != nil { 8775 panic(IOError{Err: err, Op: "U56BE", Pos: d.Pos()}) 8776 } 8777 return v 8778} 8779 8780// TryFieldScalarU56BE tries to add a field and read 56 bit unsigned integer in big-endian 8781func (d *D) TryFieldScalarU56BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 8782 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 8783 v, err := d.tryUE(56, BigEndian) 8784 s.Actual = v 8785 return s, err 8786 }, sms...) 8787 if err != nil { 8788 return nil, err 8789 } 8790 return s, err 8791} 8792 8793// FieldScalarU56BE adds a field and reads 56 bit unsigned integer in big-endian 8794func (d *D) FieldScalarU56BE(name string, sms ...scalar.Mapper) *scalar.S { 8795 s, err := d.TryFieldScalarU56BE(name, sms...) 8796 if err != nil { 8797 panic(IOError{Err: err, Name: name, Op: "U56BE", Pos: d.Pos()}) 8798 } 8799 return s 8800} 8801 8802// TryFieldU56BE tries to add a field and read 56 bit unsigned integer in big-endian 8803func (d *D) TryFieldU56BE(name string, sms ...scalar.Mapper) (uint64, error) { 8804 s, err := d.TryFieldScalarU56BE(name, sms...) 8805 return s.ActualU(), err 8806} 8807 8808// FieldU56BE adds a field and reads 56 bit unsigned integer in big-endian 8809func (d *D) FieldU56BE(name string, sms ...scalar.Mapper) uint64 { 8810 return d.FieldScalarU56BE(name, sms...).ActualU() 8811} 8812 8813// Reader U57BE 8814 8815// TryU57BE tries to read 57 bit unsigned integer in big-endian 8816func (d *D) TryU57BE() (uint64, error) { return d.tryUE(57, BigEndian) } 8817 8818// U57BE reads 57 bit unsigned integer in big-endian 8819func (d *D) U57BE() uint64 { 8820 v, err := d.tryUE(57, BigEndian) 8821 if err != nil { 8822 panic(IOError{Err: err, Op: "U57BE", Pos: d.Pos()}) 8823 } 8824 return v 8825} 8826 8827// TryFieldScalarU57BE tries to add a field and read 57 bit unsigned integer in big-endian 8828func (d *D) TryFieldScalarU57BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 8829 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 8830 v, err := d.tryUE(57, BigEndian) 8831 s.Actual = v 8832 return s, err 8833 }, sms...) 8834 if err != nil { 8835 return nil, err 8836 } 8837 return s, err 8838} 8839 8840// FieldScalarU57BE adds a field and reads 57 bit unsigned integer in big-endian 8841func (d *D) FieldScalarU57BE(name string, sms ...scalar.Mapper) *scalar.S { 8842 s, err := d.TryFieldScalarU57BE(name, sms...) 8843 if err != nil { 8844 panic(IOError{Err: err, Name: name, Op: "U57BE", Pos: d.Pos()}) 8845 } 8846 return s 8847} 8848 8849// TryFieldU57BE tries to add a field and read 57 bit unsigned integer in big-endian 8850func (d *D) TryFieldU57BE(name string, sms ...scalar.Mapper) (uint64, error) { 8851 s, err := d.TryFieldScalarU57BE(name, sms...) 8852 return s.ActualU(), err 8853} 8854 8855// FieldU57BE adds a field and reads 57 bit unsigned integer in big-endian 8856func (d *D) FieldU57BE(name string, sms ...scalar.Mapper) uint64 { 8857 return d.FieldScalarU57BE(name, sms...).ActualU() 8858} 8859 8860// Reader U58BE 8861 8862// TryU58BE tries to read 58 bit unsigned integer in big-endian 8863func (d *D) TryU58BE() (uint64, error) { return d.tryUE(58, BigEndian) } 8864 8865// U58BE reads 58 bit unsigned integer in big-endian 8866func (d *D) U58BE() uint64 { 8867 v, err := d.tryUE(58, BigEndian) 8868 if err != nil { 8869 panic(IOError{Err: err, Op: "U58BE", Pos: d.Pos()}) 8870 } 8871 return v 8872} 8873 8874// TryFieldScalarU58BE tries to add a field and read 58 bit unsigned integer in big-endian 8875func (d *D) TryFieldScalarU58BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 8876 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 8877 v, err := d.tryUE(58, BigEndian) 8878 s.Actual = v 8879 return s, err 8880 }, sms...) 8881 if err != nil { 8882 return nil, err 8883 } 8884 return s, err 8885} 8886 8887// FieldScalarU58BE adds a field and reads 58 bit unsigned integer in big-endian 8888func (d *D) FieldScalarU58BE(name string, sms ...scalar.Mapper) *scalar.S { 8889 s, err := d.TryFieldScalarU58BE(name, sms...) 8890 if err != nil { 8891 panic(IOError{Err: err, Name: name, Op: "U58BE", Pos: d.Pos()}) 8892 } 8893 return s 8894} 8895 8896// TryFieldU58BE tries to add a field and read 58 bit unsigned integer in big-endian 8897func (d *D) TryFieldU58BE(name string, sms ...scalar.Mapper) (uint64, error) { 8898 s, err := d.TryFieldScalarU58BE(name, sms...) 8899 return s.ActualU(), err 8900} 8901 8902// FieldU58BE adds a field and reads 58 bit unsigned integer in big-endian 8903func (d *D) FieldU58BE(name string, sms ...scalar.Mapper) uint64 { 8904 return d.FieldScalarU58BE(name, sms...).ActualU() 8905} 8906 8907// Reader U59BE 8908 8909// TryU59BE tries to read 59 bit unsigned integer in big-endian 8910func (d *D) TryU59BE() (uint64, error) { return d.tryUE(59, BigEndian) } 8911 8912// U59BE reads 59 bit unsigned integer in big-endian 8913func (d *D) U59BE() uint64 { 8914 v, err := d.tryUE(59, BigEndian) 8915 if err != nil { 8916 panic(IOError{Err: err, Op: "U59BE", Pos: d.Pos()}) 8917 } 8918 return v 8919} 8920 8921// TryFieldScalarU59BE tries to add a field and read 59 bit unsigned integer in big-endian 8922func (d *D) TryFieldScalarU59BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 8923 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 8924 v, err := d.tryUE(59, BigEndian) 8925 s.Actual = v 8926 return s, err 8927 }, sms...) 8928 if err != nil { 8929 return nil, err 8930 } 8931 return s, err 8932} 8933 8934// FieldScalarU59BE adds a field and reads 59 bit unsigned integer in big-endian 8935func (d *D) FieldScalarU59BE(name string, sms ...scalar.Mapper) *scalar.S { 8936 s, err := d.TryFieldScalarU59BE(name, sms...) 8937 if err != nil { 8938 panic(IOError{Err: err, Name: name, Op: "U59BE", Pos: d.Pos()}) 8939 } 8940 return s 8941} 8942 8943// TryFieldU59BE tries to add a field and read 59 bit unsigned integer in big-endian 8944func (d *D) TryFieldU59BE(name string, sms ...scalar.Mapper) (uint64, error) { 8945 s, err := d.TryFieldScalarU59BE(name, sms...) 8946 return s.ActualU(), err 8947} 8948 8949// FieldU59BE adds a field and reads 59 bit unsigned integer in big-endian 8950func (d *D) FieldU59BE(name string, sms ...scalar.Mapper) uint64 { 8951 return d.FieldScalarU59BE(name, sms...).ActualU() 8952} 8953 8954// Reader U60BE 8955 8956// TryU60BE tries to read 60 bit unsigned integer in big-endian 8957func (d *D) TryU60BE() (uint64, error) { return d.tryUE(60, BigEndian) } 8958 8959// U60BE reads 60 bit unsigned integer in big-endian 8960func (d *D) U60BE() uint64 { 8961 v, err := d.tryUE(60, BigEndian) 8962 if err != nil { 8963 panic(IOError{Err: err, Op: "U60BE", Pos: d.Pos()}) 8964 } 8965 return v 8966} 8967 8968// TryFieldScalarU60BE tries to add a field and read 60 bit unsigned integer in big-endian 8969func (d *D) TryFieldScalarU60BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 8970 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 8971 v, err := d.tryUE(60, BigEndian) 8972 s.Actual = v 8973 return s, err 8974 }, sms...) 8975 if err != nil { 8976 return nil, err 8977 } 8978 return s, err 8979} 8980 8981// FieldScalarU60BE adds a field and reads 60 bit unsigned integer in big-endian 8982func (d *D) FieldScalarU60BE(name string, sms ...scalar.Mapper) *scalar.S { 8983 s, err := d.TryFieldScalarU60BE(name, sms...) 8984 if err != nil { 8985 panic(IOError{Err: err, Name: name, Op: "U60BE", Pos: d.Pos()}) 8986 } 8987 return s 8988} 8989 8990// TryFieldU60BE tries to add a field and read 60 bit unsigned integer in big-endian 8991func (d *D) TryFieldU60BE(name string, sms ...scalar.Mapper) (uint64, error) { 8992 s, err := d.TryFieldScalarU60BE(name, sms...) 8993 return s.ActualU(), err 8994} 8995 8996// FieldU60BE adds a field and reads 60 bit unsigned integer in big-endian 8997func (d *D) FieldU60BE(name string, sms ...scalar.Mapper) uint64 { 8998 return d.FieldScalarU60BE(name, sms...).ActualU() 8999} 9000 9001// Reader U61BE 9002 9003// TryU61BE tries to read 61 bit unsigned integer in big-endian 9004func (d *D) TryU61BE() (uint64, error) { return d.tryUE(61, BigEndian) } 9005 9006// U61BE reads 61 bit unsigned integer in big-endian 9007func (d *D) U61BE() uint64 { 9008 v, err := d.tryUE(61, BigEndian) 9009 if err != nil { 9010 panic(IOError{Err: err, Op: "U61BE", Pos: d.Pos()}) 9011 } 9012 return v 9013} 9014 9015// TryFieldScalarU61BE tries to add a field and read 61 bit unsigned integer in big-endian 9016func (d *D) TryFieldScalarU61BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 9017 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 9018 v, err := d.tryUE(61, BigEndian) 9019 s.Actual = v 9020 return s, err 9021 }, sms...) 9022 if err != nil { 9023 return nil, err 9024 } 9025 return s, err 9026} 9027 9028// FieldScalarU61BE adds a field and reads 61 bit unsigned integer in big-endian 9029func (d *D) FieldScalarU61BE(name string, sms ...scalar.Mapper) *scalar.S { 9030 s, err := d.TryFieldScalarU61BE(name, sms...) 9031 if err != nil { 9032 panic(IOError{Err: err, Name: name, Op: "U61BE", Pos: d.Pos()}) 9033 } 9034 return s 9035} 9036 9037// TryFieldU61BE tries to add a field and read 61 bit unsigned integer in big-endian 9038func (d *D) TryFieldU61BE(name string, sms ...scalar.Mapper) (uint64, error) { 9039 s, err := d.TryFieldScalarU61BE(name, sms...) 9040 return s.ActualU(), err 9041} 9042 9043// FieldU61BE adds a field and reads 61 bit unsigned integer in big-endian 9044func (d *D) FieldU61BE(name string, sms ...scalar.Mapper) uint64 { 9045 return d.FieldScalarU61BE(name, sms...).ActualU() 9046} 9047 9048// Reader U62BE 9049 9050// TryU62BE tries to read 62 bit unsigned integer in big-endian 9051func (d *D) TryU62BE() (uint64, error) { return d.tryUE(62, BigEndian) } 9052 9053// U62BE reads 62 bit unsigned integer in big-endian 9054func (d *D) U62BE() uint64 { 9055 v, err := d.tryUE(62, BigEndian) 9056 if err != nil { 9057 panic(IOError{Err: err, Op: "U62BE", Pos: d.Pos()}) 9058 } 9059 return v 9060} 9061 9062// TryFieldScalarU62BE tries to add a field and read 62 bit unsigned integer in big-endian 9063func (d *D) TryFieldScalarU62BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 9064 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 9065 v, err := d.tryUE(62, BigEndian) 9066 s.Actual = v 9067 return s, err 9068 }, sms...) 9069 if err != nil { 9070 return nil, err 9071 } 9072 return s, err 9073} 9074 9075// FieldScalarU62BE adds a field and reads 62 bit unsigned integer in big-endian 9076func (d *D) FieldScalarU62BE(name string, sms ...scalar.Mapper) *scalar.S { 9077 s, err := d.TryFieldScalarU62BE(name, sms...) 9078 if err != nil { 9079 panic(IOError{Err: err, Name: name, Op: "U62BE", Pos: d.Pos()}) 9080 } 9081 return s 9082} 9083 9084// TryFieldU62BE tries to add a field and read 62 bit unsigned integer in big-endian 9085func (d *D) TryFieldU62BE(name string, sms ...scalar.Mapper) (uint64, error) { 9086 s, err := d.TryFieldScalarU62BE(name, sms...) 9087 return s.ActualU(), err 9088} 9089 9090// FieldU62BE adds a field and reads 62 bit unsigned integer in big-endian 9091func (d *D) FieldU62BE(name string, sms ...scalar.Mapper) uint64 { 9092 return d.FieldScalarU62BE(name, sms...).ActualU() 9093} 9094 9095// Reader U63BE 9096 9097// TryU63BE tries to read 63 bit unsigned integer in big-endian 9098func (d *D) TryU63BE() (uint64, error) { return d.tryUE(63, BigEndian) } 9099 9100// U63BE reads 63 bit unsigned integer in big-endian 9101func (d *D) U63BE() uint64 { 9102 v, err := d.tryUE(63, BigEndian) 9103 if err != nil { 9104 panic(IOError{Err: err, Op: "U63BE", Pos: d.Pos()}) 9105 } 9106 return v 9107} 9108 9109// TryFieldScalarU63BE tries to add a field and read 63 bit unsigned integer in big-endian 9110func (d *D) TryFieldScalarU63BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 9111 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 9112 v, err := d.tryUE(63, BigEndian) 9113 s.Actual = v 9114 return s, err 9115 }, sms...) 9116 if err != nil { 9117 return nil, err 9118 } 9119 return s, err 9120} 9121 9122// FieldScalarU63BE adds a field and reads 63 bit unsigned integer in big-endian 9123func (d *D) FieldScalarU63BE(name string, sms ...scalar.Mapper) *scalar.S { 9124 s, err := d.TryFieldScalarU63BE(name, sms...) 9125 if err != nil { 9126 panic(IOError{Err: err, Name: name, Op: "U63BE", Pos: d.Pos()}) 9127 } 9128 return s 9129} 9130 9131// TryFieldU63BE tries to add a field and read 63 bit unsigned integer in big-endian 9132func (d *D) TryFieldU63BE(name string, sms ...scalar.Mapper) (uint64, error) { 9133 s, err := d.TryFieldScalarU63BE(name, sms...) 9134 return s.ActualU(), err 9135} 9136 9137// FieldU63BE adds a field and reads 63 bit unsigned integer in big-endian 9138func (d *D) FieldU63BE(name string, sms ...scalar.Mapper) uint64 { 9139 return d.FieldScalarU63BE(name, sms...).ActualU() 9140} 9141 9142// Reader U64BE 9143 9144// TryU64BE tries to read 64 bit unsigned integer in big-endian 9145func (d *D) TryU64BE() (uint64, error) { return d.tryUE(64, BigEndian) } 9146 9147// U64BE reads 64 bit unsigned integer in big-endian 9148func (d *D) U64BE() uint64 { 9149 v, err := d.tryUE(64, BigEndian) 9150 if err != nil { 9151 panic(IOError{Err: err, Op: "U64BE", Pos: d.Pos()}) 9152 } 9153 return v 9154} 9155 9156// TryFieldScalarU64BE tries to add a field and read 64 bit unsigned integer in big-endian 9157func (d *D) TryFieldScalarU64BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 9158 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 9159 v, err := d.tryUE(64, BigEndian) 9160 s.Actual = v 9161 return s, err 9162 }, sms...) 9163 if err != nil { 9164 return nil, err 9165 } 9166 return s, err 9167} 9168 9169// FieldScalarU64BE adds a field and reads 64 bit unsigned integer in big-endian 9170func (d *D) FieldScalarU64BE(name string, sms ...scalar.Mapper) *scalar.S { 9171 s, err := d.TryFieldScalarU64BE(name, sms...) 9172 if err != nil { 9173 panic(IOError{Err: err, Name: name, Op: "U64BE", Pos: d.Pos()}) 9174 } 9175 return s 9176} 9177 9178// TryFieldU64BE tries to add a field and read 64 bit unsigned integer in big-endian 9179func (d *D) TryFieldU64BE(name string, sms ...scalar.Mapper) (uint64, error) { 9180 s, err := d.TryFieldScalarU64BE(name, sms...) 9181 return s.ActualU(), err 9182} 9183 9184// FieldU64BE adds a field and reads 64 bit unsigned integer in big-endian 9185func (d *D) FieldU64BE(name string, sms ...scalar.Mapper) uint64 { 9186 return d.FieldScalarU64BE(name, sms...).ActualU() 9187} 9188 9189// Reader S 9190 9191// TryS tries to read nBits bits signed integer in current endian 9192func (d *D) TryS(nBits int) (int64, error) { return d.trySE(nBits, d.Endian) } 9193 9194// S reads nBits bits signed integer in current endian 9195func (d *D) S(nBits int) int64 { 9196 v, err := d.trySE(nBits, d.Endian) 9197 if err != nil { 9198 panic(IOError{Err: err, Op: "S", Pos: d.Pos()}) 9199 } 9200 return v 9201} 9202 9203// TryFieldScalarS tries to add a field and read nBits bits signed integer in current endian 9204func (d *D) TryFieldScalarS(name string, nBits int, sms ...scalar.Mapper) (*scalar.S, error) { 9205 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 9206 v, err := d.trySE(nBits, d.Endian) 9207 s.Actual = v 9208 return s, err 9209 }, sms...) 9210 if err != nil { 9211 return nil, err 9212 } 9213 return s, err 9214} 9215 9216// FieldScalarS adds a field and reads nBits bits signed integer in current endian 9217func (d *D) FieldScalarS(name string, nBits int, sms ...scalar.Mapper) *scalar.S { 9218 s, err := d.TryFieldScalarS(name, nBits, sms...) 9219 if err != nil { 9220 panic(IOError{Err: err, Name: name, Op: "S", Pos: d.Pos()}) 9221 } 9222 return s 9223} 9224 9225// TryFieldS tries to add a field and read nBits bits signed integer in current endian 9226func (d *D) TryFieldS(name string, nBits int, sms ...scalar.Mapper) (int64, error) { 9227 s, err := d.TryFieldScalarS(name, nBits, sms...) 9228 return s.ActualS(), err 9229} 9230 9231// FieldS adds a field and reads nBits bits signed integer in current endian 9232func (d *D) FieldS(name string, nBits int, sms ...scalar.Mapper) int64 { 9233 return d.FieldScalarS(name, nBits, sms...).ActualS() 9234} 9235 9236// Reader SE 9237 9238// TrySE tries to read nBits signed integer in specified endian 9239func (d *D) TrySE(nBits int, endian Endian) (int64, error) { return d.trySE(nBits, endian) } 9240 9241// SE reads nBits signed integer in specified endian 9242func (d *D) SE(nBits int, endian Endian) int64 { 9243 v, err := d.trySE(nBits, endian) 9244 if err != nil { 9245 panic(IOError{Err: err, Op: "SE", Pos: d.Pos()}) 9246 } 9247 return v 9248} 9249 9250// TryFieldScalarSE tries to add a field and read nBits signed integer in specified endian 9251func (d *D) TryFieldScalarSE(name string, nBits int, endian Endian, sms ...scalar.Mapper) (*scalar.S, error) { 9252 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 9253 v, err := d.trySE(nBits, endian) 9254 s.Actual = v 9255 return s, err 9256 }, sms...) 9257 if err != nil { 9258 return nil, err 9259 } 9260 return s, err 9261} 9262 9263// FieldScalarSE adds a field and reads nBits signed integer in specified endian 9264func (d *D) FieldScalarSE(name string, nBits int, endian Endian, sms ...scalar.Mapper) *scalar.S { 9265 s, err := d.TryFieldScalarSE(name, nBits, endian, sms...) 9266 if err != nil { 9267 panic(IOError{Err: err, Name: name, Op: "SE", Pos: d.Pos()}) 9268 } 9269 return s 9270} 9271 9272// TryFieldSE tries to add a field and read nBits signed integer in specified endian 9273func (d *D) TryFieldSE(name string, nBits int, endian Endian, sms ...scalar.Mapper) (int64, error) { 9274 s, err := d.TryFieldScalarSE(name, nBits, endian, sms...) 9275 return s.ActualS(), err 9276} 9277 9278// FieldSE adds a field and reads nBits signed integer in specified endian 9279func (d *D) FieldSE(name string, nBits int, endian Endian, sms ...scalar.Mapper) int64 { 9280 return d.FieldScalarSE(name, nBits, endian, sms...).ActualS() 9281} 9282 9283// Reader S1 9284 9285// TryS1 tries to read 1 bit signed integer in current endian 9286func (d *D) TryS1() (int64, error) { return d.trySE(1, d.Endian) } 9287 9288// S1 reads 1 bit signed integer in current endian 9289func (d *D) S1() int64 { 9290 v, err := d.trySE(1, d.Endian) 9291 if err != nil { 9292 panic(IOError{Err: err, Op: "S1", Pos: d.Pos()}) 9293 } 9294 return v 9295} 9296 9297// TryFieldScalarS1 tries to add a field and read 1 bit signed integer in current endian 9298func (d *D) TryFieldScalarS1(name string, sms ...scalar.Mapper) (*scalar.S, error) { 9299 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 9300 v, err := d.trySE(1, d.Endian) 9301 s.Actual = v 9302 return s, err 9303 }, sms...) 9304 if err != nil { 9305 return nil, err 9306 } 9307 return s, err 9308} 9309 9310// FieldScalarS1 adds a field and reads 1 bit signed integer in current endian 9311func (d *D) FieldScalarS1(name string, sms ...scalar.Mapper) *scalar.S { 9312 s, err := d.TryFieldScalarS1(name, sms...) 9313 if err != nil { 9314 panic(IOError{Err: err, Name: name, Op: "S1", Pos: d.Pos()}) 9315 } 9316 return s 9317} 9318 9319// TryFieldS1 tries to add a field and read 1 bit signed integer in current endian 9320func (d *D) TryFieldS1(name string, sms ...scalar.Mapper) (int64, error) { 9321 s, err := d.TryFieldScalarS1(name, sms...) 9322 return s.ActualS(), err 9323} 9324 9325// FieldS1 adds a field and reads 1 bit signed integer in current endian 9326func (d *D) FieldS1(name string, sms ...scalar.Mapper) int64 { 9327 return d.FieldScalarS1(name, sms...).ActualS() 9328} 9329 9330// Reader S2 9331 9332// TryS2 tries to read 2 bit signed integer in current endian 9333func (d *D) TryS2() (int64, error) { return d.trySE(2, d.Endian) } 9334 9335// S2 reads 2 bit signed integer in current endian 9336func (d *D) S2() int64 { 9337 v, err := d.trySE(2, d.Endian) 9338 if err != nil { 9339 panic(IOError{Err: err, Op: "S2", Pos: d.Pos()}) 9340 } 9341 return v 9342} 9343 9344// TryFieldScalarS2 tries to add a field and read 2 bit signed integer in current endian 9345func (d *D) TryFieldScalarS2(name string, sms ...scalar.Mapper) (*scalar.S, error) { 9346 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 9347 v, err := d.trySE(2, d.Endian) 9348 s.Actual = v 9349 return s, err 9350 }, sms...) 9351 if err != nil { 9352 return nil, err 9353 } 9354 return s, err 9355} 9356 9357// FieldScalarS2 adds a field and reads 2 bit signed integer in current endian 9358func (d *D) FieldScalarS2(name string, sms ...scalar.Mapper) *scalar.S { 9359 s, err := d.TryFieldScalarS2(name, sms...) 9360 if err != nil { 9361 panic(IOError{Err: err, Name: name, Op: "S2", Pos: d.Pos()}) 9362 } 9363 return s 9364} 9365 9366// TryFieldS2 tries to add a field and read 2 bit signed integer in current endian 9367func (d *D) TryFieldS2(name string, sms ...scalar.Mapper) (int64, error) { 9368 s, err := d.TryFieldScalarS2(name, sms...) 9369 return s.ActualS(), err 9370} 9371 9372// FieldS2 adds a field and reads 2 bit signed integer in current endian 9373func (d *D) FieldS2(name string, sms ...scalar.Mapper) int64 { 9374 return d.FieldScalarS2(name, sms...).ActualS() 9375} 9376 9377// Reader S3 9378 9379// TryS3 tries to read 3 bit signed integer in current endian 9380func (d *D) TryS3() (int64, error) { return d.trySE(3, d.Endian) } 9381 9382// S3 reads 3 bit signed integer in current endian 9383func (d *D) S3() int64 { 9384 v, err := d.trySE(3, d.Endian) 9385 if err != nil { 9386 panic(IOError{Err: err, Op: "S3", Pos: d.Pos()}) 9387 } 9388 return v 9389} 9390 9391// TryFieldScalarS3 tries to add a field and read 3 bit signed integer in current endian 9392func (d *D) TryFieldScalarS3(name string, sms ...scalar.Mapper) (*scalar.S, error) { 9393 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 9394 v, err := d.trySE(3, d.Endian) 9395 s.Actual = v 9396 return s, err 9397 }, sms...) 9398 if err != nil { 9399 return nil, err 9400 } 9401 return s, err 9402} 9403 9404// FieldScalarS3 adds a field and reads 3 bit signed integer in current endian 9405func (d *D) FieldScalarS3(name string, sms ...scalar.Mapper) *scalar.S { 9406 s, err := d.TryFieldScalarS3(name, sms...) 9407 if err != nil { 9408 panic(IOError{Err: err, Name: name, Op: "S3", Pos: d.Pos()}) 9409 } 9410 return s 9411} 9412 9413// TryFieldS3 tries to add a field and read 3 bit signed integer in current endian 9414func (d *D) TryFieldS3(name string, sms ...scalar.Mapper) (int64, error) { 9415 s, err := d.TryFieldScalarS3(name, sms...) 9416 return s.ActualS(), err 9417} 9418 9419// FieldS3 adds a field and reads 3 bit signed integer in current endian 9420func (d *D) FieldS3(name string, sms ...scalar.Mapper) int64 { 9421 return d.FieldScalarS3(name, sms...).ActualS() 9422} 9423 9424// Reader S4 9425 9426// TryS4 tries to read 4 bit signed integer in current endian 9427func (d *D) TryS4() (int64, error) { return d.trySE(4, d.Endian) } 9428 9429// S4 reads 4 bit signed integer in current endian 9430func (d *D) S4() int64 { 9431 v, err := d.trySE(4, d.Endian) 9432 if err != nil { 9433 panic(IOError{Err: err, Op: "S4", Pos: d.Pos()}) 9434 } 9435 return v 9436} 9437 9438// TryFieldScalarS4 tries to add a field and read 4 bit signed integer in current endian 9439func (d *D) TryFieldScalarS4(name string, sms ...scalar.Mapper) (*scalar.S, error) { 9440 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 9441 v, err := d.trySE(4, d.Endian) 9442 s.Actual = v 9443 return s, err 9444 }, sms...) 9445 if err != nil { 9446 return nil, err 9447 } 9448 return s, err 9449} 9450 9451// FieldScalarS4 adds a field and reads 4 bit signed integer in current endian 9452func (d *D) FieldScalarS4(name string, sms ...scalar.Mapper) *scalar.S { 9453 s, err := d.TryFieldScalarS4(name, sms...) 9454 if err != nil { 9455 panic(IOError{Err: err, Name: name, Op: "S4", Pos: d.Pos()}) 9456 } 9457 return s 9458} 9459 9460// TryFieldS4 tries to add a field and read 4 bit signed integer in current endian 9461func (d *D) TryFieldS4(name string, sms ...scalar.Mapper) (int64, error) { 9462 s, err := d.TryFieldScalarS4(name, sms...) 9463 return s.ActualS(), err 9464} 9465 9466// FieldS4 adds a field and reads 4 bit signed integer in current endian 9467func (d *D) FieldS4(name string, sms ...scalar.Mapper) int64 { 9468 return d.FieldScalarS4(name, sms...).ActualS() 9469} 9470 9471// Reader S5 9472 9473// TryS5 tries to read 5 bit signed integer in current endian 9474func (d *D) TryS5() (int64, error) { return d.trySE(5, d.Endian) } 9475 9476// S5 reads 5 bit signed integer in current endian 9477func (d *D) S5() int64 { 9478 v, err := d.trySE(5, d.Endian) 9479 if err != nil { 9480 panic(IOError{Err: err, Op: "S5", Pos: d.Pos()}) 9481 } 9482 return v 9483} 9484 9485// TryFieldScalarS5 tries to add a field and read 5 bit signed integer in current endian 9486func (d *D) TryFieldScalarS5(name string, sms ...scalar.Mapper) (*scalar.S, error) { 9487 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 9488 v, err := d.trySE(5, d.Endian) 9489 s.Actual = v 9490 return s, err 9491 }, sms...) 9492 if err != nil { 9493 return nil, err 9494 } 9495 return s, err 9496} 9497 9498// FieldScalarS5 adds a field and reads 5 bit signed integer in current endian 9499func (d *D) FieldScalarS5(name string, sms ...scalar.Mapper) *scalar.S { 9500 s, err := d.TryFieldScalarS5(name, sms...) 9501 if err != nil { 9502 panic(IOError{Err: err, Name: name, Op: "S5", Pos: d.Pos()}) 9503 } 9504 return s 9505} 9506 9507// TryFieldS5 tries to add a field and read 5 bit signed integer in current endian 9508func (d *D) TryFieldS5(name string, sms ...scalar.Mapper) (int64, error) { 9509 s, err := d.TryFieldScalarS5(name, sms...) 9510 return s.ActualS(), err 9511} 9512 9513// FieldS5 adds a field and reads 5 bit signed integer in current endian 9514func (d *D) FieldS5(name string, sms ...scalar.Mapper) int64 { 9515 return d.FieldScalarS5(name, sms...).ActualS() 9516} 9517 9518// Reader S6 9519 9520// TryS6 tries to read 6 bit signed integer in current endian 9521func (d *D) TryS6() (int64, error) { return d.trySE(6, d.Endian) } 9522 9523// S6 reads 6 bit signed integer in current endian 9524func (d *D) S6() int64 { 9525 v, err := d.trySE(6, d.Endian) 9526 if err != nil { 9527 panic(IOError{Err: err, Op: "S6", Pos: d.Pos()}) 9528 } 9529 return v 9530} 9531 9532// TryFieldScalarS6 tries to add a field and read 6 bit signed integer in current endian 9533func (d *D) TryFieldScalarS6(name string, sms ...scalar.Mapper) (*scalar.S, error) { 9534 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 9535 v, err := d.trySE(6, d.Endian) 9536 s.Actual = v 9537 return s, err 9538 }, sms...) 9539 if err != nil { 9540 return nil, err 9541 } 9542 return s, err 9543} 9544 9545// FieldScalarS6 adds a field and reads 6 bit signed integer in current endian 9546func (d *D) FieldScalarS6(name string, sms ...scalar.Mapper) *scalar.S { 9547 s, err := d.TryFieldScalarS6(name, sms...) 9548 if err != nil { 9549 panic(IOError{Err: err, Name: name, Op: "S6", Pos: d.Pos()}) 9550 } 9551 return s 9552} 9553 9554// TryFieldS6 tries to add a field and read 6 bit signed integer in current endian 9555func (d *D) TryFieldS6(name string, sms ...scalar.Mapper) (int64, error) { 9556 s, err := d.TryFieldScalarS6(name, sms...) 9557 return s.ActualS(), err 9558} 9559 9560// FieldS6 adds a field and reads 6 bit signed integer in current endian 9561func (d *D) FieldS6(name string, sms ...scalar.Mapper) int64 { 9562 return d.FieldScalarS6(name, sms...).ActualS() 9563} 9564 9565// Reader S7 9566 9567// TryS7 tries to read 7 bit signed integer in current endian 9568func (d *D) TryS7() (int64, error) { return d.trySE(7, d.Endian) } 9569 9570// S7 reads 7 bit signed integer in current endian 9571func (d *D) S7() int64 { 9572 v, err := d.trySE(7, d.Endian) 9573 if err != nil { 9574 panic(IOError{Err: err, Op: "S7", Pos: d.Pos()}) 9575 } 9576 return v 9577} 9578 9579// TryFieldScalarS7 tries to add a field and read 7 bit signed integer in current endian 9580func (d *D) TryFieldScalarS7(name string, sms ...scalar.Mapper) (*scalar.S, error) { 9581 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 9582 v, err := d.trySE(7, d.Endian) 9583 s.Actual = v 9584 return s, err 9585 }, sms...) 9586 if err != nil { 9587 return nil, err 9588 } 9589 return s, err 9590} 9591 9592// FieldScalarS7 adds a field and reads 7 bit signed integer in current endian 9593func (d *D) FieldScalarS7(name string, sms ...scalar.Mapper) *scalar.S { 9594 s, err := d.TryFieldScalarS7(name, sms...) 9595 if err != nil { 9596 panic(IOError{Err: err, Name: name, Op: "S7", Pos: d.Pos()}) 9597 } 9598 return s 9599} 9600 9601// TryFieldS7 tries to add a field and read 7 bit signed integer in current endian 9602func (d *D) TryFieldS7(name string, sms ...scalar.Mapper) (int64, error) { 9603 s, err := d.TryFieldScalarS7(name, sms...) 9604 return s.ActualS(), err 9605} 9606 9607// FieldS7 adds a field and reads 7 bit signed integer in current endian 9608func (d *D) FieldS7(name string, sms ...scalar.Mapper) int64 { 9609 return d.FieldScalarS7(name, sms...).ActualS() 9610} 9611 9612// Reader S8 9613 9614// TryS8 tries to read 8 bit signed integer in current endian 9615func (d *D) TryS8() (int64, error) { return d.trySE(8, d.Endian) } 9616 9617// S8 reads 8 bit signed integer in current endian 9618func (d *D) S8() int64 { 9619 v, err := d.trySE(8, d.Endian) 9620 if err != nil { 9621 panic(IOError{Err: err, Op: "S8", Pos: d.Pos()}) 9622 } 9623 return v 9624} 9625 9626// TryFieldScalarS8 tries to add a field and read 8 bit signed integer in current endian 9627func (d *D) TryFieldScalarS8(name string, sms ...scalar.Mapper) (*scalar.S, error) { 9628 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 9629 v, err := d.trySE(8, d.Endian) 9630 s.Actual = v 9631 return s, err 9632 }, sms...) 9633 if err != nil { 9634 return nil, err 9635 } 9636 return s, err 9637} 9638 9639// FieldScalarS8 adds a field and reads 8 bit signed integer in current endian 9640func (d *D) FieldScalarS8(name string, sms ...scalar.Mapper) *scalar.S { 9641 s, err := d.TryFieldScalarS8(name, sms...) 9642 if err != nil { 9643 panic(IOError{Err: err, Name: name, Op: "S8", Pos: d.Pos()}) 9644 } 9645 return s 9646} 9647 9648// TryFieldS8 tries to add a field and read 8 bit signed integer in current endian 9649func (d *D) TryFieldS8(name string, sms ...scalar.Mapper) (int64, error) { 9650 s, err := d.TryFieldScalarS8(name, sms...) 9651 return s.ActualS(), err 9652} 9653 9654// FieldS8 adds a field and reads 8 bit signed integer in current endian 9655func (d *D) FieldS8(name string, sms ...scalar.Mapper) int64 { 9656 return d.FieldScalarS8(name, sms...).ActualS() 9657} 9658 9659// Reader S9 9660 9661// TryS9 tries to read 9 bit signed integer in current endian 9662func (d *D) TryS9() (int64, error) { return d.trySE(9, d.Endian) } 9663 9664// S9 reads 9 bit signed integer in current endian 9665func (d *D) S9() int64 { 9666 v, err := d.trySE(9, d.Endian) 9667 if err != nil { 9668 panic(IOError{Err: err, Op: "S9", Pos: d.Pos()}) 9669 } 9670 return v 9671} 9672 9673// TryFieldScalarS9 tries to add a field and read 9 bit signed integer in current endian 9674func (d *D) TryFieldScalarS9(name string, sms ...scalar.Mapper) (*scalar.S, error) { 9675 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 9676 v, err := d.trySE(9, d.Endian) 9677 s.Actual = v 9678 return s, err 9679 }, sms...) 9680 if err != nil { 9681 return nil, err 9682 } 9683 return s, err 9684} 9685 9686// FieldScalarS9 adds a field and reads 9 bit signed integer in current endian 9687func (d *D) FieldScalarS9(name string, sms ...scalar.Mapper) *scalar.S { 9688 s, err := d.TryFieldScalarS9(name, sms...) 9689 if err != nil { 9690 panic(IOError{Err: err, Name: name, Op: "S9", Pos: d.Pos()}) 9691 } 9692 return s 9693} 9694 9695// TryFieldS9 tries to add a field and read 9 bit signed integer in current endian 9696func (d *D) TryFieldS9(name string, sms ...scalar.Mapper) (int64, error) { 9697 s, err := d.TryFieldScalarS9(name, sms...) 9698 return s.ActualS(), err 9699} 9700 9701// FieldS9 adds a field and reads 9 bit signed integer in current endian 9702func (d *D) FieldS9(name string, sms ...scalar.Mapper) int64 { 9703 return d.FieldScalarS9(name, sms...).ActualS() 9704} 9705 9706// Reader S10 9707 9708// TryS10 tries to read 10 bit signed integer in current endian 9709func (d *D) TryS10() (int64, error) { return d.trySE(10, d.Endian) } 9710 9711// S10 reads 10 bit signed integer in current endian 9712func (d *D) S10() int64 { 9713 v, err := d.trySE(10, d.Endian) 9714 if err != nil { 9715 panic(IOError{Err: err, Op: "S10", Pos: d.Pos()}) 9716 } 9717 return v 9718} 9719 9720// TryFieldScalarS10 tries to add a field and read 10 bit signed integer in current endian 9721func (d *D) TryFieldScalarS10(name string, sms ...scalar.Mapper) (*scalar.S, error) { 9722 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 9723 v, err := d.trySE(10, d.Endian) 9724 s.Actual = v 9725 return s, err 9726 }, sms...) 9727 if err != nil { 9728 return nil, err 9729 } 9730 return s, err 9731} 9732 9733// FieldScalarS10 adds a field and reads 10 bit signed integer in current endian 9734func (d *D) FieldScalarS10(name string, sms ...scalar.Mapper) *scalar.S { 9735 s, err := d.TryFieldScalarS10(name, sms...) 9736 if err != nil { 9737 panic(IOError{Err: err, Name: name, Op: "S10", Pos: d.Pos()}) 9738 } 9739 return s 9740} 9741 9742// TryFieldS10 tries to add a field and read 10 bit signed integer in current endian 9743func (d *D) TryFieldS10(name string, sms ...scalar.Mapper) (int64, error) { 9744 s, err := d.TryFieldScalarS10(name, sms...) 9745 return s.ActualS(), err 9746} 9747 9748// FieldS10 adds a field and reads 10 bit signed integer in current endian 9749func (d *D) FieldS10(name string, sms ...scalar.Mapper) int64 { 9750 return d.FieldScalarS10(name, sms...).ActualS() 9751} 9752 9753// Reader S11 9754 9755// TryS11 tries to read 11 bit signed integer in current endian 9756func (d *D) TryS11() (int64, error) { return d.trySE(11, d.Endian) } 9757 9758// S11 reads 11 bit signed integer in current endian 9759func (d *D) S11() int64 { 9760 v, err := d.trySE(11, d.Endian) 9761 if err != nil { 9762 panic(IOError{Err: err, Op: "S11", Pos: d.Pos()}) 9763 } 9764 return v 9765} 9766 9767// TryFieldScalarS11 tries to add a field and read 11 bit signed integer in current endian 9768func (d *D) TryFieldScalarS11(name string, sms ...scalar.Mapper) (*scalar.S, error) { 9769 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 9770 v, err := d.trySE(11, d.Endian) 9771 s.Actual = v 9772 return s, err 9773 }, sms...) 9774 if err != nil { 9775 return nil, err 9776 } 9777 return s, err 9778} 9779 9780// FieldScalarS11 adds a field and reads 11 bit signed integer in current endian 9781func (d *D) FieldScalarS11(name string, sms ...scalar.Mapper) *scalar.S { 9782 s, err := d.TryFieldScalarS11(name, sms...) 9783 if err != nil { 9784 panic(IOError{Err: err, Name: name, Op: "S11", Pos: d.Pos()}) 9785 } 9786 return s 9787} 9788 9789// TryFieldS11 tries to add a field and read 11 bit signed integer in current endian 9790func (d *D) TryFieldS11(name string, sms ...scalar.Mapper) (int64, error) { 9791 s, err := d.TryFieldScalarS11(name, sms...) 9792 return s.ActualS(), err 9793} 9794 9795// FieldS11 adds a field and reads 11 bit signed integer in current endian 9796func (d *D) FieldS11(name string, sms ...scalar.Mapper) int64 { 9797 return d.FieldScalarS11(name, sms...).ActualS() 9798} 9799 9800// Reader S12 9801 9802// TryS12 tries to read 12 bit signed integer in current endian 9803func (d *D) TryS12() (int64, error) { return d.trySE(12, d.Endian) } 9804 9805// S12 reads 12 bit signed integer in current endian 9806func (d *D) S12() int64 { 9807 v, err := d.trySE(12, d.Endian) 9808 if err != nil { 9809 panic(IOError{Err: err, Op: "S12", Pos: d.Pos()}) 9810 } 9811 return v 9812} 9813 9814// TryFieldScalarS12 tries to add a field and read 12 bit signed integer in current endian 9815func (d *D) TryFieldScalarS12(name string, sms ...scalar.Mapper) (*scalar.S, error) { 9816 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 9817 v, err := d.trySE(12, d.Endian) 9818 s.Actual = v 9819 return s, err 9820 }, sms...) 9821 if err != nil { 9822 return nil, err 9823 } 9824 return s, err 9825} 9826 9827// FieldScalarS12 adds a field and reads 12 bit signed integer in current endian 9828func (d *D) FieldScalarS12(name string, sms ...scalar.Mapper) *scalar.S { 9829 s, err := d.TryFieldScalarS12(name, sms...) 9830 if err != nil { 9831 panic(IOError{Err: err, Name: name, Op: "S12", Pos: d.Pos()}) 9832 } 9833 return s 9834} 9835 9836// TryFieldS12 tries to add a field and read 12 bit signed integer in current endian 9837func (d *D) TryFieldS12(name string, sms ...scalar.Mapper) (int64, error) { 9838 s, err := d.TryFieldScalarS12(name, sms...) 9839 return s.ActualS(), err 9840} 9841 9842// FieldS12 adds a field and reads 12 bit signed integer in current endian 9843func (d *D) FieldS12(name string, sms ...scalar.Mapper) int64 { 9844 return d.FieldScalarS12(name, sms...).ActualS() 9845} 9846 9847// Reader S13 9848 9849// TryS13 tries to read 13 bit signed integer in current endian 9850func (d *D) TryS13() (int64, error) { return d.trySE(13, d.Endian) } 9851 9852// S13 reads 13 bit signed integer in current endian 9853func (d *D) S13() int64 { 9854 v, err := d.trySE(13, d.Endian) 9855 if err != nil { 9856 panic(IOError{Err: err, Op: "S13", Pos: d.Pos()}) 9857 } 9858 return v 9859} 9860 9861// TryFieldScalarS13 tries to add a field and read 13 bit signed integer in current endian 9862func (d *D) TryFieldScalarS13(name string, sms ...scalar.Mapper) (*scalar.S, error) { 9863 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 9864 v, err := d.trySE(13, d.Endian) 9865 s.Actual = v 9866 return s, err 9867 }, sms...) 9868 if err != nil { 9869 return nil, err 9870 } 9871 return s, err 9872} 9873 9874// FieldScalarS13 adds a field and reads 13 bit signed integer in current endian 9875func (d *D) FieldScalarS13(name string, sms ...scalar.Mapper) *scalar.S { 9876 s, err := d.TryFieldScalarS13(name, sms...) 9877 if err != nil { 9878 panic(IOError{Err: err, Name: name, Op: "S13", Pos: d.Pos()}) 9879 } 9880 return s 9881} 9882 9883// TryFieldS13 tries to add a field and read 13 bit signed integer in current endian 9884func (d *D) TryFieldS13(name string, sms ...scalar.Mapper) (int64, error) { 9885 s, err := d.TryFieldScalarS13(name, sms...) 9886 return s.ActualS(), err 9887} 9888 9889// FieldS13 adds a field and reads 13 bit signed integer in current endian 9890func (d *D) FieldS13(name string, sms ...scalar.Mapper) int64 { 9891 return d.FieldScalarS13(name, sms...).ActualS() 9892} 9893 9894// Reader S14 9895 9896// TryS14 tries to read 14 bit signed integer in current endian 9897func (d *D) TryS14() (int64, error) { return d.trySE(14, d.Endian) } 9898 9899// S14 reads 14 bit signed integer in current endian 9900func (d *D) S14() int64 { 9901 v, err := d.trySE(14, d.Endian) 9902 if err != nil { 9903 panic(IOError{Err: err, Op: "S14", Pos: d.Pos()}) 9904 } 9905 return v 9906} 9907 9908// TryFieldScalarS14 tries to add a field and read 14 bit signed integer in current endian 9909func (d *D) TryFieldScalarS14(name string, sms ...scalar.Mapper) (*scalar.S, error) { 9910 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 9911 v, err := d.trySE(14, d.Endian) 9912 s.Actual = v 9913 return s, err 9914 }, sms...) 9915 if err != nil { 9916 return nil, err 9917 } 9918 return s, err 9919} 9920 9921// FieldScalarS14 adds a field and reads 14 bit signed integer in current endian 9922func (d *D) FieldScalarS14(name string, sms ...scalar.Mapper) *scalar.S { 9923 s, err := d.TryFieldScalarS14(name, sms...) 9924 if err != nil { 9925 panic(IOError{Err: err, Name: name, Op: "S14", Pos: d.Pos()}) 9926 } 9927 return s 9928} 9929 9930// TryFieldS14 tries to add a field and read 14 bit signed integer in current endian 9931func (d *D) TryFieldS14(name string, sms ...scalar.Mapper) (int64, error) { 9932 s, err := d.TryFieldScalarS14(name, sms...) 9933 return s.ActualS(), err 9934} 9935 9936// FieldS14 adds a field and reads 14 bit signed integer in current endian 9937func (d *D) FieldS14(name string, sms ...scalar.Mapper) int64 { 9938 return d.FieldScalarS14(name, sms...).ActualS() 9939} 9940 9941// Reader S15 9942 9943// TryS15 tries to read 15 bit signed integer in current endian 9944func (d *D) TryS15() (int64, error) { return d.trySE(15, d.Endian) } 9945 9946// S15 reads 15 bit signed integer in current endian 9947func (d *D) S15() int64 { 9948 v, err := d.trySE(15, d.Endian) 9949 if err != nil { 9950 panic(IOError{Err: err, Op: "S15", Pos: d.Pos()}) 9951 } 9952 return v 9953} 9954 9955// TryFieldScalarS15 tries to add a field and read 15 bit signed integer in current endian 9956func (d *D) TryFieldScalarS15(name string, sms ...scalar.Mapper) (*scalar.S, error) { 9957 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 9958 v, err := d.trySE(15, d.Endian) 9959 s.Actual = v 9960 return s, err 9961 }, sms...) 9962 if err != nil { 9963 return nil, err 9964 } 9965 return s, err 9966} 9967 9968// FieldScalarS15 adds a field and reads 15 bit signed integer in current endian 9969func (d *D) FieldScalarS15(name string, sms ...scalar.Mapper) *scalar.S { 9970 s, err := d.TryFieldScalarS15(name, sms...) 9971 if err != nil { 9972 panic(IOError{Err: err, Name: name, Op: "S15", Pos: d.Pos()}) 9973 } 9974 return s 9975} 9976 9977// TryFieldS15 tries to add a field and read 15 bit signed integer in current endian 9978func (d *D) TryFieldS15(name string, sms ...scalar.Mapper) (int64, error) { 9979 s, err := d.TryFieldScalarS15(name, sms...) 9980 return s.ActualS(), err 9981} 9982 9983// FieldS15 adds a field and reads 15 bit signed integer in current endian 9984func (d *D) FieldS15(name string, sms ...scalar.Mapper) int64 { 9985 return d.FieldScalarS15(name, sms...).ActualS() 9986} 9987 9988// Reader S16 9989 9990// TryS16 tries to read 16 bit signed integer in current endian 9991func (d *D) TryS16() (int64, error) { return d.trySE(16, d.Endian) } 9992 9993// S16 reads 16 bit signed integer in current endian 9994func (d *D) S16() int64 { 9995 v, err := d.trySE(16, d.Endian) 9996 if err != nil { 9997 panic(IOError{Err: err, Op: "S16", Pos: d.Pos()}) 9998 } 9999 return v 10000} 10001 10002// TryFieldScalarS16 tries to add a field and read 16 bit signed integer in current endian 10003func (d *D) TryFieldScalarS16(name string, sms ...scalar.Mapper) (*scalar.S, error) { 10004 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 10005 v, err := d.trySE(16, d.Endian) 10006 s.Actual = v 10007 return s, err 10008 }, sms...) 10009 if err != nil { 10010 return nil, err 10011 } 10012 return s, err 10013} 10014 10015// FieldScalarS16 adds a field and reads 16 bit signed integer in current endian 10016func (d *D) FieldScalarS16(name string, sms ...scalar.Mapper) *scalar.S { 10017 s, err := d.TryFieldScalarS16(name, sms...) 10018 if err != nil { 10019 panic(IOError{Err: err, Name: name, Op: "S16", Pos: d.Pos()}) 10020 } 10021 return s 10022} 10023 10024// TryFieldS16 tries to add a field and read 16 bit signed integer in current endian 10025func (d *D) TryFieldS16(name string, sms ...scalar.Mapper) (int64, error) { 10026 s, err := d.TryFieldScalarS16(name, sms...) 10027 return s.ActualS(), err 10028} 10029 10030// FieldS16 adds a field and reads 16 bit signed integer in current endian 10031func (d *D) FieldS16(name string, sms ...scalar.Mapper) int64 { 10032 return d.FieldScalarS16(name, sms...).ActualS() 10033} 10034 10035// Reader S17 10036 10037// TryS17 tries to read 17 bit signed integer in current endian 10038func (d *D) TryS17() (int64, error) { return d.trySE(17, d.Endian) } 10039 10040// S17 reads 17 bit signed integer in current endian 10041func (d *D) S17() int64 { 10042 v, err := d.trySE(17, d.Endian) 10043 if err != nil { 10044 panic(IOError{Err: err, Op: "S17", Pos: d.Pos()}) 10045 } 10046 return v 10047} 10048 10049// TryFieldScalarS17 tries to add a field and read 17 bit signed integer in current endian 10050func (d *D) TryFieldScalarS17(name string, sms ...scalar.Mapper) (*scalar.S, error) { 10051 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 10052 v, err := d.trySE(17, d.Endian) 10053 s.Actual = v 10054 return s, err 10055 }, sms...) 10056 if err != nil { 10057 return nil, err 10058 } 10059 return s, err 10060} 10061 10062// FieldScalarS17 adds a field and reads 17 bit signed integer in current endian 10063func (d *D) FieldScalarS17(name string, sms ...scalar.Mapper) *scalar.S { 10064 s, err := d.TryFieldScalarS17(name, sms...) 10065 if err != nil { 10066 panic(IOError{Err: err, Name: name, Op: "S17", Pos: d.Pos()}) 10067 } 10068 return s 10069} 10070 10071// TryFieldS17 tries to add a field and read 17 bit signed integer in current endian 10072func (d *D) TryFieldS17(name string, sms ...scalar.Mapper) (int64, error) { 10073 s, err := d.TryFieldScalarS17(name, sms...) 10074 return s.ActualS(), err 10075} 10076 10077// FieldS17 adds a field and reads 17 bit signed integer in current endian 10078func (d *D) FieldS17(name string, sms ...scalar.Mapper) int64 { 10079 return d.FieldScalarS17(name, sms...).ActualS() 10080} 10081 10082// Reader S18 10083 10084// TryS18 tries to read 18 bit signed integer in current endian 10085func (d *D) TryS18() (int64, error) { return d.trySE(18, d.Endian) } 10086 10087// S18 reads 18 bit signed integer in current endian 10088func (d *D) S18() int64 { 10089 v, err := d.trySE(18, d.Endian) 10090 if err != nil { 10091 panic(IOError{Err: err, Op: "S18", Pos: d.Pos()}) 10092 } 10093 return v 10094} 10095 10096// TryFieldScalarS18 tries to add a field and read 18 bit signed integer in current endian 10097func (d *D) TryFieldScalarS18(name string, sms ...scalar.Mapper) (*scalar.S, error) { 10098 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 10099 v, err := d.trySE(18, d.Endian) 10100 s.Actual = v 10101 return s, err 10102 }, sms...) 10103 if err != nil { 10104 return nil, err 10105 } 10106 return s, err 10107} 10108 10109// FieldScalarS18 adds a field and reads 18 bit signed integer in current endian 10110func (d *D) FieldScalarS18(name string, sms ...scalar.Mapper) *scalar.S { 10111 s, err := d.TryFieldScalarS18(name, sms...) 10112 if err != nil { 10113 panic(IOError{Err: err, Name: name, Op: "S18", Pos: d.Pos()}) 10114 } 10115 return s 10116} 10117 10118// TryFieldS18 tries to add a field and read 18 bit signed integer in current endian 10119func (d *D) TryFieldS18(name string, sms ...scalar.Mapper) (int64, error) { 10120 s, err := d.TryFieldScalarS18(name, sms...) 10121 return s.ActualS(), err 10122} 10123 10124// FieldS18 adds a field and reads 18 bit signed integer in current endian 10125func (d *D) FieldS18(name string, sms ...scalar.Mapper) int64 { 10126 return d.FieldScalarS18(name, sms...).ActualS() 10127} 10128 10129// Reader S19 10130 10131// TryS19 tries to read 19 bit signed integer in current endian 10132func (d *D) TryS19() (int64, error) { return d.trySE(19, d.Endian) } 10133 10134// S19 reads 19 bit signed integer in current endian 10135func (d *D) S19() int64 { 10136 v, err := d.trySE(19, d.Endian) 10137 if err != nil { 10138 panic(IOError{Err: err, Op: "S19", Pos: d.Pos()}) 10139 } 10140 return v 10141} 10142 10143// TryFieldScalarS19 tries to add a field and read 19 bit signed integer in current endian 10144func (d *D) TryFieldScalarS19(name string, sms ...scalar.Mapper) (*scalar.S, error) { 10145 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 10146 v, err := d.trySE(19, d.Endian) 10147 s.Actual = v 10148 return s, err 10149 }, sms...) 10150 if err != nil { 10151 return nil, err 10152 } 10153 return s, err 10154} 10155 10156// FieldScalarS19 adds a field and reads 19 bit signed integer in current endian 10157func (d *D) FieldScalarS19(name string, sms ...scalar.Mapper) *scalar.S { 10158 s, err := d.TryFieldScalarS19(name, sms...) 10159 if err != nil { 10160 panic(IOError{Err: err, Name: name, Op: "S19", Pos: d.Pos()}) 10161 } 10162 return s 10163} 10164 10165// TryFieldS19 tries to add a field and read 19 bit signed integer in current endian 10166func (d *D) TryFieldS19(name string, sms ...scalar.Mapper) (int64, error) { 10167 s, err := d.TryFieldScalarS19(name, sms...) 10168 return s.ActualS(), err 10169} 10170 10171// FieldS19 adds a field and reads 19 bit signed integer in current endian 10172func (d *D) FieldS19(name string, sms ...scalar.Mapper) int64 { 10173 return d.FieldScalarS19(name, sms...).ActualS() 10174} 10175 10176// Reader S20 10177 10178// TryS20 tries to read 20 bit signed integer in current endian 10179func (d *D) TryS20() (int64, error) { return d.trySE(20, d.Endian) } 10180 10181// S20 reads 20 bit signed integer in current endian 10182func (d *D) S20() int64 { 10183 v, err := d.trySE(20, d.Endian) 10184 if err != nil { 10185 panic(IOError{Err: err, Op: "S20", Pos: d.Pos()}) 10186 } 10187 return v 10188} 10189 10190// TryFieldScalarS20 tries to add a field and read 20 bit signed integer in current endian 10191func (d *D) TryFieldScalarS20(name string, sms ...scalar.Mapper) (*scalar.S, error) { 10192 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 10193 v, err := d.trySE(20, d.Endian) 10194 s.Actual = v 10195 return s, err 10196 }, sms...) 10197 if err != nil { 10198 return nil, err 10199 } 10200 return s, err 10201} 10202 10203// FieldScalarS20 adds a field and reads 20 bit signed integer in current endian 10204func (d *D) FieldScalarS20(name string, sms ...scalar.Mapper) *scalar.S { 10205 s, err := d.TryFieldScalarS20(name, sms...) 10206 if err != nil { 10207 panic(IOError{Err: err, Name: name, Op: "S20", Pos: d.Pos()}) 10208 } 10209 return s 10210} 10211 10212// TryFieldS20 tries to add a field and read 20 bit signed integer in current endian 10213func (d *D) TryFieldS20(name string, sms ...scalar.Mapper) (int64, error) { 10214 s, err := d.TryFieldScalarS20(name, sms...) 10215 return s.ActualS(), err 10216} 10217 10218// FieldS20 adds a field and reads 20 bit signed integer in current endian 10219func (d *D) FieldS20(name string, sms ...scalar.Mapper) int64 { 10220 return d.FieldScalarS20(name, sms...).ActualS() 10221} 10222 10223// Reader S21 10224 10225// TryS21 tries to read 21 bit signed integer in current endian 10226func (d *D) TryS21() (int64, error) { return d.trySE(21, d.Endian) } 10227 10228// S21 reads 21 bit signed integer in current endian 10229func (d *D) S21() int64 { 10230 v, err := d.trySE(21, d.Endian) 10231 if err != nil { 10232 panic(IOError{Err: err, Op: "S21", Pos: d.Pos()}) 10233 } 10234 return v 10235} 10236 10237// TryFieldScalarS21 tries to add a field and read 21 bit signed integer in current endian 10238func (d *D) TryFieldScalarS21(name string, sms ...scalar.Mapper) (*scalar.S, error) { 10239 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 10240 v, err := d.trySE(21, d.Endian) 10241 s.Actual = v 10242 return s, err 10243 }, sms...) 10244 if err != nil { 10245 return nil, err 10246 } 10247 return s, err 10248} 10249 10250// FieldScalarS21 adds a field and reads 21 bit signed integer in current endian 10251func (d *D) FieldScalarS21(name string, sms ...scalar.Mapper) *scalar.S { 10252 s, err := d.TryFieldScalarS21(name, sms...) 10253 if err != nil { 10254 panic(IOError{Err: err, Name: name, Op: "S21", Pos: d.Pos()}) 10255 } 10256 return s 10257} 10258 10259// TryFieldS21 tries to add a field and read 21 bit signed integer in current endian 10260func (d *D) TryFieldS21(name string, sms ...scalar.Mapper) (int64, error) { 10261 s, err := d.TryFieldScalarS21(name, sms...) 10262 return s.ActualS(), err 10263} 10264 10265// FieldS21 adds a field and reads 21 bit signed integer in current endian 10266func (d *D) FieldS21(name string, sms ...scalar.Mapper) int64 { 10267 return d.FieldScalarS21(name, sms...).ActualS() 10268} 10269 10270// Reader S22 10271 10272// TryS22 tries to read 22 bit signed integer in current endian 10273func (d *D) TryS22() (int64, error) { return d.trySE(22, d.Endian) } 10274 10275// S22 reads 22 bit signed integer in current endian 10276func (d *D) S22() int64 { 10277 v, err := d.trySE(22, d.Endian) 10278 if err != nil { 10279 panic(IOError{Err: err, Op: "S22", Pos: d.Pos()}) 10280 } 10281 return v 10282} 10283 10284// TryFieldScalarS22 tries to add a field and read 22 bit signed integer in current endian 10285func (d *D) TryFieldScalarS22(name string, sms ...scalar.Mapper) (*scalar.S, error) { 10286 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 10287 v, err := d.trySE(22, d.Endian) 10288 s.Actual = v 10289 return s, err 10290 }, sms...) 10291 if err != nil { 10292 return nil, err 10293 } 10294 return s, err 10295} 10296 10297// FieldScalarS22 adds a field and reads 22 bit signed integer in current endian 10298func (d *D) FieldScalarS22(name string, sms ...scalar.Mapper) *scalar.S { 10299 s, err := d.TryFieldScalarS22(name, sms...) 10300 if err != nil { 10301 panic(IOError{Err: err, Name: name, Op: "S22", Pos: d.Pos()}) 10302 } 10303 return s 10304} 10305 10306// TryFieldS22 tries to add a field and read 22 bit signed integer in current endian 10307func (d *D) TryFieldS22(name string, sms ...scalar.Mapper) (int64, error) { 10308 s, err := d.TryFieldScalarS22(name, sms...) 10309 return s.ActualS(), err 10310} 10311 10312// FieldS22 adds a field and reads 22 bit signed integer in current endian 10313func (d *D) FieldS22(name string, sms ...scalar.Mapper) int64 { 10314 return d.FieldScalarS22(name, sms...).ActualS() 10315} 10316 10317// Reader S23 10318 10319// TryS23 tries to read 23 bit signed integer in current endian 10320func (d *D) TryS23() (int64, error) { return d.trySE(23, d.Endian) } 10321 10322// S23 reads 23 bit signed integer in current endian 10323func (d *D) S23() int64 { 10324 v, err := d.trySE(23, d.Endian) 10325 if err != nil { 10326 panic(IOError{Err: err, Op: "S23", Pos: d.Pos()}) 10327 } 10328 return v 10329} 10330 10331// TryFieldScalarS23 tries to add a field and read 23 bit signed integer in current endian 10332func (d *D) TryFieldScalarS23(name string, sms ...scalar.Mapper) (*scalar.S, error) { 10333 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 10334 v, err := d.trySE(23, d.Endian) 10335 s.Actual = v 10336 return s, err 10337 }, sms...) 10338 if err != nil { 10339 return nil, err 10340 } 10341 return s, err 10342} 10343 10344// FieldScalarS23 adds a field and reads 23 bit signed integer in current endian 10345func (d *D) FieldScalarS23(name string, sms ...scalar.Mapper) *scalar.S { 10346 s, err := d.TryFieldScalarS23(name, sms...) 10347 if err != nil { 10348 panic(IOError{Err: err, Name: name, Op: "S23", Pos: d.Pos()}) 10349 } 10350 return s 10351} 10352 10353// TryFieldS23 tries to add a field and read 23 bit signed integer in current endian 10354func (d *D) TryFieldS23(name string, sms ...scalar.Mapper) (int64, error) { 10355 s, err := d.TryFieldScalarS23(name, sms...) 10356 return s.ActualS(), err 10357} 10358 10359// FieldS23 adds a field and reads 23 bit signed integer in current endian 10360func (d *D) FieldS23(name string, sms ...scalar.Mapper) int64 { 10361 return d.FieldScalarS23(name, sms...).ActualS() 10362} 10363 10364// Reader S24 10365 10366// TryS24 tries to read 24 bit signed integer in current endian 10367func (d *D) TryS24() (int64, error) { return d.trySE(24, d.Endian) } 10368 10369// S24 reads 24 bit signed integer in current endian 10370func (d *D) S24() int64 { 10371 v, err := d.trySE(24, d.Endian) 10372 if err != nil { 10373 panic(IOError{Err: err, Op: "S24", Pos: d.Pos()}) 10374 } 10375 return v 10376} 10377 10378// TryFieldScalarS24 tries to add a field and read 24 bit signed integer in current endian 10379func (d *D) TryFieldScalarS24(name string, sms ...scalar.Mapper) (*scalar.S, error) { 10380 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 10381 v, err := d.trySE(24, d.Endian) 10382 s.Actual = v 10383 return s, err 10384 }, sms...) 10385 if err != nil { 10386 return nil, err 10387 } 10388 return s, err 10389} 10390 10391// FieldScalarS24 adds a field and reads 24 bit signed integer in current endian 10392func (d *D) FieldScalarS24(name string, sms ...scalar.Mapper) *scalar.S { 10393 s, err := d.TryFieldScalarS24(name, sms...) 10394 if err != nil { 10395 panic(IOError{Err: err, Name: name, Op: "S24", Pos: d.Pos()}) 10396 } 10397 return s 10398} 10399 10400// TryFieldS24 tries to add a field and read 24 bit signed integer in current endian 10401func (d *D) TryFieldS24(name string, sms ...scalar.Mapper) (int64, error) { 10402 s, err := d.TryFieldScalarS24(name, sms...) 10403 return s.ActualS(), err 10404} 10405 10406// FieldS24 adds a field and reads 24 bit signed integer in current endian 10407func (d *D) FieldS24(name string, sms ...scalar.Mapper) int64 { 10408 return d.FieldScalarS24(name, sms...).ActualS() 10409} 10410 10411// Reader S25 10412 10413// TryS25 tries to read 25 bit signed integer in current endian 10414func (d *D) TryS25() (int64, error) { return d.trySE(25, d.Endian) } 10415 10416// S25 reads 25 bit signed integer in current endian 10417func (d *D) S25() int64 { 10418 v, err := d.trySE(25, d.Endian) 10419 if err != nil { 10420 panic(IOError{Err: err, Op: "S25", Pos: d.Pos()}) 10421 } 10422 return v 10423} 10424 10425// TryFieldScalarS25 tries to add a field and read 25 bit signed integer in current endian 10426func (d *D) TryFieldScalarS25(name string, sms ...scalar.Mapper) (*scalar.S, error) { 10427 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 10428 v, err := d.trySE(25, d.Endian) 10429 s.Actual = v 10430 return s, err 10431 }, sms...) 10432 if err != nil { 10433 return nil, err 10434 } 10435 return s, err 10436} 10437 10438// FieldScalarS25 adds a field and reads 25 bit signed integer in current endian 10439func (d *D) FieldScalarS25(name string, sms ...scalar.Mapper) *scalar.S { 10440 s, err := d.TryFieldScalarS25(name, sms...) 10441 if err != nil { 10442 panic(IOError{Err: err, Name: name, Op: "S25", Pos: d.Pos()}) 10443 } 10444 return s 10445} 10446 10447// TryFieldS25 tries to add a field and read 25 bit signed integer in current endian 10448func (d *D) TryFieldS25(name string, sms ...scalar.Mapper) (int64, error) { 10449 s, err := d.TryFieldScalarS25(name, sms...) 10450 return s.ActualS(), err 10451} 10452 10453// FieldS25 adds a field and reads 25 bit signed integer in current endian 10454func (d *D) FieldS25(name string, sms ...scalar.Mapper) int64 { 10455 return d.FieldScalarS25(name, sms...).ActualS() 10456} 10457 10458// Reader S26 10459 10460// TryS26 tries to read 26 bit signed integer in current endian 10461func (d *D) TryS26() (int64, error) { return d.trySE(26, d.Endian) } 10462 10463// S26 reads 26 bit signed integer in current endian 10464func (d *D) S26() int64 { 10465 v, err := d.trySE(26, d.Endian) 10466 if err != nil { 10467 panic(IOError{Err: err, Op: "S26", Pos: d.Pos()}) 10468 } 10469 return v 10470} 10471 10472// TryFieldScalarS26 tries to add a field and read 26 bit signed integer in current endian 10473func (d *D) TryFieldScalarS26(name string, sms ...scalar.Mapper) (*scalar.S, error) { 10474 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 10475 v, err := d.trySE(26, d.Endian) 10476 s.Actual = v 10477 return s, err 10478 }, sms...) 10479 if err != nil { 10480 return nil, err 10481 } 10482 return s, err 10483} 10484 10485// FieldScalarS26 adds a field and reads 26 bit signed integer in current endian 10486func (d *D) FieldScalarS26(name string, sms ...scalar.Mapper) *scalar.S { 10487 s, err := d.TryFieldScalarS26(name, sms...) 10488 if err != nil { 10489 panic(IOError{Err: err, Name: name, Op: "S26", Pos: d.Pos()}) 10490 } 10491 return s 10492} 10493 10494// TryFieldS26 tries to add a field and read 26 bit signed integer in current endian 10495func (d *D) TryFieldS26(name string, sms ...scalar.Mapper) (int64, error) { 10496 s, err := d.TryFieldScalarS26(name, sms...) 10497 return s.ActualS(), err 10498} 10499 10500// FieldS26 adds a field and reads 26 bit signed integer in current endian 10501func (d *D) FieldS26(name string, sms ...scalar.Mapper) int64 { 10502 return d.FieldScalarS26(name, sms...).ActualS() 10503} 10504 10505// Reader S27 10506 10507// TryS27 tries to read 27 bit signed integer in current endian 10508func (d *D) TryS27() (int64, error) { return d.trySE(27, d.Endian) } 10509 10510// S27 reads 27 bit signed integer in current endian 10511func (d *D) S27() int64 { 10512 v, err := d.trySE(27, d.Endian) 10513 if err != nil { 10514 panic(IOError{Err: err, Op: "S27", Pos: d.Pos()}) 10515 } 10516 return v 10517} 10518 10519// TryFieldScalarS27 tries to add a field and read 27 bit signed integer in current endian 10520func (d *D) TryFieldScalarS27(name string, sms ...scalar.Mapper) (*scalar.S, error) { 10521 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 10522 v, err := d.trySE(27, d.Endian) 10523 s.Actual = v 10524 return s, err 10525 }, sms...) 10526 if err != nil { 10527 return nil, err 10528 } 10529 return s, err 10530} 10531 10532// FieldScalarS27 adds a field and reads 27 bit signed integer in current endian 10533func (d *D) FieldScalarS27(name string, sms ...scalar.Mapper) *scalar.S { 10534 s, err := d.TryFieldScalarS27(name, sms...) 10535 if err != nil { 10536 panic(IOError{Err: err, Name: name, Op: "S27", Pos: d.Pos()}) 10537 } 10538 return s 10539} 10540 10541// TryFieldS27 tries to add a field and read 27 bit signed integer in current endian 10542func (d *D) TryFieldS27(name string, sms ...scalar.Mapper) (int64, error) { 10543 s, err := d.TryFieldScalarS27(name, sms...) 10544 return s.ActualS(), err 10545} 10546 10547// FieldS27 adds a field and reads 27 bit signed integer in current endian 10548func (d *D) FieldS27(name string, sms ...scalar.Mapper) int64 { 10549 return d.FieldScalarS27(name, sms...).ActualS() 10550} 10551 10552// Reader S28 10553 10554// TryS28 tries to read 28 bit signed integer in current endian 10555func (d *D) TryS28() (int64, error) { return d.trySE(28, d.Endian) } 10556 10557// S28 reads 28 bit signed integer in current endian 10558func (d *D) S28() int64 { 10559 v, err := d.trySE(28, d.Endian) 10560 if err != nil { 10561 panic(IOError{Err: err, Op: "S28", Pos: d.Pos()}) 10562 } 10563 return v 10564} 10565 10566// TryFieldScalarS28 tries to add a field and read 28 bit signed integer in current endian 10567func (d *D) TryFieldScalarS28(name string, sms ...scalar.Mapper) (*scalar.S, error) { 10568 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 10569 v, err := d.trySE(28, d.Endian) 10570 s.Actual = v 10571 return s, err 10572 }, sms...) 10573 if err != nil { 10574 return nil, err 10575 } 10576 return s, err 10577} 10578 10579// FieldScalarS28 adds a field and reads 28 bit signed integer in current endian 10580func (d *D) FieldScalarS28(name string, sms ...scalar.Mapper) *scalar.S { 10581 s, err := d.TryFieldScalarS28(name, sms...) 10582 if err != nil { 10583 panic(IOError{Err: err, Name: name, Op: "S28", Pos: d.Pos()}) 10584 } 10585 return s 10586} 10587 10588// TryFieldS28 tries to add a field and read 28 bit signed integer in current endian 10589func (d *D) TryFieldS28(name string, sms ...scalar.Mapper) (int64, error) { 10590 s, err := d.TryFieldScalarS28(name, sms...) 10591 return s.ActualS(), err 10592} 10593 10594// FieldS28 adds a field and reads 28 bit signed integer in current endian 10595func (d *D) FieldS28(name string, sms ...scalar.Mapper) int64 { 10596 return d.FieldScalarS28(name, sms...).ActualS() 10597} 10598 10599// Reader S29 10600 10601// TryS29 tries to read 29 bit signed integer in current endian 10602func (d *D) TryS29() (int64, error) { return d.trySE(29, d.Endian) } 10603 10604// S29 reads 29 bit signed integer in current endian 10605func (d *D) S29() int64 { 10606 v, err := d.trySE(29, d.Endian) 10607 if err != nil { 10608 panic(IOError{Err: err, Op: "S29", Pos: d.Pos()}) 10609 } 10610 return v 10611} 10612 10613// TryFieldScalarS29 tries to add a field and read 29 bit signed integer in current endian 10614func (d *D) TryFieldScalarS29(name string, sms ...scalar.Mapper) (*scalar.S, error) { 10615 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 10616 v, err := d.trySE(29, d.Endian) 10617 s.Actual = v 10618 return s, err 10619 }, sms...) 10620 if err != nil { 10621 return nil, err 10622 } 10623 return s, err 10624} 10625 10626// FieldScalarS29 adds a field and reads 29 bit signed integer in current endian 10627func (d *D) FieldScalarS29(name string, sms ...scalar.Mapper) *scalar.S { 10628 s, err := d.TryFieldScalarS29(name, sms...) 10629 if err != nil { 10630 panic(IOError{Err: err, Name: name, Op: "S29", Pos: d.Pos()}) 10631 } 10632 return s 10633} 10634 10635// TryFieldS29 tries to add a field and read 29 bit signed integer in current endian 10636func (d *D) TryFieldS29(name string, sms ...scalar.Mapper) (int64, error) { 10637 s, err := d.TryFieldScalarS29(name, sms...) 10638 return s.ActualS(), err 10639} 10640 10641// FieldS29 adds a field and reads 29 bit signed integer in current endian 10642func (d *D) FieldS29(name string, sms ...scalar.Mapper) int64 { 10643 return d.FieldScalarS29(name, sms...).ActualS() 10644} 10645 10646// Reader S30 10647 10648// TryS30 tries to read 30 bit signed integer in current endian 10649func (d *D) TryS30() (int64, error) { return d.trySE(30, d.Endian) } 10650 10651// S30 reads 30 bit signed integer in current endian 10652func (d *D) S30() int64 { 10653 v, err := d.trySE(30, d.Endian) 10654 if err != nil { 10655 panic(IOError{Err: err, Op: "S30", Pos: d.Pos()}) 10656 } 10657 return v 10658} 10659 10660// TryFieldScalarS30 tries to add a field and read 30 bit signed integer in current endian 10661func (d *D) TryFieldScalarS30(name string, sms ...scalar.Mapper) (*scalar.S, error) { 10662 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 10663 v, err := d.trySE(30, d.Endian) 10664 s.Actual = v 10665 return s, err 10666 }, sms...) 10667 if err != nil { 10668 return nil, err 10669 } 10670 return s, err 10671} 10672 10673// FieldScalarS30 adds a field and reads 30 bit signed integer in current endian 10674func (d *D) FieldScalarS30(name string, sms ...scalar.Mapper) *scalar.S { 10675 s, err := d.TryFieldScalarS30(name, sms...) 10676 if err != nil { 10677 panic(IOError{Err: err, Name: name, Op: "S30", Pos: d.Pos()}) 10678 } 10679 return s 10680} 10681 10682// TryFieldS30 tries to add a field and read 30 bit signed integer in current endian 10683func (d *D) TryFieldS30(name string, sms ...scalar.Mapper) (int64, error) { 10684 s, err := d.TryFieldScalarS30(name, sms...) 10685 return s.ActualS(), err 10686} 10687 10688// FieldS30 adds a field and reads 30 bit signed integer in current endian 10689func (d *D) FieldS30(name string, sms ...scalar.Mapper) int64 { 10690 return d.FieldScalarS30(name, sms...).ActualS() 10691} 10692 10693// Reader S31 10694 10695// TryS31 tries to read 31 bit signed integer in current endian 10696func (d *D) TryS31() (int64, error) { return d.trySE(31, d.Endian) } 10697 10698// S31 reads 31 bit signed integer in current endian 10699func (d *D) S31() int64 { 10700 v, err := d.trySE(31, d.Endian) 10701 if err != nil { 10702 panic(IOError{Err: err, Op: "S31", Pos: d.Pos()}) 10703 } 10704 return v 10705} 10706 10707// TryFieldScalarS31 tries to add a field and read 31 bit signed integer in current endian 10708func (d *D) TryFieldScalarS31(name string, sms ...scalar.Mapper) (*scalar.S, error) { 10709 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 10710 v, err := d.trySE(31, d.Endian) 10711 s.Actual = v 10712 return s, err 10713 }, sms...) 10714 if err != nil { 10715 return nil, err 10716 } 10717 return s, err 10718} 10719 10720// FieldScalarS31 adds a field and reads 31 bit signed integer in current endian 10721func (d *D) FieldScalarS31(name string, sms ...scalar.Mapper) *scalar.S { 10722 s, err := d.TryFieldScalarS31(name, sms...) 10723 if err != nil { 10724 panic(IOError{Err: err, Name: name, Op: "S31", Pos: d.Pos()}) 10725 } 10726 return s 10727} 10728 10729// TryFieldS31 tries to add a field and read 31 bit signed integer in current endian 10730func (d *D) TryFieldS31(name string, sms ...scalar.Mapper) (int64, error) { 10731 s, err := d.TryFieldScalarS31(name, sms...) 10732 return s.ActualS(), err 10733} 10734 10735// FieldS31 adds a field and reads 31 bit signed integer in current endian 10736func (d *D) FieldS31(name string, sms ...scalar.Mapper) int64 { 10737 return d.FieldScalarS31(name, sms...).ActualS() 10738} 10739 10740// Reader S32 10741 10742// TryS32 tries to read 32 bit signed integer in current endian 10743func (d *D) TryS32() (int64, error) { return d.trySE(32, d.Endian) } 10744 10745// S32 reads 32 bit signed integer in current endian 10746func (d *D) S32() int64 { 10747 v, err := d.trySE(32, d.Endian) 10748 if err != nil { 10749 panic(IOError{Err: err, Op: "S32", Pos: d.Pos()}) 10750 } 10751 return v 10752} 10753 10754// TryFieldScalarS32 tries to add a field and read 32 bit signed integer in current endian 10755func (d *D) TryFieldScalarS32(name string, sms ...scalar.Mapper) (*scalar.S, error) { 10756 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 10757 v, err := d.trySE(32, d.Endian) 10758 s.Actual = v 10759 return s, err 10760 }, sms...) 10761 if err != nil { 10762 return nil, err 10763 } 10764 return s, err 10765} 10766 10767// FieldScalarS32 adds a field and reads 32 bit signed integer in current endian 10768func (d *D) FieldScalarS32(name string, sms ...scalar.Mapper) *scalar.S { 10769 s, err := d.TryFieldScalarS32(name, sms...) 10770 if err != nil { 10771 panic(IOError{Err: err, Name: name, Op: "S32", Pos: d.Pos()}) 10772 } 10773 return s 10774} 10775 10776// TryFieldS32 tries to add a field and read 32 bit signed integer in current endian 10777func (d *D) TryFieldS32(name string, sms ...scalar.Mapper) (int64, error) { 10778 s, err := d.TryFieldScalarS32(name, sms...) 10779 return s.ActualS(), err 10780} 10781 10782// FieldS32 adds a field and reads 32 bit signed integer in current endian 10783func (d *D) FieldS32(name string, sms ...scalar.Mapper) int64 { 10784 return d.FieldScalarS32(name, sms...).ActualS() 10785} 10786 10787// Reader S33 10788 10789// TryS33 tries to read 33 bit signed integer in current endian 10790func (d *D) TryS33() (int64, error) { return d.trySE(33, d.Endian) } 10791 10792// S33 reads 33 bit signed integer in current endian 10793func (d *D) S33() int64 { 10794 v, err := d.trySE(33, d.Endian) 10795 if err != nil { 10796 panic(IOError{Err: err, Op: "S33", Pos: d.Pos()}) 10797 } 10798 return v 10799} 10800 10801// TryFieldScalarS33 tries to add a field and read 33 bit signed integer in current endian 10802func (d *D) TryFieldScalarS33(name string, sms ...scalar.Mapper) (*scalar.S, error) { 10803 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 10804 v, err := d.trySE(33, d.Endian) 10805 s.Actual = v 10806 return s, err 10807 }, sms...) 10808 if err != nil { 10809 return nil, err 10810 } 10811 return s, err 10812} 10813 10814// FieldScalarS33 adds a field and reads 33 bit signed integer in current endian 10815func (d *D) FieldScalarS33(name string, sms ...scalar.Mapper) *scalar.S { 10816 s, err := d.TryFieldScalarS33(name, sms...) 10817 if err != nil { 10818 panic(IOError{Err: err, Name: name, Op: "S33", Pos: d.Pos()}) 10819 } 10820 return s 10821} 10822 10823// TryFieldS33 tries to add a field and read 33 bit signed integer in current endian 10824func (d *D) TryFieldS33(name string, sms ...scalar.Mapper) (int64, error) { 10825 s, err := d.TryFieldScalarS33(name, sms...) 10826 return s.ActualS(), err 10827} 10828 10829// FieldS33 adds a field and reads 33 bit signed integer in current endian 10830func (d *D) FieldS33(name string, sms ...scalar.Mapper) int64 { 10831 return d.FieldScalarS33(name, sms...).ActualS() 10832} 10833 10834// Reader S34 10835 10836// TryS34 tries to read 34 bit signed integer in current endian 10837func (d *D) TryS34() (int64, error) { return d.trySE(34, d.Endian) } 10838 10839// S34 reads 34 bit signed integer in current endian 10840func (d *D) S34() int64 { 10841 v, err := d.trySE(34, d.Endian) 10842 if err != nil { 10843 panic(IOError{Err: err, Op: "S34", Pos: d.Pos()}) 10844 } 10845 return v 10846} 10847 10848// TryFieldScalarS34 tries to add a field and read 34 bit signed integer in current endian 10849func (d *D) TryFieldScalarS34(name string, sms ...scalar.Mapper) (*scalar.S, error) { 10850 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 10851 v, err := d.trySE(34, d.Endian) 10852 s.Actual = v 10853 return s, err 10854 }, sms...) 10855 if err != nil { 10856 return nil, err 10857 } 10858 return s, err 10859} 10860 10861// FieldScalarS34 adds a field and reads 34 bit signed integer in current endian 10862func (d *D) FieldScalarS34(name string, sms ...scalar.Mapper) *scalar.S { 10863 s, err := d.TryFieldScalarS34(name, sms...) 10864 if err != nil { 10865 panic(IOError{Err: err, Name: name, Op: "S34", Pos: d.Pos()}) 10866 } 10867 return s 10868} 10869 10870// TryFieldS34 tries to add a field and read 34 bit signed integer in current endian 10871func (d *D) TryFieldS34(name string, sms ...scalar.Mapper) (int64, error) { 10872 s, err := d.TryFieldScalarS34(name, sms...) 10873 return s.ActualS(), err 10874} 10875 10876// FieldS34 adds a field and reads 34 bit signed integer in current endian 10877func (d *D) FieldS34(name string, sms ...scalar.Mapper) int64 { 10878 return d.FieldScalarS34(name, sms...).ActualS() 10879} 10880 10881// Reader S35 10882 10883// TryS35 tries to read 35 bit signed integer in current endian 10884func (d *D) TryS35() (int64, error) { return d.trySE(35, d.Endian) } 10885 10886// S35 reads 35 bit signed integer in current endian 10887func (d *D) S35() int64 { 10888 v, err := d.trySE(35, d.Endian) 10889 if err != nil { 10890 panic(IOError{Err: err, Op: "S35", Pos: d.Pos()}) 10891 } 10892 return v 10893} 10894 10895// TryFieldScalarS35 tries to add a field and read 35 bit signed integer in current endian 10896func (d *D) TryFieldScalarS35(name string, sms ...scalar.Mapper) (*scalar.S, error) { 10897 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 10898 v, err := d.trySE(35, d.Endian) 10899 s.Actual = v 10900 return s, err 10901 }, sms...) 10902 if err != nil { 10903 return nil, err 10904 } 10905 return s, err 10906} 10907 10908// FieldScalarS35 adds a field and reads 35 bit signed integer in current endian 10909func (d *D) FieldScalarS35(name string, sms ...scalar.Mapper) *scalar.S { 10910 s, err := d.TryFieldScalarS35(name, sms...) 10911 if err != nil { 10912 panic(IOError{Err: err, Name: name, Op: "S35", Pos: d.Pos()}) 10913 } 10914 return s 10915} 10916 10917// TryFieldS35 tries to add a field and read 35 bit signed integer in current endian 10918func (d *D) TryFieldS35(name string, sms ...scalar.Mapper) (int64, error) { 10919 s, err := d.TryFieldScalarS35(name, sms...) 10920 return s.ActualS(), err 10921} 10922 10923// FieldS35 adds a field and reads 35 bit signed integer in current endian 10924func (d *D) FieldS35(name string, sms ...scalar.Mapper) int64 { 10925 return d.FieldScalarS35(name, sms...).ActualS() 10926} 10927 10928// Reader S36 10929 10930// TryS36 tries to read 36 bit signed integer in current endian 10931func (d *D) TryS36() (int64, error) { return d.trySE(36, d.Endian) } 10932 10933// S36 reads 36 bit signed integer in current endian 10934func (d *D) S36() int64 { 10935 v, err := d.trySE(36, d.Endian) 10936 if err != nil { 10937 panic(IOError{Err: err, Op: "S36", Pos: d.Pos()}) 10938 } 10939 return v 10940} 10941 10942// TryFieldScalarS36 tries to add a field and read 36 bit signed integer in current endian 10943func (d *D) TryFieldScalarS36(name string, sms ...scalar.Mapper) (*scalar.S, error) { 10944 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 10945 v, err := d.trySE(36, d.Endian) 10946 s.Actual = v 10947 return s, err 10948 }, sms...) 10949 if err != nil { 10950 return nil, err 10951 } 10952 return s, err 10953} 10954 10955// FieldScalarS36 adds a field and reads 36 bit signed integer in current endian 10956func (d *D) FieldScalarS36(name string, sms ...scalar.Mapper) *scalar.S { 10957 s, err := d.TryFieldScalarS36(name, sms...) 10958 if err != nil { 10959 panic(IOError{Err: err, Name: name, Op: "S36", Pos: d.Pos()}) 10960 } 10961 return s 10962} 10963 10964// TryFieldS36 tries to add a field and read 36 bit signed integer in current endian 10965func (d *D) TryFieldS36(name string, sms ...scalar.Mapper) (int64, error) { 10966 s, err := d.TryFieldScalarS36(name, sms...) 10967 return s.ActualS(), err 10968} 10969 10970// FieldS36 adds a field and reads 36 bit signed integer in current endian 10971func (d *D) FieldS36(name string, sms ...scalar.Mapper) int64 { 10972 return d.FieldScalarS36(name, sms...).ActualS() 10973} 10974 10975// Reader S37 10976 10977// TryS37 tries to read 37 bit signed integer in current endian 10978func (d *D) TryS37() (int64, error) { return d.trySE(37, d.Endian) } 10979 10980// S37 reads 37 bit signed integer in current endian 10981func (d *D) S37() int64 { 10982 v, err := d.trySE(37, d.Endian) 10983 if err != nil { 10984 panic(IOError{Err: err, Op: "S37", Pos: d.Pos()}) 10985 } 10986 return v 10987} 10988 10989// TryFieldScalarS37 tries to add a field and read 37 bit signed integer in current endian 10990func (d *D) TryFieldScalarS37(name string, sms ...scalar.Mapper) (*scalar.S, error) { 10991 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 10992 v, err := d.trySE(37, d.Endian) 10993 s.Actual = v 10994 return s, err 10995 }, sms...) 10996 if err != nil { 10997 return nil, err 10998 } 10999 return s, err 11000} 11001 11002// FieldScalarS37 adds a field and reads 37 bit signed integer in current endian 11003func (d *D) FieldScalarS37(name string, sms ...scalar.Mapper) *scalar.S { 11004 s, err := d.TryFieldScalarS37(name, sms...) 11005 if err != nil { 11006 panic(IOError{Err: err, Name: name, Op: "S37", Pos: d.Pos()}) 11007 } 11008 return s 11009} 11010 11011// TryFieldS37 tries to add a field and read 37 bit signed integer in current endian 11012func (d *D) TryFieldS37(name string, sms ...scalar.Mapper) (int64, error) { 11013 s, err := d.TryFieldScalarS37(name, sms...) 11014 return s.ActualS(), err 11015} 11016 11017// FieldS37 adds a field and reads 37 bit signed integer in current endian 11018func (d *D) FieldS37(name string, sms ...scalar.Mapper) int64 { 11019 return d.FieldScalarS37(name, sms...).ActualS() 11020} 11021 11022// Reader S38 11023 11024// TryS38 tries to read 38 bit signed integer in current endian 11025func (d *D) TryS38() (int64, error) { return d.trySE(38, d.Endian) } 11026 11027// S38 reads 38 bit signed integer in current endian 11028func (d *D) S38() int64 { 11029 v, err := d.trySE(38, d.Endian) 11030 if err != nil { 11031 panic(IOError{Err: err, Op: "S38", Pos: d.Pos()}) 11032 } 11033 return v 11034} 11035 11036// TryFieldScalarS38 tries to add a field and read 38 bit signed integer in current endian 11037func (d *D) TryFieldScalarS38(name string, sms ...scalar.Mapper) (*scalar.S, error) { 11038 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 11039 v, err := d.trySE(38, d.Endian) 11040 s.Actual = v 11041 return s, err 11042 }, sms...) 11043 if err != nil { 11044 return nil, err 11045 } 11046 return s, err 11047} 11048 11049// FieldScalarS38 adds a field and reads 38 bit signed integer in current endian 11050func (d *D) FieldScalarS38(name string, sms ...scalar.Mapper) *scalar.S { 11051 s, err := d.TryFieldScalarS38(name, sms...) 11052 if err != nil { 11053 panic(IOError{Err: err, Name: name, Op: "S38", Pos: d.Pos()}) 11054 } 11055 return s 11056} 11057 11058// TryFieldS38 tries to add a field and read 38 bit signed integer in current endian 11059func (d *D) TryFieldS38(name string, sms ...scalar.Mapper) (int64, error) { 11060 s, err := d.TryFieldScalarS38(name, sms...) 11061 return s.ActualS(), err 11062} 11063 11064// FieldS38 adds a field and reads 38 bit signed integer in current endian 11065func (d *D) FieldS38(name string, sms ...scalar.Mapper) int64 { 11066 return d.FieldScalarS38(name, sms...).ActualS() 11067} 11068 11069// Reader S39 11070 11071// TryS39 tries to read 39 bit signed integer in current endian 11072func (d *D) TryS39() (int64, error) { return d.trySE(39, d.Endian) } 11073 11074// S39 reads 39 bit signed integer in current endian 11075func (d *D) S39() int64 { 11076 v, err := d.trySE(39, d.Endian) 11077 if err != nil { 11078 panic(IOError{Err: err, Op: "S39", Pos: d.Pos()}) 11079 } 11080 return v 11081} 11082 11083// TryFieldScalarS39 tries to add a field and read 39 bit signed integer in current endian 11084func (d *D) TryFieldScalarS39(name string, sms ...scalar.Mapper) (*scalar.S, error) { 11085 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 11086 v, err := d.trySE(39, d.Endian) 11087 s.Actual = v 11088 return s, err 11089 }, sms...) 11090 if err != nil { 11091 return nil, err 11092 } 11093 return s, err 11094} 11095 11096// FieldScalarS39 adds a field and reads 39 bit signed integer in current endian 11097func (d *D) FieldScalarS39(name string, sms ...scalar.Mapper) *scalar.S { 11098 s, err := d.TryFieldScalarS39(name, sms...) 11099 if err != nil { 11100 panic(IOError{Err: err, Name: name, Op: "S39", Pos: d.Pos()}) 11101 } 11102 return s 11103} 11104 11105// TryFieldS39 tries to add a field and read 39 bit signed integer in current endian 11106func (d *D) TryFieldS39(name string, sms ...scalar.Mapper) (int64, error) { 11107 s, err := d.TryFieldScalarS39(name, sms...) 11108 return s.ActualS(), err 11109} 11110 11111// FieldS39 adds a field and reads 39 bit signed integer in current endian 11112func (d *D) FieldS39(name string, sms ...scalar.Mapper) int64 { 11113 return d.FieldScalarS39(name, sms...).ActualS() 11114} 11115 11116// Reader S40 11117 11118// TryS40 tries to read 40 bit signed integer in current endian 11119func (d *D) TryS40() (int64, error) { return d.trySE(40, d.Endian) } 11120 11121// S40 reads 40 bit signed integer in current endian 11122func (d *D) S40() int64 { 11123 v, err := d.trySE(40, d.Endian) 11124 if err != nil { 11125 panic(IOError{Err: err, Op: "S40", Pos: d.Pos()}) 11126 } 11127 return v 11128} 11129 11130// TryFieldScalarS40 tries to add a field and read 40 bit signed integer in current endian 11131func (d *D) TryFieldScalarS40(name string, sms ...scalar.Mapper) (*scalar.S, error) { 11132 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 11133 v, err := d.trySE(40, d.Endian) 11134 s.Actual = v 11135 return s, err 11136 }, sms...) 11137 if err != nil { 11138 return nil, err 11139 } 11140 return s, err 11141} 11142 11143// FieldScalarS40 adds a field and reads 40 bit signed integer in current endian 11144func (d *D) FieldScalarS40(name string, sms ...scalar.Mapper) *scalar.S { 11145 s, err := d.TryFieldScalarS40(name, sms...) 11146 if err != nil { 11147 panic(IOError{Err: err, Name: name, Op: "S40", Pos: d.Pos()}) 11148 } 11149 return s 11150} 11151 11152// TryFieldS40 tries to add a field and read 40 bit signed integer in current endian 11153func (d *D) TryFieldS40(name string, sms ...scalar.Mapper) (int64, error) { 11154 s, err := d.TryFieldScalarS40(name, sms...) 11155 return s.ActualS(), err 11156} 11157 11158// FieldS40 adds a field and reads 40 bit signed integer in current endian 11159func (d *D) FieldS40(name string, sms ...scalar.Mapper) int64 { 11160 return d.FieldScalarS40(name, sms...).ActualS() 11161} 11162 11163// Reader S41 11164 11165// TryS41 tries to read 41 bit signed integer in current endian 11166func (d *D) TryS41() (int64, error) { return d.trySE(41, d.Endian) } 11167 11168// S41 reads 41 bit signed integer in current endian 11169func (d *D) S41() int64 { 11170 v, err := d.trySE(41, d.Endian) 11171 if err != nil { 11172 panic(IOError{Err: err, Op: "S41", Pos: d.Pos()}) 11173 } 11174 return v 11175} 11176 11177// TryFieldScalarS41 tries to add a field and read 41 bit signed integer in current endian 11178func (d *D) TryFieldScalarS41(name string, sms ...scalar.Mapper) (*scalar.S, error) { 11179 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 11180 v, err := d.trySE(41, d.Endian) 11181 s.Actual = v 11182 return s, err 11183 }, sms...) 11184 if err != nil { 11185 return nil, err 11186 } 11187 return s, err 11188} 11189 11190// FieldScalarS41 adds a field and reads 41 bit signed integer in current endian 11191func (d *D) FieldScalarS41(name string, sms ...scalar.Mapper) *scalar.S { 11192 s, err := d.TryFieldScalarS41(name, sms...) 11193 if err != nil { 11194 panic(IOError{Err: err, Name: name, Op: "S41", Pos: d.Pos()}) 11195 } 11196 return s 11197} 11198 11199// TryFieldS41 tries to add a field and read 41 bit signed integer in current endian 11200func (d *D) TryFieldS41(name string, sms ...scalar.Mapper) (int64, error) { 11201 s, err := d.TryFieldScalarS41(name, sms...) 11202 return s.ActualS(), err 11203} 11204 11205// FieldS41 adds a field and reads 41 bit signed integer in current endian 11206func (d *D) FieldS41(name string, sms ...scalar.Mapper) int64 { 11207 return d.FieldScalarS41(name, sms...).ActualS() 11208} 11209 11210// Reader S42 11211 11212// TryS42 tries to read 42 bit signed integer in current endian 11213func (d *D) TryS42() (int64, error) { return d.trySE(42, d.Endian) } 11214 11215// S42 reads 42 bit signed integer in current endian 11216func (d *D) S42() int64 { 11217 v, err := d.trySE(42, d.Endian) 11218 if err != nil { 11219 panic(IOError{Err: err, Op: "S42", Pos: d.Pos()}) 11220 } 11221 return v 11222} 11223 11224// TryFieldScalarS42 tries to add a field and read 42 bit signed integer in current endian 11225func (d *D) TryFieldScalarS42(name string, sms ...scalar.Mapper) (*scalar.S, error) { 11226 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 11227 v, err := d.trySE(42, d.Endian) 11228 s.Actual = v 11229 return s, err 11230 }, sms...) 11231 if err != nil { 11232 return nil, err 11233 } 11234 return s, err 11235} 11236 11237// FieldScalarS42 adds a field and reads 42 bit signed integer in current endian 11238func (d *D) FieldScalarS42(name string, sms ...scalar.Mapper) *scalar.S { 11239 s, err := d.TryFieldScalarS42(name, sms...) 11240 if err != nil { 11241 panic(IOError{Err: err, Name: name, Op: "S42", Pos: d.Pos()}) 11242 } 11243 return s 11244} 11245 11246// TryFieldS42 tries to add a field and read 42 bit signed integer in current endian 11247func (d *D) TryFieldS42(name string, sms ...scalar.Mapper) (int64, error) { 11248 s, err := d.TryFieldScalarS42(name, sms...) 11249 return s.ActualS(), err 11250} 11251 11252// FieldS42 adds a field and reads 42 bit signed integer in current endian 11253func (d *D) FieldS42(name string, sms ...scalar.Mapper) int64 { 11254 return d.FieldScalarS42(name, sms...).ActualS() 11255} 11256 11257// Reader S43 11258 11259// TryS43 tries to read 43 bit signed integer in current endian 11260func (d *D) TryS43() (int64, error) { return d.trySE(43, d.Endian) } 11261 11262// S43 reads 43 bit signed integer in current endian 11263func (d *D) S43() int64 { 11264 v, err := d.trySE(43, d.Endian) 11265 if err != nil { 11266 panic(IOError{Err: err, Op: "S43", Pos: d.Pos()}) 11267 } 11268 return v 11269} 11270 11271// TryFieldScalarS43 tries to add a field and read 43 bit signed integer in current endian 11272func (d *D) TryFieldScalarS43(name string, sms ...scalar.Mapper) (*scalar.S, error) { 11273 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 11274 v, err := d.trySE(43, d.Endian) 11275 s.Actual = v 11276 return s, err 11277 }, sms...) 11278 if err != nil { 11279 return nil, err 11280 } 11281 return s, err 11282} 11283 11284// FieldScalarS43 adds a field and reads 43 bit signed integer in current endian 11285func (d *D) FieldScalarS43(name string, sms ...scalar.Mapper) *scalar.S { 11286 s, err := d.TryFieldScalarS43(name, sms...) 11287 if err != nil { 11288 panic(IOError{Err: err, Name: name, Op: "S43", Pos: d.Pos()}) 11289 } 11290 return s 11291} 11292 11293// TryFieldS43 tries to add a field and read 43 bit signed integer in current endian 11294func (d *D) TryFieldS43(name string, sms ...scalar.Mapper) (int64, error) { 11295 s, err := d.TryFieldScalarS43(name, sms...) 11296 return s.ActualS(), err 11297} 11298 11299// FieldS43 adds a field and reads 43 bit signed integer in current endian 11300func (d *D) FieldS43(name string, sms ...scalar.Mapper) int64 { 11301 return d.FieldScalarS43(name, sms...).ActualS() 11302} 11303 11304// Reader S44 11305 11306// TryS44 tries to read 44 bit signed integer in current endian 11307func (d *D) TryS44() (int64, error) { return d.trySE(44, d.Endian) } 11308 11309// S44 reads 44 bit signed integer in current endian 11310func (d *D) S44() int64 { 11311 v, err := d.trySE(44, d.Endian) 11312 if err != nil { 11313 panic(IOError{Err: err, Op: "S44", Pos: d.Pos()}) 11314 } 11315 return v 11316} 11317 11318// TryFieldScalarS44 tries to add a field and read 44 bit signed integer in current endian 11319func (d *D) TryFieldScalarS44(name string, sms ...scalar.Mapper) (*scalar.S, error) { 11320 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 11321 v, err := d.trySE(44, d.Endian) 11322 s.Actual = v 11323 return s, err 11324 }, sms...) 11325 if err != nil { 11326 return nil, err 11327 } 11328 return s, err 11329} 11330 11331// FieldScalarS44 adds a field and reads 44 bit signed integer in current endian 11332func (d *D) FieldScalarS44(name string, sms ...scalar.Mapper) *scalar.S { 11333 s, err := d.TryFieldScalarS44(name, sms...) 11334 if err != nil { 11335 panic(IOError{Err: err, Name: name, Op: "S44", Pos: d.Pos()}) 11336 } 11337 return s 11338} 11339 11340// TryFieldS44 tries to add a field and read 44 bit signed integer in current endian 11341func (d *D) TryFieldS44(name string, sms ...scalar.Mapper) (int64, error) { 11342 s, err := d.TryFieldScalarS44(name, sms...) 11343 return s.ActualS(), err 11344} 11345 11346// FieldS44 adds a field and reads 44 bit signed integer in current endian 11347func (d *D) FieldS44(name string, sms ...scalar.Mapper) int64 { 11348 return d.FieldScalarS44(name, sms...).ActualS() 11349} 11350 11351// Reader S45 11352 11353// TryS45 tries to read 45 bit signed integer in current endian 11354func (d *D) TryS45() (int64, error) { return d.trySE(45, d.Endian) } 11355 11356// S45 reads 45 bit signed integer in current endian 11357func (d *D) S45() int64 { 11358 v, err := d.trySE(45, d.Endian) 11359 if err != nil { 11360 panic(IOError{Err: err, Op: "S45", Pos: d.Pos()}) 11361 } 11362 return v 11363} 11364 11365// TryFieldScalarS45 tries to add a field and read 45 bit signed integer in current endian 11366func (d *D) TryFieldScalarS45(name string, sms ...scalar.Mapper) (*scalar.S, error) { 11367 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 11368 v, err := d.trySE(45, d.Endian) 11369 s.Actual = v 11370 return s, err 11371 }, sms...) 11372 if err != nil { 11373 return nil, err 11374 } 11375 return s, err 11376} 11377 11378// FieldScalarS45 adds a field and reads 45 bit signed integer in current endian 11379func (d *D) FieldScalarS45(name string, sms ...scalar.Mapper) *scalar.S { 11380 s, err := d.TryFieldScalarS45(name, sms...) 11381 if err != nil { 11382 panic(IOError{Err: err, Name: name, Op: "S45", Pos: d.Pos()}) 11383 } 11384 return s 11385} 11386 11387// TryFieldS45 tries to add a field and read 45 bit signed integer in current endian 11388func (d *D) TryFieldS45(name string, sms ...scalar.Mapper) (int64, error) { 11389 s, err := d.TryFieldScalarS45(name, sms...) 11390 return s.ActualS(), err 11391} 11392 11393// FieldS45 adds a field and reads 45 bit signed integer in current endian 11394func (d *D) FieldS45(name string, sms ...scalar.Mapper) int64 { 11395 return d.FieldScalarS45(name, sms...).ActualS() 11396} 11397 11398// Reader S46 11399 11400// TryS46 tries to read 46 bit signed integer in current endian 11401func (d *D) TryS46() (int64, error) { return d.trySE(46, d.Endian) } 11402 11403// S46 reads 46 bit signed integer in current endian 11404func (d *D) S46() int64 { 11405 v, err := d.trySE(46, d.Endian) 11406 if err != nil { 11407 panic(IOError{Err: err, Op: "S46", Pos: d.Pos()}) 11408 } 11409 return v 11410} 11411 11412// TryFieldScalarS46 tries to add a field and read 46 bit signed integer in current endian 11413func (d *D) TryFieldScalarS46(name string, sms ...scalar.Mapper) (*scalar.S, error) { 11414 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 11415 v, err := d.trySE(46, d.Endian) 11416 s.Actual = v 11417 return s, err 11418 }, sms...) 11419 if err != nil { 11420 return nil, err 11421 } 11422 return s, err 11423} 11424 11425// FieldScalarS46 adds a field and reads 46 bit signed integer in current endian 11426func (d *D) FieldScalarS46(name string, sms ...scalar.Mapper) *scalar.S { 11427 s, err := d.TryFieldScalarS46(name, sms...) 11428 if err != nil { 11429 panic(IOError{Err: err, Name: name, Op: "S46", Pos: d.Pos()}) 11430 } 11431 return s 11432} 11433 11434// TryFieldS46 tries to add a field and read 46 bit signed integer in current endian 11435func (d *D) TryFieldS46(name string, sms ...scalar.Mapper) (int64, error) { 11436 s, err := d.TryFieldScalarS46(name, sms...) 11437 return s.ActualS(), err 11438} 11439 11440// FieldS46 adds a field and reads 46 bit signed integer in current endian 11441func (d *D) FieldS46(name string, sms ...scalar.Mapper) int64 { 11442 return d.FieldScalarS46(name, sms...).ActualS() 11443} 11444 11445// Reader S47 11446 11447// TryS47 tries to read 47 bit signed integer in current endian 11448func (d *D) TryS47() (int64, error) { return d.trySE(47, d.Endian) } 11449 11450// S47 reads 47 bit signed integer in current endian 11451func (d *D) S47() int64 { 11452 v, err := d.trySE(47, d.Endian) 11453 if err != nil { 11454 panic(IOError{Err: err, Op: "S47", Pos: d.Pos()}) 11455 } 11456 return v 11457} 11458 11459// TryFieldScalarS47 tries to add a field and read 47 bit signed integer in current endian 11460func (d *D) TryFieldScalarS47(name string, sms ...scalar.Mapper) (*scalar.S, error) { 11461 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 11462 v, err := d.trySE(47, d.Endian) 11463 s.Actual = v 11464 return s, err 11465 }, sms...) 11466 if err != nil { 11467 return nil, err 11468 } 11469 return s, err 11470} 11471 11472// FieldScalarS47 adds a field and reads 47 bit signed integer in current endian 11473func (d *D) FieldScalarS47(name string, sms ...scalar.Mapper) *scalar.S { 11474 s, err := d.TryFieldScalarS47(name, sms...) 11475 if err != nil { 11476 panic(IOError{Err: err, Name: name, Op: "S47", Pos: d.Pos()}) 11477 } 11478 return s 11479} 11480 11481// TryFieldS47 tries to add a field and read 47 bit signed integer in current endian 11482func (d *D) TryFieldS47(name string, sms ...scalar.Mapper) (int64, error) { 11483 s, err := d.TryFieldScalarS47(name, sms...) 11484 return s.ActualS(), err 11485} 11486 11487// FieldS47 adds a field and reads 47 bit signed integer in current endian 11488func (d *D) FieldS47(name string, sms ...scalar.Mapper) int64 { 11489 return d.FieldScalarS47(name, sms...).ActualS() 11490} 11491 11492// Reader S48 11493 11494// TryS48 tries to read 48 bit signed integer in current endian 11495func (d *D) TryS48() (int64, error) { return d.trySE(48, d.Endian) } 11496 11497// S48 reads 48 bit signed integer in current endian 11498func (d *D) S48() int64 { 11499 v, err := d.trySE(48, d.Endian) 11500 if err != nil { 11501 panic(IOError{Err: err, Op: "S48", Pos: d.Pos()}) 11502 } 11503 return v 11504} 11505 11506// TryFieldScalarS48 tries to add a field and read 48 bit signed integer in current endian 11507func (d *D) TryFieldScalarS48(name string, sms ...scalar.Mapper) (*scalar.S, error) { 11508 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 11509 v, err := d.trySE(48, d.Endian) 11510 s.Actual = v 11511 return s, err 11512 }, sms...) 11513 if err != nil { 11514 return nil, err 11515 } 11516 return s, err 11517} 11518 11519// FieldScalarS48 adds a field and reads 48 bit signed integer in current endian 11520func (d *D) FieldScalarS48(name string, sms ...scalar.Mapper) *scalar.S { 11521 s, err := d.TryFieldScalarS48(name, sms...) 11522 if err != nil { 11523 panic(IOError{Err: err, Name: name, Op: "S48", Pos: d.Pos()}) 11524 } 11525 return s 11526} 11527 11528// TryFieldS48 tries to add a field and read 48 bit signed integer in current endian 11529func (d *D) TryFieldS48(name string, sms ...scalar.Mapper) (int64, error) { 11530 s, err := d.TryFieldScalarS48(name, sms...) 11531 return s.ActualS(), err 11532} 11533 11534// FieldS48 adds a field and reads 48 bit signed integer in current endian 11535func (d *D) FieldS48(name string, sms ...scalar.Mapper) int64 { 11536 return d.FieldScalarS48(name, sms...).ActualS() 11537} 11538 11539// Reader S49 11540 11541// TryS49 tries to read 49 bit signed integer in current endian 11542func (d *D) TryS49() (int64, error) { return d.trySE(49, d.Endian) } 11543 11544// S49 reads 49 bit signed integer in current endian 11545func (d *D) S49() int64 { 11546 v, err := d.trySE(49, d.Endian) 11547 if err != nil { 11548 panic(IOError{Err: err, Op: "S49", Pos: d.Pos()}) 11549 } 11550 return v 11551} 11552 11553// TryFieldScalarS49 tries to add a field and read 49 bit signed integer in current endian 11554func (d *D) TryFieldScalarS49(name string, sms ...scalar.Mapper) (*scalar.S, error) { 11555 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 11556 v, err := d.trySE(49, d.Endian) 11557 s.Actual = v 11558 return s, err 11559 }, sms...) 11560 if err != nil { 11561 return nil, err 11562 } 11563 return s, err 11564} 11565 11566// FieldScalarS49 adds a field and reads 49 bit signed integer in current endian 11567func (d *D) FieldScalarS49(name string, sms ...scalar.Mapper) *scalar.S { 11568 s, err := d.TryFieldScalarS49(name, sms...) 11569 if err != nil { 11570 panic(IOError{Err: err, Name: name, Op: "S49", Pos: d.Pos()}) 11571 } 11572 return s 11573} 11574 11575// TryFieldS49 tries to add a field and read 49 bit signed integer in current endian 11576func (d *D) TryFieldS49(name string, sms ...scalar.Mapper) (int64, error) { 11577 s, err := d.TryFieldScalarS49(name, sms...) 11578 return s.ActualS(), err 11579} 11580 11581// FieldS49 adds a field and reads 49 bit signed integer in current endian 11582func (d *D) FieldS49(name string, sms ...scalar.Mapper) int64 { 11583 return d.FieldScalarS49(name, sms...).ActualS() 11584} 11585 11586// Reader S50 11587 11588// TryS50 tries to read 50 bit signed integer in current endian 11589func (d *D) TryS50() (int64, error) { return d.trySE(50, d.Endian) } 11590 11591// S50 reads 50 bit signed integer in current endian 11592func (d *D) S50() int64 { 11593 v, err := d.trySE(50, d.Endian) 11594 if err != nil { 11595 panic(IOError{Err: err, Op: "S50", Pos: d.Pos()}) 11596 } 11597 return v 11598} 11599 11600// TryFieldScalarS50 tries to add a field and read 50 bit signed integer in current endian 11601func (d *D) TryFieldScalarS50(name string, sms ...scalar.Mapper) (*scalar.S, error) { 11602 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 11603 v, err := d.trySE(50, d.Endian) 11604 s.Actual = v 11605 return s, err 11606 }, sms...) 11607 if err != nil { 11608 return nil, err 11609 } 11610 return s, err 11611} 11612 11613// FieldScalarS50 adds a field and reads 50 bit signed integer in current endian 11614func (d *D) FieldScalarS50(name string, sms ...scalar.Mapper) *scalar.S { 11615 s, err := d.TryFieldScalarS50(name, sms...) 11616 if err != nil { 11617 panic(IOError{Err: err, Name: name, Op: "S50", Pos: d.Pos()}) 11618 } 11619 return s 11620} 11621 11622// TryFieldS50 tries to add a field and read 50 bit signed integer in current endian 11623func (d *D) TryFieldS50(name string, sms ...scalar.Mapper) (int64, error) { 11624 s, err := d.TryFieldScalarS50(name, sms...) 11625 return s.ActualS(), err 11626} 11627 11628// FieldS50 adds a field and reads 50 bit signed integer in current endian 11629func (d *D) FieldS50(name string, sms ...scalar.Mapper) int64 { 11630 return d.FieldScalarS50(name, sms...).ActualS() 11631} 11632 11633// Reader S51 11634 11635// TryS51 tries to read 51 bit signed integer in current endian 11636func (d *D) TryS51() (int64, error) { return d.trySE(51, d.Endian) } 11637 11638// S51 reads 51 bit signed integer in current endian 11639func (d *D) S51() int64 { 11640 v, err := d.trySE(51, d.Endian) 11641 if err != nil { 11642 panic(IOError{Err: err, Op: "S51", Pos: d.Pos()}) 11643 } 11644 return v 11645} 11646 11647// TryFieldScalarS51 tries to add a field and read 51 bit signed integer in current endian 11648func (d *D) TryFieldScalarS51(name string, sms ...scalar.Mapper) (*scalar.S, error) { 11649 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 11650 v, err := d.trySE(51, d.Endian) 11651 s.Actual = v 11652 return s, err 11653 }, sms...) 11654 if err != nil { 11655 return nil, err 11656 } 11657 return s, err 11658} 11659 11660// FieldScalarS51 adds a field and reads 51 bit signed integer in current endian 11661func (d *D) FieldScalarS51(name string, sms ...scalar.Mapper) *scalar.S { 11662 s, err := d.TryFieldScalarS51(name, sms...) 11663 if err != nil { 11664 panic(IOError{Err: err, Name: name, Op: "S51", Pos: d.Pos()}) 11665 } 11666 return s 11667} 11668 11669// TryFieldS51 tries to add a field and read 51 bit signed integer in current endian 11670func (d *D) TryFieldS51(name string, sms ...scalar.Mapper) (int64, error) { 11671 s, err := d.TryFieldScalarS51(name, sms...) 11672 return s.ActualS(), err 11673} 11674 11675// FieldS51 adds a field and reads 51 bit signed integer in current endian 11676func (d *D) FieldS51(name string, sms ...scalar.Mapper) int64 { 11677 return d.FieldScalarS51(name, sms...).ActualS() 11678} 11679 11680// Reader S52 11681 11682// TryS52 tries to read 52 bit signed integer in current endian 11683func (d *D) TryS52() (int64, error) { return d.trySE(52, d.Endian) } 11684 11685// S52 reads 52 bit signed integer in current endian 11686func (d *D) S52() int64 { 11687 v, err := d.trySE(52, d.Endian) 11688 if err != nil { 11689 panic(IOError{Err: err, Op: "S52", Pos: d.Pos()}) 11690 } 11691 return v 11692} 11693 11694// TryFieldScalarS52 tries to add a field and read 52 bit signed integer in current endian 11695func (d *D) TryFieldScalarS52(name string, sms ...scalar.Mapper) (*scalar.S, error) { 11696 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 11697 v, err := d.trySE(52, d.Endian) 11698 s.Actual = v 11699 return s, err 11700 }, sms...) 11701 if err != nil { 11702 return nil, err 11703 } 11704 return s, err 11705} 11706 11707// FieldScalarS52 adds a field and reads 52 bit signed integer in current endian 11708func (d *D) FieldScalarS52(name string, sms ...scalar.Mapper) *scalar.S { 11709 s, err := d.TryFieldScalarS52(name, sms...) 11710 if err != nil { 11711 panic(IOError{Err: err, Name: name, Op: "S52", Pos: d.Pos()}) 11712 } 11713 return s 11714} 11715 11716// TryFieldS52 tries to add a field and read 52 bit signed integer in current endian 11717func (d *D) TryFieldS52(name string, sms ...scalar.Mapper) (int64, error) { 11718 s, err := d.TryFieldScalarS52(name, sms...) 11719 return s.ActualS(), err 11720} 11721 11722// FieldS52 adds a field and reads 52 bit signed integer in current endian 11723func (d *D) FieldS52(name string, sms ...scalar.Mapper) int64 { 11724 return d.FieldScalarS52(name, sms...).ActualS() 11725} 11726 11727// Reader S53 11728 11729// TryS53 tries to read 53 bit signed integer in current endian 11730func (d *D) TryS53() (int64, error) { return d.trySE(53, d.Endian) } 11731 11732// S53 reads 53 bit signed integer in current endian 11733func (d *D) S53() int64 { 11734 v, err := d.trySE(53, d.Endian) 11735 if err != nil { 11736 panic(IOError{Err: err, Op: "S53", Pos: d.Pos()}) 11737 } 11738 return v 11739} 11740 11741// TryFieldScalarS53 tries to add a field and read 53 bit signed integer in current endian 11742func (d *D) TryFieldScalarS53(name string, sms ...scalar.Mapper) (*scalar.S, error) { 11743 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 11744 v, err := d.trySE(53, d.Endian) 11745 s.Actual = v 11746 return s, err 11747 }, sms...) 11748 if err != nil { 11749 return nil, err 11750 } 11751 return s, err 11752} 11753 11754// FieldScalarS53 adds a field and reads 53 bit signed integer in current endian 11755func (d *D) FieldScalarS53(name string, sms ...scalar.Mapper) *scalar.S { 11756 s, err := d.TryFieldScalarS53(name, sms...) 11757 if err != nil { 11758 panic(IOError{Err: err, Name: name, Op: "S53", Pos: d.Pos()}) 11759 } 11760 return s 11761} 11762 11763// TryFieldS53 tries to add a field and read 53 bit signed integer in current endian 11764func (d *D) TryFieldS53(name string, sms ...scalar.Mapper) (int64, error) { 11765 s, err := d.TryFieldScalarS53(name, sms...) 11766 return s.ActualS(), err 11767} 11768 11769// FieldS53 adds a field and reads 53 bit signed integer in current endian 11770func (d *D) FieldS53(name string, sms ...scalar.Mapper) int64 { 11771 return d.FieldScalarS53(name, sms...).ActualS() 11772} 11773 11774// Reader S54 11775 11776// TryS54 tries to read 54 bit signed integer in current endian 11777func (d *D) TryS54() (int64, error) { return d.trySE(54, d.Endian) } 11778 11779// S54 reads 54 bit signed integer in current endian 11780func (d *D) S54() int64 { 11781 v, err := d.trySE(54, d.Endian) 11782 if err != nil { 11783 panic(IOError{Err: err, Op: "S54", Pos: d.Pos()}) 11784 } 11785 return v 11786} 11787 11788// TryFieldScalarS54 tries to add a field and read 54 bit signed integer in current endian 11789func (d *D) TryFieldScalarS54(name string, sms ...scalar.Mapper) (*scalar.S, error) { 11790 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 11791 v, err := d.trySE(54, d.Endian) 11792 s.Actual = v 11793 return s, err 11794 }, sms...) 11795 if err != nil { 11796 return nil, err 11797 } 11798 return s, err 11799} 11800 11801// FieldScalarS54 adds a field and reads 54 bit signed integer in current endian 11802func (d *D) FieldScalarS54(name string, sms ...scalar.Mapper) *scalar.S { 11803 s, err := d.TryFieldScalarS54(name, sms...) 11804 if err != nil { 11805 panic(IOError{Err: err, Name: name, Op: "S54", Pos: d.Pos()}) 11806 } 11807 return s 11808} 11809 11810// TryFieldS54 tries to add a field and read 54 bit signed integer in current endian 11811func (d *D) TryFieldS54(name string, sms ...scalar.Mapper) (int64, error) { 11812 s, err := d.TryFieldScalarS54(name, sms...) 11813 return s.ActualS(), err 11814} 11815 11816// FieldS54 adds a field and reads 54 bit signed integer in current endian 11817func (d *D) FieldS54(name string, sms ...scalar.Mapper) int64 { 11818 return d.FieldScalarS54(name, sms...).ActualS() 11819} 11820 11821// Reader S55 11822 11823// TryS55 tries to read 55 bit signed integer in current endian 11824func (d *D) TryS55() (int64, error) { return d.trySE(55, d.Endian) } 11825 11826// S55 reads 55 bit signed integer in current endian 11827func (d *D) S55() int64 { 11828 v, err := d.trySE(55, d.Endian) 11829 if err != nil { 11830 panic(IOError{Err: err, Op: "S55", Pos: d.Pos()}) 11831 } 11832 return v 11833} 11834 11835// TryFieldScalarS55 tries to add a field and read 55 bit signed integer in current endian 11836func (d *D) TryFieldScalarS55(name string, sms ...scalar.Mapper) (*scalar.S, error) { 11837 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 11838 v, err := d.trySE(55, d.Endian) 11839 s.Actual = v 11840 return s, err 11841 }, sms...) 11842 if err != nil { 11843 return nil, err 11844 } 11845 return s, err 11846} 11847 11848// FieldScalarS55 adds a field and reads 55 bit signed integer in current endian 11849func (d *D) FieldScalarS55(name string, sms ...scalar.Mapper) *scalar.S { 11850 s, err := d.TryFieldScalarS55(name, sms...) 11851 if err != nil { 11852 panic(IOError{Err: err, Name: name, Op: "S55", Pos: d.Pos()}) 11853 } 11854 return s 11855} 11856 11857// TryFieldS55 tries to add a field and read 55 bit signed integer in current endian 11858func (d *D) TryFieldS55(name string, sms ...scalar.Mapper) (int64, error) { 11859 s, err := d.TryFieldScalarS55(name, sms...) 11860 return s.ActualS(), err 11861} 11862 11863// FieldS55 adds a field and reads 55 bit signed integer in current endian 11864func (d *D) FieldS55(name string, sms ...scalar.Mapper) int64 { 11865 return d.FieldScalarS55(name, sms...).ActualS() 11866} 11867 11868// Reader S56 11869 11870// TryS56 tries to read 56 bit signed integer in current endian 11871func (d *D) TryS56() (int64, error) { return d.trySE(56, d.Endian) } 11872 11873// S56 reads 56 bit signed integer in current endian 11874func (d *D) S56() int64 { 11875 v, err := d.trySE(56, d.Endian) 11876 if err != nil { 11877 panic(IOError{Err: err, Op: "S56", Pos: d.Pos()}) 11878 } 11879 return v 11880} 11881 11882// TryFieldScalarS56 tries to add a field and read 56 bit signed integer in current endian 11883func (d *D) TryFieldScalarS56(name string, sms ...scalar.Mapper) (*scalar.S, error) { 11884 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 11885 v, err := d.trySE(56, d.Endian) 11886 s.Actual = v 11887 return s, err 11888 }, sms...) 11889 if err != nil { 11890 return nil, err 11891 } 11892 return s, err 11893} 11894 11895// FieldScalarS56 adds a field and reads 56 bit signed integer in current endian 11896func (d *D) FieldScalarS56(name string, sms ...scalar.Mapper) *scalar.S { 11897 s, err := d.TryFieldScalarS56(name, sms...) 11898 if err != nil { 11899 panic(IOError{Err: err, Name: name, Op: "S56", Pos: d.Pos()}) 11900 } 11901 return s 11902} 11903 11904// TryFieldS56 tries to add a field and read 56 bit signed integer in current endian 11905func (d *D) TryFieldS56(name string, sms ...scalar.Mapper) (int64, error) { 11906 s, err := d.TryFieldScalarS56(name, sms...) 11907 return s.ActualS(), err 11908} 11909 11910// FieldS56 adds a field and reads 56 bit signed integer in current endian 11911func (d *D) FieldS56(name string, sms ...scalar.Mapper) int64 { 11912 return d.FieldScalarS56(name, sms...).ActualS() 11913} 11914 11915// Reader S57 11916 11917// TryS57 tries to read 57 bit signed integer in current endian 11918func (d *D) TryS57() (int64, error) { return d.trySE(57, d.Endian) } 11919 11920// S57 reads 57 bit signed integer in current endian 11921func (d *D) S57() int64 { 11922 v, err := d.trySE(57, d.Endian) 11923 if err != nil { 11924 panic(IOError{Err: err, Op: "S57", Pos: d.Pos()}) 11925 } 11926 return v 11927} 11928 11929// TryFieldScalarS57 tries to add a field and read 57 bit signed integer in current endian 11930func (d *D) TryFieldScalarS57(name string, sms ...scalar.Mapper) (*scalar.S, error) { 11931 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 11932 v, err := d.trySE(57, d.Endian) 11933 s.Actual = v 11934 return s, err 11935 }, sms...) 11936 if err != nil { 11937 return nil, err 11938 } 11939 return s, err 11940} 11941 11942// FieldScalarS57 adds a field and reads 57 bit signed integer in current endian 11943func (d *D) FieldScalarS57(name string, sms ...scalar.Mapper) *scalar.S { 11944 s, err := d.TryFieldScalarS57(name, sms...) 11945 if err != nil { 11946 panic(IOError{Err: err, Name: name, Op: "S57", Pos: d.Pos()}) 11947 } 11948 return s 11949} 11950 11951// TryFieldS57 tries to add a field and read 57 bit signed integer in current endian 11952func (d *D) TryFieldS57(name string, sms ...scalar.Mapper) (int64, error) { 11953 s, err := d.TryFieldScalarS57(name, sms...) 11954 return s.ActualS(), err 11955} 11956 11957// FieldS57 adds a field and reads 57 bit signed integer in current endian 11958func (d *D) FieldS57(name string, sms ...scalar.Mapper) int64 { 11959 return d.FieldScalarS57(name, sms...).ActualS() 11960} 11961 11962// Reader S58 11963 11964// TryS58 tries to read 58 bit signed integer in current endian 11965func (d *D) TryS58() (int64, error) { return d.trySE(58, d.Endian) } 11966 11967// S58 reads 58 bit signed integer in current endian 11968func (d *D) S58() int64 { 11969 v, err := d.trySE(58, d.Endian) 11970 if err != nil { 11971 panic(IOError{Err: err, Op: "S58", Pos: d.Pos()}) 11972 } 11973 return v 11974} 11975 11976// TryFieldScalarS58 tries to add a field and read 58 bit signed integer in current endian 11977func (d *D) TryFieldScalarS58(name string, sms ...scalar.Mapper) (*scalar.S, error) { 11978 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 11979 v, err := d.trySE(58, d.Endian) 11980 s.Actual = v 11981 return s, err 11982 }, sms...) 11983 if err != nil { 11984 return nil, err 11985 } 11986 return s, err 11987} 11988 11989// FieldScalarS58 adds a field and reads 58 bit signed integer in current endian 11990func (d *D) FieldScalarS58(name string, sms ...scalar.Mapper) *scalar.S { 11991 s, err := d.TryFieldScalarS58(name, sms...) 11992 if err != nil { 11993 panic(IOError{Err: err, Name: name, Op: "S58", Pos: d.Pos()}) 11994 } 11995 return s 11996} 11997 11998// TryFieldS58 tries to add a field and read 58 bit signed integer in current endian 11999func (d *D) TryFieldS58(name string, sms ...scalar.Mapper) (int64, error) { 12000 s, err := d.TryFieldScalarS58(name, sms...) 12001 return s.ActualS(), err 12002} 12003 12004// FieldS58 adds a field and reads 58 bit signed integer in current endian 12005func (d *D) FieldS58(name string, sms ...scalar.Mapper) int64 { 12006 return d.FieldScalarS58(name, sms...).ActualS() 12007} 12008 12009// Reader S59 12010 12011// TryS59 tries to read 59 bit signed integer in current endian 12012func (d *D) TryS59() (int64, error) { return d.trySE(59, d.Endian) } 12013 12014// S59 reads 59 bit signed integer in current endian 12015func (d *D) S59() int64 { 12016 v, err := d.trySE(59, d.Endian) 12017 if err != nil { 12018 panic(IOError{Err: err, Op: "S59", Pos: d.Pos()}) 12019 } 12020 return v 12021} 12022 12023// TryFieldScalarS59 tries to add a field and read 59 bit signed integer in current endian 12024func (d *D) TryFieldScalarS59(name string, sms ...scalar.Mapper) (*scalar.S, error) { 12025 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 12026 v, err := d.trySE(59, d.Endian) 12027 s.Actual = v 12028 return s, err 12029 }, sms...) 12030 if err != nil { 12031 return nil, err 12032 } 12033 return s, err 12034} 12035 12036// FieldScalarS59 adds a field and reads 59 bit signed integer in current endian 12037func (d *D) FieldScalarS59(name string, sms ...scalar.Mapper) *scalar.S { 12038 s, err := d.TryFieldScalarS59(name, sms...) 12039 if err != nil { 12040 panic(IOError{Err: err, Name: name, Op: "S59", Pos: d.Pos()}) 12041 } 12042 return s 12043} 12044 12045// TryFieldS59 tries to add a field and read 59 bit signed integer in current endian 12046func (d *D) TryFieldS59(name string, sms ...scalar.Mapper) (int64, error) { 12047 s, err := d.TryFieldScalarS59(name, sms...) 12048 return s.ActualS(), err 12049} 12050 12051// FieldS59 adds a field and reads 59 bit signed integer in current endian 12052func (d *D) FieldS59(name string, sms ...scalar.Mapper) int64 { 12053 return d.FieldScalarS59(name, sms...).ActualS() 12054} 12055 12056// Reader S60 12057 12058// TryS60 tries to read 60 bit signed integer in current endian 12059func (d *D) TryS60() (int64, error) { return d.trySE(60, d.Endian) } 12060 12061// S60 reads 60 bit signed integer in current endian 12062func (d *D) S60() int64 { 12063 v, err := d.trySE(60, d.Endian) 12064 if err != nil { 12065 panic(IOError{Err: err, Op: "S60", Pos: d.Pos()}) 12066 } 12067 return v 12068} 12069 12070// TryFieldScalarS60 tries to add a field and read 60 bit signed integer in current endian 12071func (d *D) TryFieldScalarS60(name string, sms ...scalar.Mapper) (*scalar.S, error) { 12072 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 12073 v, err := d.trySE(60, d.Endian) 12074 s.Actual = v 12075 return s, err 12076 }, sms...) 12077 if err != nil { 12078 return nil, err 12079 } 12080 return s, err 12081} 12082 12083// FieldScalarS60 adds a field and reads 60 bit signed integer in current endian 12084func (d *D) FieldScalarS60(name string, sms ...scalar.Mapper) *scalar.S { 12085 s, err := d.TryFieldScalarS60(name, sms...) 12086 if err != nil { 12087 panic(IOError{Err: err, Name: name, Op: "S60", Pos: d.Pos()}) 12088 } 12089 return s 12090} 12091 12092// TryFieldS60 tries to add a field and read 60 bit signed integer in current endian 12093func (d *D) TryFieldS60(name string, sms ...scalar.Mapper) (int64, error) { 12094 s, err := d.TryFieldScalarS60(name, sms...) 12095 return s.ActualS(), err 12096} 12097 12098// FieldS60 adds a field and reads 60 bit signed integer in current endian 12099func (d *D) FieldS60(name string, sms ...scalar.Mapper) int64 { 12100 return d.FieldScalarS60(name, sms...).ActualS() 12101} 12102 12103// Reader S61 12104 12105// TryS61 tries to read 61 bit signed integer in current endian 12106func (d *D) TryS61() (int64, error) { return d.trySE(61, d.Endian) } 12107 12108// S61 reads 61 bit signed integer in current endian 12109func (d *D) S61() int64 { 12110 v, err := d.trySE(61, d.Endian) 12111 if err != nil { 12112 panic(IOError{Err: err, Op: "S61", Pos: d.Pos()}) 12113 } 12114 return v 12115} 12116 12117// TryFieldScalarS61 tries to add a field and read 61 bit signed integer in current endian 12118func (d *D) TryFieldScalarS61(name string, sms ...scalar.Mapper) (*scalar.S, error) { 12119 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 12120 v, err := d.trySE(61, d.Endian) 12121 s.Actual = v 12122 return s, err 12123 }, sms...) 12124 if err != nil { 12125 return nil, err 12126 } 12127 return s, err 12128} 12129 12130// FieldScalarS61 adds a field and reads 61 bit signed integer in current endian 12131func (d *D) FieldScalarS61(name string, sms ...scalar.Mapper) *scalar.S { 12132 s, err := d.TryFieldScalarS61(name, sms...) 12133 if err != nil { 12134 panic(IOError{Err: err, Name: name, Op: "S61", Pos: d.Pos()}) 12135 } 12136 return s 12137} 12138 12139// TryFieldS61 tries to add a field and read 61 bit signed integer in current endian 12140func (d *D) TryFieldS61(name string, sms ...scalar.Mapper) (int64, error) { 12141 s, err := d.TryFieldScalarS61(name, sms...) 12142 return s.ActualS(), err 12143} 12144 12145// FieldS61 adds a field and reads 61 bit signed integer in current endian 12146func (d *D) FieldS61(name string, sms ...scalar.Mapper) int64 { 12147 return d.FieldScalarS61(name, sms...).ActualS() 12148} 12149 12150// Reader S62 12151 12152// TryS62 tries to read 62 bit signed integer in current endian 12153func (d *D) TryS62() (int64, error) { return d.trySE(62, d.Endian) } 12154 12155// S62 reads 62 bit signed integer in current endian 12156func (d *D) S62() int64 { 12157 v, err := d.trySE(62, d.Endian) 12158 if err != nil { 12159 panic(IOError{Err: err, Op: "S62", Pos: d.Pos()}) 12160 } 12161 return v 12162} 12163 12164// TryFieldScalarS62 tries to add a field and read 62 bit signed integer in current endian 12165func (d *D) TryFieldScalarS62(name string, sms ...scalar.Mapper) (*scalar.S, error) { 12166 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 12167 v, err := d.trySE(62, d.Endian) 12168 s.Actual = v 12169 return s, err 12170 }, sms...) 12171 if err != nil { 12172 return nil, err 12173 } 12174 return s, err 12175} 12176 12177// FieldScalarS62 adds a field and reads 62 bit signed integer in current endian 12178func (d *D) FieldScalarS62(name string, sms ...scalar.Mapper) *scalar.S { 12179 s, err := d.TryFieldScalarS62(name, sms...) 12180 if err != nil { 12181 panic(IOError{Err: err, Name: name, Op: "S62", Pos: d.Pos()}) 12182 } 12183 return s 12184} 12185 12186// TryFieldS62 tries to add a field and read 62 bit signed integer in current endian 12187func (d *D) TryFieldS62(name string, sms ...scalar.Mapper) (int64, error) { 12188 s, err := d.TryFieldScalarS62(name, sms...) 12189 return s.ActualS(), err 12190} 12191 12192// FieldS62 adds a field and reads 62 bit signed integer in current endian 12193func (d *D) FieldS62(name string, sms ...scalar.Mapper) int64 { 12194 return d.FieldScalarS62(name, sms...).ActualS() 12195} 12196 12197// Reader S63 12198 12199// TryS63 tries to read 63 bit signed integer in current endian 12200func (d *D) TryS63() (int64, error) { return d.trySE(63, d.Endian) } 12201 12202// S63 reads 63 bit signed integer in current endian 12203func (d *D) S63() int64 { 12204 v, err := d.trySE(63, d.Endian) 12205 if err != nil { 12206 panic(IOError{Err: err, Op: "S63", Pos: d.Pos()}) 12207 } 12208 return v 12209} 12210 12211// TryFieldScalarS63 tries to add a field and read 63 bit signed integer in current endian 12212func (d *D) TryFieldScalarS63(name string, sms ...scalar.Mapper) (*scalar.S, error) { 12213 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 12214 v, err := d.trySE(63, d.Endian) 12215 s.Actual = v 12216 return s, err 12217 }, sms...) 12218 if err != nil { 12219 return nil, err 12220 } 12221 return s, err 12222} 12223 12224// FieldScalarS63 adds a field and reads 63 bit signed integer in current endian 12225func (d *D) FieldScalarS63(name string, sms ...scalar.Mapper) *scalar.S { 12226 s, err := d.TryFieldScalarS63(name, sms...) 12227 if err != nil { 12228 panic(IOError{Err: err, Name: name, Op: "S63", Pos: d.Pos()}) 12229 } 12230 return s 12231} 12232 12233// TryFieldS63 tries to add a field and read 63 bit signed integer in current endian 12234func (d *D) TryFieldS63(name string, sms ...scalar.Mapper) (int64, error) { 12235 s, err := d.TryFieldScalarS63(name, sms...) 12236 return s.ActualS(), err 12237} 12238 12239// FieldS63 adds a field and reads 63 bit signed integer in current endian 12240func (d *D) FieldS63(name string, sms ...scalar.Mapper) int64 { 12241 return d.FieldScalarS63(name, sms...).ActualS() 12242} 12243 12244// Reader S64 12245 12246// TryS64 tries to read 64 bit signed integer in current endian 12247func (d *D) TryS64() (int64, error) { return d.trySE(64, d.Endian) } 12248 12249// S64 reads 64 bit signed integer in current endian 12250func (d *D) S64() int64 { 12251 v, err := d.trySE(64, d.Endian) 12252 if err != nil { 12253 panic(IOError{Err: err, Op: "S64", Pos: d.Pos()}) 12254 } 12255 return v 12256} 12257 12258// TryFieldScalarS64 tries to add a field and read 64 bit signed integer in current endian 12259func (d *D) TryFieldScalarS64(name string, sms ...scalar.Mapper) (*scalar.S, error) { 12260 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 12261 v, err := d.trySE(64, d.Endian) 12262 s.Actual = v 12263 return s, err 12264 }, sms...) 12265 if err != nil { 12266 return nil, err 12267 } 12268 return s, err 12269} 12270 12271// FieldScalarS64 adds a field and reads 64 bit signed integer in current endian 12272func (d *D) FieldScalarS64(name string, sms ...scalar.Mapper) *scalar.S { 12273 s, err := d.TryFieldScalarS64(name, sms...) 12274 if err != nil { 12275 panic(IOError{Err: err, Name: name, Op: "S64", Pos: d.Pos()}) 12276 } 12277 return s 12278} 12279 12280// TryFieldS64 tries to add a field and read 64 bit signed integer in current endian 12281func (d *D) TryFieldS64(name string, sms ...scalar.Mapper) (int64, error) { 12282 s, err := d.TryFieldScalarS64(name, sms...) 12283 return s.ActualS(), err 12284} 12285 12286// FieldS64 adds a field and reads 64 bit signed integer in current endian 12287func (d *D) FieldS64(name string, sms ...scalar.Mapper) int64 { 12288 return d.FieldScalarS64(name, sms...).ActualS() 12289} 12290 12291// Reader S8LE 12292 12293// TryS8LE tries to read 8 bit signed integer in little-endian 12294func (d *D) TryS8LE() (int64, error) { return d.trySE(8, LittleEndian) } 12295 12296// S8LE reads 8 bit signed integer in little-endian 12297func (d *D) S8LE() int64 { 12298 v, err := d.trySE(8, LittleEndian) 12299 if err != nil { 12300 panic(IOError{Err: err, Op: "S8LE", Pos: d.Pos()}) 12301 } 12302 return v 12303} 12304 12305// TryFieldScalarS8LE tries to add a field and read 8 bit signed integer in little-endian 12306func (d *D) TryFieldScalarS8LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 12307 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 12308 v, err := d.trySE(8, LittleEndian) 12309 s.Actual = v 12310 return s, err 12311 }, sms...) 12312 if err != nil { 12313 return nil, err 12314 } 12315 return s, err 12316} 12317 12318// FieldScalarS8LE adds a field and reads 8 bit signed integer in little-endian 12319func (d *D) FieldScalarS8LE(name string, sms ...scalar.Mapper) *scalar.S { 12320 s, err := d.TryFieldScalarS8LE(name, sms...) 12321 if err != nil { 12322 panic(IOError{Err: err, Name: name, Op: "S8LE", Pos: d.Pos()}) 12323 } 12324 return s 12325} 12326 12327// TryFieldS8LE tries to add a field and read 8 bit signed integer in little-endian 12328func (d *D) TryFieldS8LE(name string, sms ...scalar.Mapper) (int64, error) { 12329 s, err := d.TryFieldScalarS8LE(name, sms...) 12330 return s.ActualS(), err 12331} 12332 12333// FieldS8LE adds a field and reads 8 bit signed integer in little-endian 12334func (d *D) FieldS8LE(name string, sms ...scalar.Mapper) int64 { 12335 return d.FieldScalarS8LE(name, sms...).ActualS() 12336} 12337 12338// Reader S9LE 12339 12340// TryS9LE tries to read 9 bit signed integer in little-endian 12341func (d *D) TryS9LE() (int64, error) { return d.trySE(9, LittleEndian) } 12342 12343// S9LE reads 9 bit signed integer in little-endian 12344func (d *D) S9LE() int64 { 12345 v, err := d.trySE(9, LittleEndian) 12346 if err != nil { 12347 panic(IOError{Err: err, Op: "S9LE", Pos: d.Pos()}) 12348 } 12349 return v 12350} 12351 12352// TryFieldScalarS9LE tries to add a field and read 9 bit signed integer in little-endian 12353func (d *D) TryFieldScalarS9LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 12354 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 12355 v, err := d.trySE(9, LittleEndian) 12356 s.Actual = v 12357 return s, err 12358 }, sms...) 12359 if err != nil { 12360 return nil, err 12361 } 12362 return s, err 12363} 12364 12365// FieldScalarS9LE adds a field and reads 9 bit signed integer in little-endian 12366func (d *D) FieldScalarS9LE(name string, sms ...scalar.Mapper) *scalar.S { 12367 s, err := d.TryFieldScalarS9LE(name, sms...) 12368 if err != nil { 12369 panic(IOError{Err: err, Name: name, Op: "S9LE", Pos: d.Pos()}) 12370 } 12371 return s 12372} 12373 12374// TryFieldS9LE tries to add a field and read 9 bit signed integer in little-endian 12375func (d *D) TryFieldS9LE(name string, sms ...scalar.Mapper) (int64, error) { 12376 s, err := d.TryFieldScalarS9LE(name, sms...) 12377 return s.ActualS(), err 12378} 12379 12380// FieldS9LE adds a field and reads 9 bit signed integer in little-endian 12381func (d *D) FieldS9LE(name string, sms ...scalar.Mapper) int64 { 12382 return d.FieldScalarS9LE(name, sms...).ActualS() 12383} 12384 12385// Reader S10LE 12386 12387// TryS10LE tries to read 10 bit signed integer in little-endian 12388func (d *D) TryS10LE() (int64, error) { return d.trySE(10, LittleEndian) } 12389 12390// S10LE reads 10 bit signed integer in little-endian 12391func (d *D) S10LE() int64 { 12392 v, err := d.trySE(10, LittleEndian) 12393 if err != nil { 12394 panic(IOError{Err: err, Op: "S10LE", Pos: d.Pos()}) 12395 } 12396 return v 12397} 12398 12399// TryFieldScalarS10LE tries to add a field and read 10 bit signed integer in little-endian 12400func (d *D) TryFieldScalarS10LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 12401 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 12402 v, err := d.trySE(10, LittleEndian) 12403 s.Actual = v 12404 return s, err 12405 }, sms...) 12406 if err != nil { 12407 return nil, err 12408 } 12409 return s, err 12410} 12411 12412// FieldScalarS10LE adds a field and reads 10 bit signed integer in little-endian 12413func (d *D) FieldScalarS10LE(name string, sms ...scalar.Mapper) *scalar.S { 12414 s, err := d.TryFieldScalarS10LE(name, sms...) 12415 if err != nil { 12416 panic(IOError{Err: err, Name: name, Op: "S10LE", Pos: d.Pos()}) 12417 } 12418 return s 12419} 12420 12421// TryFieldS10LE tries to add a field and read 10 bit signed integer in little-endian 12422func (d *D) TryFieldS10LE(name string, sms ...scalar.Mapper) (int64, error) { 12423 s, err := d.TryFieldScalarS10LE(name, sms...) 12424 return s.ActualS(), err 12425} 12426 12427// FieldS10LE adds a field and reads 10 bit signed integer in little-endian 12428func (d *D) FieldS10LE(name string, sms ...scalar.Mapper) int64 { 12429 return d.FieldScalarS10LE(name, sms...).ActualS() 12430} 12431 12432// Reader S11LE 12433 12434// TryS11LE tries to read 11 bit signed integer in little-endian 12435func (d *D) TryS11LE() (int64, error) { return d.trySE(11, LittleEndian) } 12436 12437// S11LE reads 11 bit signed integer in little-endian 12438func (d *D) S11LE() int64 { 12439 v, err := d.trySE(11, LittleEndian) 12440 if err != nil { 12441 panic(IOError{Err: err, Op: "S11LE", Pos: d.Pos()}) 12442 } 12443 return v 12444} 12445 12446// TryFieldScalarS11LE tries to add a field and read 11 bit signed integer in little-endian 12447func (d *D) TryFieldScalarS11LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 12448 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 12449 v, err := d.trySE(11, LittleEndian) 12450 s.Actual = v 12451 return s, err 12452 }, sms...) 12453 if err != nil { 12454 return nil, err 12455 } 12456 return s, err 12457} 12458 12459// FieldScalarS11LE adds a field and reads 11 bit signed integer in little-endian 12460func (d *D) FieldScalarS11LE(name string, sms ...scalar.Mapper) *scalar.S { 12461 s, err := d.TryFieldScalarS11LE(name, sms...) 12462 if err != nil { 12463 panic(IOError{Err: err, Name: name, Op: "S11LE", Pos: d.Pos()}) 12464 } 12465 return s 12466} 12467 12468// TryFieldS11LE tries to add a field and read 11 bit signed integer in little-endian 12469func (d *D) TryFieldS11LE(name string, sms ...scalar.Mapper) (int64, error) { 12470 s, err := d.TryFieldScalarS11LE(name, sms...) 12471 return s.ActualS(), err 12472} 12473 12474// FieldS11LE adds a field and reads 11 bit signed integer in little-endian 12475func (d *D) FieldS11LE(name string, sms ...scalar.Mapper) int64 { 12476 return d.FieldScalarS11LE(name, sms...).ActualS() 12477} 12478 12479// Reader S12LE 12480 12481// TryS12LE tries to read 12 bit signed integer in little-endian 12482func (d *D) TryS12LE() (int64, error) { return d.trySE(12, LittleEndian) } 12483 12484// S12LE reads 12 bit signed integer in little-endian 12485func (d *D) S12LE() int64 { 12486 v, err := d.trySE(12, LittleEndian) 12487 if err != nil { 12488 panic(IOError{Err: err, Op: "S12LE", Pos: d.Pos()}) 12489 } 12490 return v 12491} 12492 12493// TryFieldScalarS12LE tries to add a field and read 12 bit signed integer in little-endian 12494func (d *D) TryFieldScalarS12LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 12495 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 12496 v, err := d.trySE(12, LittleEndian) 12497 s.Actual = v 12498 return s, err 12499 }, sms...) 12500 if err != nil { 12501 return nil, err 12502 } 12503 return s, err 12504} 12505 12506// FieldScalarS12LE adds a field and reads 12 bit signed integer in little-endian 12507func (d *D) FieldScalarS12LE(name string, sms ...scalar.Mapper) *scalar.S { 12508 s, err := d.TryFieldScalarS12LE(name, sms...) 12509 if err != nil { 12510 panic(IOError{Err: err, Name: name, Op: "S12LE", Pos: d.Pos()}) 12511 } 12512 return s 12513} 12514 12515// TryFieldS12LE tries to add a field and read 12 bit signed integer in little-endian 12516func (d *D) TryFieldS12LE(name string, sms ...scalar.Mapper) (int64, error) { 12517 s, err := d.TryFieldScalarS12LE(name, sms...) 12518 return s.ActualS(), err 12519} 12520 12521// FieldS12LE adds a field and reads 12 bit signed integer in little-endian 12522func (d *D) FieldS12LE(name string, sms ...scalar.Mapper) int64 { 12523 return d.FieldScalarS12LE(name, sms...).ActualS() 12524} 12525 12526// Reader S13LE 12527 12528// TryS13LE tries to read 13 bit signed integer in little-endian 12529func (d *D) TryS13LE() (int64, error) { return d.trySE(13, LittleEndian) } 12530 12531// S13LE reads 13 bit signed integer in little-endian 12532func (d *D) S13LE() int64 { 12533 v, err := d.trySE(13, LittleEndian) 12534 if err != nil { 12535 panic(IOError{Err: err, Op: "S13LE", Pos: d.Pos()}) 12536 } 12537 return v 12538} 12539 12540// TryFieldScalarS13LE tries to add a field and read 13 bit signed integer in little-endian 12541func (d *D) TryFieldScalarS13LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 12542 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 12543 v, err := d.trySE(13, LittleEndian) 12544 s.Actual = v 12545 return s, err 12546 }, sms...) 12547 if err != nil { 12548 return nil, err 12549 } 12550 return s, err 12551} 12552 12553// FieldScalarS13LE adds a field and reads 13 bit signed integer in little-endian 12554func (d *D) FieldScalarS13LE(name string, sms ...scalar.Mapper) *scalar.S { 12555 s, err := d.TryFieldScalarS13LE(name, sms...) 12556 if err != nil { 12557 panic(IOError{Err: err, Name: name, Op: "S13LE", Pos: d.Pos()}) 12558 } 12559 return s 12560} 12561 12562// TryFieldS13LE tries to add a field and read 13 bit signed integer in little-endian 12563func (d *D) TryFieldS13LE(name string, sms ...scalar.Mapper) (int64, error) { 12564 s, err := d.TryFieldScalarS13LE(name, sms...) 12565 return s.ActualS(), err 12566} 12567 12568// FieldS13LE adds a field and reads 13 bit signed integer in little-endian 12569func (d *D) FieldS13LE(name string, sms ...scalar.Mapper) int64 { 12570 return d.FieldScalarS13LE(name, sms...).ActualS() 12571} 12572 12573// Reader S14LE 12574 12575// TryS14LE tries to read 14 bit signed integer in little-endian 12576func (d *D) TryS14LE() (int64, error) { return d.trySE(14, LittleEndian) } 12577 12578// S14LE reads 14 bit signed integer in little-endian 12579func (d *D) S14LE() int64 { 12580 v, err := d.trySE(14, LittleEndian) 12581 if err != nil { 12582 panic(IOError{Err: err, Op: "S14LE", Pos: d.Pos()}) 12583 } 12584 return v 12585} 12586 12587// TryFieldScalarS14LE tries to add a field and read 14 bit signed integer in little-endian 12588func (d *D) TryFieldScalarS14LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 12589 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 12590 v, err := d.trySE(14, LittleEndian) 12591 s.Actual = v 12592 return s, err 12593 }, sms...) 12594 if err != nil { 12595 return nil, err 12596 } 12597 return s, err 12598} 12599 12600// FieldScalarS14LE adds a field and reads 14 bit signed integer in little-endian 12601func (d *D) FieldScalarS14LE(name string, sms ...scalar.Mapper) *scalar.S { 12602 s, err := d.TryFieldScalarS14LE(name, sms...) 12603 if err != nil { 12604 panic(IOError{Err: err, Name: name, Op: "S14LE", Pos: d.Pos()}) 12605 } 12606 return s 12607} 12608 12609// TryFieldS14LE tries to add a field and read 14 bit signed integer in little-endian 12610func (d *D) TryFieldS14LE(name string, sms ...scalar.Mapper) (int64, error) { 12611 s, err := d.TryFieldScalarS14LE(name, sms...) 12612 return s.ActualS(), err 12613} 12614 12615// FieldS14LE adds a field and reads 14 bit signed integer in little-endian 12616func (d *D) FieldS14LE(name string, sms ...scalar.Mapper) int64 { 12617 return d.FieldScalarS14LE(name, sms...).ActualS() 12618} 12619 12620// Reader S15LE 12621 12622// TryS15LE tries to read 15 bit signed integer in little-endian 12623func (d *D) TryS15LE() (int64, error) { return d.trySE(15, LittleEndian) } 12624 12625// S15LE reads 15 bit signed integer in little-endian 12626func (d *D) S15LE() int64 { 12627 v, err := d.trySE(15, LittleEndian) 12628 if err != nil { 12629 panic(IOError{Err: err, Op: "S15LE", Pos: d.Pos()}) 12630 } 12631 return v 12632} 12633 12634// TryFieldScalarS15LE tries to add a field and read 15 bit signed integer in little-endian 12635func (d *D) TryFieldScalarS15LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 12636 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 12637 v, err := d.trySE(15, LittleEndian) 12638 s.Actual = v 12639 return s, err 12640 }, sms...) 12641 if err != nil { 12642 return nil, err 12643 } 12644 return s, err 12645} 12646 12647// FieldScalarS15LE adds a field and reads 15 bit signed integer in little-endian 12648func (d *D) FieldScalarS15LE(name string, sms ...scalar.Mapper) *scalar.S { 12649 s, err := d.TryFieldScalarS15LE(name, sms...) 12650 if err != nil { 12651 panic(IOError{Err: err, Name: name, Op: "S15LE", Pos: d.Pos()}) 12652 } 12653 return s 12654} 12655 12656// TryFieldS15LE tries to add a field and read 15 bit signed integer in little-endian 12657func (d *D) TryFieldS15LE(name string, sms ...scalar.Mapper) (int64, error) { 12658 s, err := d.TryFieldScalarS15LE(name, sms...) 12659 return s.ActualS(), err 12660} 12661 12662// FieldS15LE adds a field and reads 15 bit signed integer in little-endian 12663func (d *D) FieldS15LE(name string, sms ...scalar.Mapper) int64 { 12664 return d.FieldScalarS15LE(name, sms...).ActualS() 12665} 12666 12667// Reader S16LE 12668 12669// TryS16LE tries to read 16 bit signed integer in little-endian 12670func (d *D) TryS16LE() (int64, error) { return d.trySE(16, LittleEndian) } 12671 12672// S16LE reads 16 bit signed integer in little-endian 12673func (d *D) S16LE() int64 { 12674 v, err := d.trySE(16, LittleEndian) 12675 if err != nil { 12676 panic(IOError{Err: err, Op: "S16LE", Pos: d.Pos()}) 12677 } 12678 return v 12679} 12680 12681// TryFieldScalarS16LE tries to add a field and read 16 bit signed integer in little-endian 12682func (d *D) TryFieldScalarS16LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 12683 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 12684 v, err := d.trySE(16, LittleEndian) 12685 s.Actual = v 12686 return s, err 12687 }, sms...) 12688 if err != nil { 12689 return nil, err 12690 } 12691 return s, err 12692} 12693 12694// FieldScalarS16LE adds a field and reads 16 bit signed integer in little-endian 12695func (d *D) FieldScalarS16LE(name string, sms ...scalar.Mapper) *scalar.S { 12696 s, err := d.TryFieldScalarS16LE(name, sms...) 12697 if err != nil { 12698 panic(IOError{Err: err, Name: name, Op: "S16LE", Pos: d.Pos()}) 12699 } 12700 return s 12701} 12702 12703// TryFieldS16LE tries to add a field and read 16 bit signed integer in little-endian 12704func (d *D) TryFieldS16LE(name string, sms ...scalar.Mapper) (int64, error) { 12705 s, err := d.TryFieldScalarS16LE(name, sms...) 12706 return s.ActualS(), err 12707} 12708 12709// FieldS16LE adds a field and reads 16 bit signed integer in little-endian 12710func (d *D) FieldS16LE(name string, sms ...scalar.Mapper) int64 { 12711 return d.FieldScalarS16LE(name, sms...).ActualS() 12712} 12713 12714// Reader S17LE 12715 12716// TryS17LE tries to read 17 bit signed integer in little-endian 12717func (d *D) TryS17LE() (int64, error) { return d.trySE(17, LittleEndian) } 12718 12719// S17LE reads 17 bit signed integer in little-endian 12720func (d *D) S17LE() int64 { 12721 v, err := d.trySE(17, LittleEndian) 12722 if err != nil { 12723 panic(IOError{Err: err, Op: "S17LE", Pos: d.Pos()}) 12724 } 12725 return v 12726} 12727 12728// TryFieldScalarS17LE tries to add a field and read 17 bit signed integer in little-endian 12729func (d *D) TryFieldScalarS17LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 12730 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 12731 v, err := d.trySE(17, LittleEndian) 12732 s.Actual = v 12733 return s, err 12734 }, sms...) 12735 if err != nil { 12736 return nil, err 12737 } 12738 return s, err 12739} 12740 12741// FieldScalarS17LE adds a field and reads 17 bit signed integer in little-endian 12742func (d *D) FieldScalarS17LE(name string, sms ...scalar.Mapper) *scalar.S { 12743 s, err := d.TryFieldScalarS17LE(name, sms...) 12744 if err != nil { 12745 panic(IOError{Err: err, Name: name, Op: "S17LE", Pos: d.Pos()}) 12746 } 12747 return s 12748} 12749 12750// TryFieldS17LE tries to add a field and read 17 bit signed integer in little-endian 12751func (d *D) TryFieldS17LE(name string, sms ...scalar.Mapper) (int64, error) { 12752 s, err := d.TryFieldScalarS17LE(name, sms...) 12753 return s.ActualS(), err 12754} 12755 12756// FieldS17LE adds a field and reads 17 bit signed integer in little-endian 12757func (d *D) FieldS17LE(name string, sms ...scalar.Mapper) int64 { 12758 return d.FieldScalarS17LE(name, sms...).ActualS() 12759} 12760 12761// Reader S18LE 12762 12763// TryS18LE tries to read 18 bit signed integer in little-endian 12764func (d *D) TryS18LE() (int64, error) { return d.trySE(18, LittleEndian) } 12765 12766// S18LE reads 18 bit signed integer in little-endian 12767func (d *D) S18LE() int64 { 12768 v, err := d.trySE(18, LittleEndian) 12769 if err != nil { 12770 panic(IOError{Err: err, Op: "S18LE", Pos: d.Pos()}) 12771 } 12772 return v 12773} 12774 12775// TryFieldScalarS18LE tries to add a field and read 18 bit signed integer in little-endian 12776func (d *D) TryFieldScalarS18LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 12777 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 12778 v, err := d.trySE(18, LittleEndian) 12779 s.Actual = v 12780 return s, err 12781 }, sms...) 12782 if err != nil { 12783 return nil, err 12784 } 12785 return s, err 12786} 12787 12788// FieldScalarS18LE adds a field and reads 18 bit signed integer in little-endian 12789func (d *D) FieldScalarS18LE(name string, sms ...scalar.Mapper) *scalar.S { 12790 s, err := d.TryFieldScalarS18LE(name, sms...) 12791 if err != nil { 12792 panic(IOError{Err: err, Name: name, Op: "S18LE", Pos: d.Pos()}) 12793 } 12794 return s 12795} 12796 12797// TryFieldS18LE tries to add a field and read 18 bit signed integer in little-endian 12798func (d *D) TryFieldS18LE(name string, sms ...scalar.Mapper) (int64, error) { 12799 s, err := d.TryFieldScalarS18LE(name, sms...) 12800 return s.ActualS(), err 12801} 12802 12803// FieldS18LE adds a field and reads 18 bit signed integer in little-endian 12804func (d *D) FieldS18LE(name string, sms ...scalar.Mapper) int64 { 12805 return d.FieldScalarS18LE(name, sms...).ActualS() 12806} 12807 12808// Reader S19LE 12809 12810// TryS19LE tries to read 19 bit signed integer in little-endian 12811func (d *D) TryS19LE() (int64, error) { return d.trySE(19, LittleEndian) } 12812 12813// S19LE reads 19 bit signed integer in little-endian 12814func (d *D) S19LE() int64 { 12815 v, err := d.trySE(19, LittleEndian) 12816 if err != nil { 12817 panic(IOError{Err: err, Op: "S19LE", Pos: d.Pos()}) 12818 } 12819 return v 12820} 12821 12822// TryFieldScalarS19LE tries to add a field and read 19 bit signed integer in little-endian 12823func (d *D) TryFieldScalarS19LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 12824 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 12825 v, err := d.trySE(19, LittleEndian) 12826 s.Actual = v 12827 return s, err 12828 }, sms...) 12829 if err != nil { 12830 return nil, err 12831 } 12832 return s, err 12833} 12834 12835// FieldScalarS19LE adds a field and reads 19 bit signed integer in little-endian 12836func (d *D) FieldScalarS19LE(name string, sms ...scalar.Mapper) *scalar.S { 12837 s, err := d.TryFieldScalarS19LE(name, sms...) 12838 if err != nil { 12839 panic(IOError{Err: err, Name: name, Op: "S19LE", Pos: d.Pos()}) 12840 } 12841 return s 12842} 12843 12844// TryFieldS19LE tries to add a field and read 19 bit signed integer in little-endian 12845func (d *D) TryFieldS19LE(name string, sms ...scalar.Mapper) (int64, error) { 12846 s, err := d.TryFieldScalarS19LE(name, sms...) 12847 return s.ActualS(), err 12848} 12849 12850// FieldS19LE adds a field and reads 19 bit signed integer in little-endian 12851func (d *D) FieldS19LE(name string, sms ...scalar.Mapper) int64 { 12852 return d.FieldScalarS19LE(name, sms...).ActualS() 12853} 12854 12855// Reader S20LE 12856 12857// TryS20LE tries to read 20 bit signed integer in little-endian 12858func (d *D) TryS20LE() (int64, error) { return d.trySE(20, LittleEndian) } 12859 12860// S20LE reads 20 bit signed integer in little-endian 12861func (d *D) S20LE() int64 { 12862 v, err := d.trySE(20, LittleEndian) 12863 if err != nil { 12864 panic(IOError{Err: err, Op: "S20LE", Pos: d.Pos()}) 12865 } 12866 return v 12867} 12868 12869// TryFieldScalarS20LE tries to add a field and read 20 bit signed integer in little-endian 12870func (d *D) TryFieldScalarS20LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 12871 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 12872 v, err := d.trySE(20, LittleEndian) 12873 s.Actual = v 12874 return s, err 12875 }, sms...) 12876 if err != nil { 12877 return nil, err 12878 } 12879 return s, err 12880} 12881 12882// FieldScalarS20LE adds a field and reads 20 bit signed integer in little-endian 12883func (d *D) FieldScalarS20LE(name string, sms ...scalar.Mapper) *scalar.S { 12884 s, err := d.TryFieldScalarS20LE(name, sms...) 12885 if err != nil { 12886 panic(IOError{Err: err, Name: name, Op: "S20LE", Pos: d.Pos()}) 12887 } 12888 return s 12889} 12890 12891// TryFieldS20LE tries to add a field and read 20 bit signed integer in little-endian 12892func (d *D) TryFieldS20LE(name string, sms ...scalar.Mapper) (int64, error) { 12893 s, err := d.TryFieldScalarS20LE(name, sms...) 12894 return s.ActualS(), err 12895} 12896 12897// FieldS20LE adds a field and reads 20 bit signed integer in little-endian 12898func (d *D) FieldS20LE(name string, sms ...scalar.Mapper) int64 { 12899 return d.FieldScalarS20LE(name, sms...).ActualS() 12900} 12901 12902// Reader S21LE 12903 12904// TryS21LE tries to read 21 bit signed integer in little-endian 12905func (d *D) TryS21LE() (int64, error) { return d.trySE(21, LittleEndian) } 12906 12907// S21LE reads 21 bit signed integer in little-endian 12908func (d *D) S21LE() int64 { 12909 v, err := d.trySE(21, LittleEndian) 12910 if err != nil { 12911 panic(IOError{Err: err, Op: "S21LE", Pos: d.Pos()}) 12912 } 12913 return v 12914} 12915 12916// TryFieldScalarS21LE tries to add a field and read 21 bit signed integer in little-endian 12917func (d *D) TryFieldScalarS21LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 12918 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 12919 v, err := d.trySE(21, LittleEndian) 12920 s.Actual = v 12921 return s, err 12922 }, sms...) 12923 if err != nil { 12924 return nil, err 12925 } 12926 return s, err 12927} 12928 12929// FieldScalarS21LE adds a field and reads 21 bit signed integer in little-endian 12930func (d *D) FieldScalarS21LE(name string, sms ...scalar.Mapper) *scalar.S { 12931 s, err := d.TryFieldScalarS21LE(name, sms...) 12932 if err != nil { 12933 panic(IOError{Err: err, Name: name, Op: "S21LE", Pos: d.Pos()}) 12934 } 12935 return s 12936} 12937 12938// TryFieldS21LE tries to add a field and read 21 bit signed integer in little-endian 12939func (d *D) TryFieldS21LE(name string, sms ...scalar.Mapper) (int64, error) { 12940 s, err := d.TryFieldScalarS21LE(name, sms...) 12941 return s.ActualS(), err 12942} 12943 12944// FieldS21LE adds a field and reads 21 bit signed integer in little-endian 12945func (d *D) FieldS21LE(name string, sms ...scalar.Mapper) int64 { 12946 return d.FieldScalarS21LE(name, sms...).ActualS() 12947} 12948 12949// Reader S22LE 12950 12951// TryS22LE tries to read 22 bit signed integer in little-endian 12952func (d *D) TryS22LE() (int64, error) { return d.trySE(22, LittleEndian) } 12953 12954// S22LE reads 22 bit signed integer in little-endian 12955func (d *D) S22LE() int64 { 12956 v, err := d.trySE(22, LittleEndian) 12957 if err != nil { 12958 panic(IOError{Err: err, Op: "S22LE", Pos: d.Pos()}) 12959 } 12960 return v 12961} 12962 12963// TryFieldScalarS22LE tries to add a field and read 22 bit signed integer in little-endian 12964func (d *D) TryFieldScalarS22LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 12965 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 12966 v, err := d.trySE(22, LittleEndian) 12967 s.Actual = v 12968 return s, err 12969 }, sms...) 12970 if err != nil { 12971 return nil, err 12972 } 12973 return s, err 12974} 12975 12976// FieldScalarS22LE adds a field and reads 22 bit signed integer in little-endian 12977func (d *D) FieldScalarS22LE(name string, sms ...scalar.Mapper) *scalar.S { 12978 s, err := d.TryFieldScalarS22LE(name, sms...) 12979 if err != nil { 12980 panic(IOError{Err: err, Name: name, Op: "S22LE", Pos: d.Pos()}) 12981 } 12982 return s 12983} 12984 12985// TryFieldS22LE tries to add a field and read 22 bit signed integer in little-endian 12986func (d *D) TryFieldS22LE(name string, sms ...scalar.Mapper) (int64, error) { 12987 s, err := d.TryFieldScalarS22LE(name, sms...) 12988 return s.ActualS(), err 12989} 12990 12991// FieldS22LE adds a field and reads 22 bit signed integer in little-endian 12992func (d *D) FieldS22LE(name string, sms ...scalar.Mapper) int64 { 12993 return d.FieldScalarS22LE(name, sms...).ActualS() 12994} 12995 12996// Reader S23LE 12997 12998// TryS23LE tries to read 23 bit signed integer in little-endian 12999func (d *D) TryS23LE() (int64, error) { return d.trySE(23, LittleEndian) } 13000 13001// S23LE reads 23 bit signed integer in little-endian 13002func (d *D) S23LE() int64 { 13003 v, err := d.trySE(23, LittleEndian) 13004 if err != nil { 13005 panic(IOError{Err: err, Op: "S23LE", Pos: d.Pos()}) 13006 } 13007 return v 13008} 13009 13010// TryFieldScalarS23LE tries to add a field and read 23 bit signed integer in little-endian 13011func (d *D) TryFieldScalarS23LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 13012 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 13013 v, err := d.trySE(23, LittleEndian) 13014 s.Actual = v 13015 return s, err 13016 }, sms...) 13017 if err != nil { 13018 return nil, err 13019 } 13020 return s, err 13021} 13022 13023// FieldScalarS23LE adds a field and reads 23 bit signed integer in little-endian 13024func (d *D) FieldScalarS23LE(name string, sms ...scalar.Mapper) *scalar.S { 13025 s, err := d.TryFieldScalarS23LE(name, sms...) 13026 if err != nil { 13027 panic(IOError{Err: err, Name: name, Op: "S23LE", Pos: d.Pos()}) 13028 } 13029 return s 13030} 13031 13032// TryFieldS23LE tries to add a field and read 23 bit signed integer in little-endian 13033func (d *D) TryFieldS23LE(name string, sms ...scalar.Mapper) (int64, error) { 13034 s, err := d.TryFieldScalarS23LE(name, sms...) 13035 return s.ActualS(), err 13036} 13037 13038// FieldS23LE adds a field and reads 23 bit signed integer in little-endian 13039func (d *D) FieldS23LE(name string, sms ...scalar.Mapper) int64 { 13040 return d.FieldScalarS23LE(name, sms...).ActualS() 13041} 13042 13043// Reader S24LE 13044 13045// TryS24LE tries to read 24 bit signed integer in little-endian 13046func (d *D) TryS24LE() (int64, error) { return d.trySE(24, LittleEndian) } 13047 13048// S24LE reads 24 bit signed integer in little-endian 13049func (d *D) S24LE() int64 { 13050 v, err := d.trySE(24, LittleEndian) 13051 if err != nil { 13052 panic(IOError{Err: err, Op: "S24LE", Pos: d.Pos()}) 13053 } 13054 return v 13055} 13056 13057// TryFieldScalarS24LE tries to add a field and read 24 bit signed integer in little-endian 13058func (d *D) TryFieldScalarS24LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 13059 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 13060 v, err := d.trySE(24, LittleEndian) 13061 s.Actual = v 13062 return s, err 13063 }, sms...) 13064 if err != nil { 13065 return nil, err 13066 } 13067 return s, err 13068} 13069 13070// FieldScalarS24LE adds a field and reads 24 bit signed integer in little-endian 13071func (d *D) FieldScalarS24LE(name string, sms ...scalar.Mapper) *scalar.S { 13072 s, err := d.TryFieldScalarS24LE(name, sms...) 13073 if err != nil { 13074 panic(IOError{Err: err, Name: name, Op: "S24LE", Pos: d.Pos()}) 13075 } 13076 return s 13077} 13078 13079// TryFieldS24LE tries to add a field and read 24 bit signed integer in little-endian 13080func (d *D) TryFieldS24LE(name string, sms ...scalar.Mapper) (int64, error) { 13081 s, err := d.TryFieldScalarS24LE(name, sms...) 13082 return s.ActualS(), err 13083} 13084 13085// FieldS24LE adds a field and reads 24 bit signed integer in little-endian 13086func (d *D) FieldS24LE(name string, sms ...scalar.Mapper) int64 { 13087 return d.FieldScalarS24LE(name, sms...).ActualS() 13088} 13089 13090// Reader S25LE 13091 13092// TryS25LE tries to read 25 bit signed integer in little-endian 13093func (d *D) TryS25LE() (int64, error) { return d.trySE(25, LittleEndian) } 13094 13095// S25LE reads 25 bit signed integer in little-endian 13096func (d *D) S25LE() int64 { 13097 v, err := d.trySE(25, LittleEndian) 13098 if err != nil { 13099 panic(IOError{Err: err, Op: "S25LE", Pos: d.Pos()}) 13100 } 13101 return v 13102} 13103 13104// TryFieldScalarS25LE tries to add a field and read 25 bit signed integer in little-endian 13105func (d *D) TryFieldScalarS25LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 13106 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 13107 v, err := d.trySE(25, LittleEndian) 13108 s.Actual = v 13109 return s, err 13110 }, sms...) 13111 if err != nil { 13112 return nil, err 13113 } 13114 return s, err 13115} 13116 13117// FieldScalarS25LE adds a field and reads 25 bit signed integer in little-endian 13118func (d *D) FieldScalarS25LE(name string, sms ...scalar.Mapper) *scalar.S { 13119 s, err := d.TryFieldScalarS25LE(name, sms...) 13120 if err != nil { 13121 panic(IOError{Err: err, Name: name, Op: "S25LE", Pos: d.Pos()}) 13122 } 13123 return s 13124} 13125 13126// TryFieldS25LE tries to add a field and read 25 bit signed integer in little-endian 13127func (d *D) TryFieldS25LE(name string, sms ...scalar.Mapper) (int64, error) { 13128 s, err := d.TryFieldScalarS25LE(name, sms...) 13129 return s.ActualS(), err 13130} 13131 13132// FieldS25LE adds a field and reads 25 bit signed integer in little-endian 13133func (d *D) FieldS25LE(name string, sms ...scalar.Mapper) int64 { 13134 return d.FieldScalarS25LE(name, sms...).ActualS() 13135} 13136 13137// Reader S26LE 13138 13139// TryS26LE tries to read 26 bit signed integer in little-endian 13140func (d *D) TryS26LE() (int64, error) { return d.trySE(26, LittleEndian) } 13141 13142// S26LE reads 26 bit signed integer in little-endian 13143func (d *D) S26LE() int64 { 13144 v, err := d.trySE(26, LittleEndian) 13145 if err != nil { 13146 panic(IOError{Err: err, Op: "S26LE", Pos: d.Pos()}) 13147 } 13148 return v 13149} 13150 13151// TryFieldScalarS26LE tries to add a field and read 26 bit signed integer in little-endian 13152func (d *D) TryFieldScalarS26LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 13153 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 13154 v, err := d.trySE(26, LittleEndian) 13155 s.Actual = v 13156 return s, err 13157 }, sms...) 13158 if err != nil { 13159 return nil, err 13160 } 13161 return s, err 13162} 13163 13164// FieldScalarS26LE adds a field and reads 26 bit signed integer in little-endian 13165func (d *D) FieldScalarS26LE(name string, sms ...scalar.Mapper) *scalar.S { 13166 s, err := d.TryFieldScalarS26LE(name, sms...) 13167 if err != nil { 13168 panic(IOError{Err: err, Name: name, Op: "S26LE", Pos: d.Pos()}) 13169 } 13170 return s 13171} 13172 13173// TryFieldS26LE tries to add a field and read 26 bit signed integer in little-endian 13174func (d *D) TryFieldS26LE(name string, sms ...scalar.Mapper) (int64, error) { 13175 s, err := d.TryFieldScalarS26LE(name, sms...) 13176 return s.ActualS(), err 13177} 13178 13179// FieldS26LE adds a field and reads 26 bit signed integer in little-endian 13180func (d *D) FieldS26LE(name string, sms ...scalar.Mapper) int64 { 13181 return d.FieldScalarS26LE(name, sms...).ActualS() 13182} 13183 13184// Reader S27LE 13185 13186// TryS27LE tries to read 27 bit signed integer in little-endian 13187func (d *D) TryS27LE() (int64, error) { return d.trySE(27, LittleEndian) } 13188 13189// S27LE reads 27 bit signed integer in little-endian 13190func (d *D) S27LE() int64 { 13191 v, err := d.trySE(27, LittleEndian) 13192 if err != nil { 13193 panic(IOError{Err: err, Op: "S27LE", Pos: d.Pos()}) 13194 } 13195 return v 13196} 13197 13198// TryFieldScalarS27LE tries to add a field and read 27 bit signed integer in little-endian 13199func (d *D) TryFieldScalarS27LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 13200 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 13201 v, err := d.trySE(27, LittleEndian) 13202 s.Actual = v 13203 return s, err 13204 }, sms...) 13205 if err != nil { 13206 return nil, err 13207 } 13208 return s, err 13209} 13210 13211// FieldScalarS27LE adds a field and reads 27 bit signed integer in little-endian 13212func (d *D) FieldScalarS27LE(name string, sms ...scalar.Mapper) *scalar.S { 13213 s, err := d.TryFieldScalarS27LE(name, sms...) 13214 if err != nil { 13215 panic(IOError{Err: err, Name: name, Op: "S27LE", Pos: d.Pos()}) 13216 } 13217 return s 13218} 13219 13220// TryFieldS27LE tries to add a field and read 27 bit signed integer in little-endian 13221func (d *D) TryFieldS27LE(name string, sms ...scalar.Mapper) (int64, error) { 13222 s, err := d.TryFieldScalarS27LE(name, sms...) 13223 return s.ActualS(), err 13224} 13225 13226// FieldS27LE adds a field and reads 27 bit signed integer in little-endian 13227func (d *D) FieldS27LE(name string, sms ...scalar.Mapper) int64 { 13228 return d.FieldScalarS27LE(name, sms...).ActualS() 13229} 13230 13231// Reader S28LE 13232 13233// TryS28LE tries to read 28 bit signed integer in little-endian 13234func (d *D) TryS28LE() (int64, error) { return d.trySE(28, LittleEndian) } 13235 13236// S28LE reads 28 bit signed integer in little-endian 13237func (d *D) S28LE() int64 { 13238 v, err := d.trySE(28, LittleEndian) 13239 if err != nil { 13240 panic(IOError{Err: err, Op: "S28LE", Pos: d.Pos()}) 13241 } 13242 return v 13243} 13244 13245// TryFieldScalarS28LE tries to add a field and read 28 bit signed integer in little-endian 13246func (d *D) TryFieldScalarS28LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 13247 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 13248 v, err := d.trySE(28, LittleEndian) 13249 s.Actual = v 13250 return s, err 13251 }, sms...) 13252 if err != nil { 13253 return nil, err 13254 } 13255 return s, err 13256} 13257 13258// FieldScalarS28LE adds a field and reads 28 bit signed integer in little-endian 13259func (d *D) FieldScalarS28LE(name string, sms ...scalar.Mapper) *scalar.S { 13260 s, err := d.TryFieldScalarS28LE(name, sms...) 13261 if err != nil { 13262 panic(IOError{Err: err, Name: name, Op: "S28LE", Pos: d.Pos()}) 13263 } 13264 return s 13265} 13266 13267// TryFieldS28LE tries to add a field and read 28 bit signed integer in little-endian 13268func (d *D) TryFieldS28LE(name string, sms ...scalar.Mapper) (int64, error) { 13269 s, err := d.TryFieldScalarS28LE(name, sms...) 13270 return s.ActualS(), err 13271} 13272 13273// FieldS28LE adds a field and reads 28 bit signed integer in little-endian 13274func (d *D) FieldS28LE(name string, sms ...scalar.Mapper) int64 { 13275 return d.FieldScalarS28LE(name, sms...).ActualS() 13276} 13277 13278// Reader S29LE 13279 13280// TryS29LE tries to read 29 bit signed integer in little-endian 13281func (d *D) TryS29LE() (int64, error) { return d.trySE(29, LittleEndian) } 13282 13283// S29LE reads 29 bit signed integer in little-endian 13284func (d *D) S29LE() int64 { 13285 v, err := d.trySE(29, LittleEndian) 13286 if err != nil { 13287 panic(IOError{Err: err, Op: "S29LE", Pos: d.Pos()}) 13288 } 13289 return v 13290} 13291 13292// TryFieldScalarS29LE tries to add a field and read 29 bit signed integer in little-endian 13293func (d *D) TryFieldScalarS29LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 13294 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 13295 v, err := d.trySE(29, LittleEndian) 13296 s.Actual = v 13297 return s, err 13298 }, sms...) 13299 if err != nil { 13300 return nil, err 13301 } 13302 return s, err 13303} 13304 13305// FieldScalarS29LE adds a field and reads 29 bit signed integer in little-endian 13306func (d *D) FieldScalarS29LE(name string, sms ...scalar.Mapper) *scalar.S { 13307 s, err := d.TryFieldScalarS29LE(name, sms...) 13308 if err != nil { 13309 panic(IOError{Err: err, Name: name, Op: "S29LE", Pos: d.Pos()}) 13310 } 13311 return s 13312} 13313 13314// TryFieldS29LE tries to add a field and read 29 bit signed integer in little-endian 13315func (d *D) TryFieldS29LE(name string, sms ...scalar.Mapper) (int64, error) { 13316 s, err := d.TryFieldScalarS29LE(name, sms...) 13317 return s.ActualS(), err 13318} 13319 13320// FieldS29LE adds a field and reads 29 bit signed integer in little-endian 13321func (d *D) FieldS29LE(name string, sms ...scalar.Mapper) int64 { 13322 return d.FieldScalarS29LE(name, sms...).ActualS() 13323} 13324 13325// Reader S30LE 13326 13327// TryS30LE tries to read 30 bit signed integer in little-endian 13328func (d *D) TryS30LE() (int64, error) { return d.trySE(30, LittleEndian) } 13329 13330// S30LE reads 30 bit signed integer in little-endian 13331func (d *D) S30LE() int64 { 13332 v, err := d.trySE(30, LittleEndian) 13333 if err != nil { 13334 panic(IOError{Err: err, Op: "S30LE", Pos: d.Pos()}) 13335 } 13336 return v 13337} 13338 13339// TryFieldScalarS30LE tries to add a field and read 30 bit signed integer in little-endian 13340func (d *D) TryFieldScalarS30LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 13341 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 13342 v, err := d.trySE(30, LittleEndian) 13343 s.Actual = v 13344 return s, err 13345 }, sms...) 13346 if err != nil { 13347 return nil, err 13348 } 13349 return s, err 13350} 13351 13352// FieldScalarS30LE adds a field and reads 30 bit signed integer in little-endian 13353func (d *D) FieldScalarS30LE(name string, sms ...scalar.Mapper) *scalar.S { 13354 s, err := d.TryFieldScalarS30LE(name, sms...) 13355 if err != nil { 13356 panic(IOError{Err: err, Name: name, Op: "S30LE", Pos: d.Pos()}) 13357 } 13358 return s 13359} 13360 13361// TryFieldS30LE tries to add a field and read 30 bit signed integer in little-endian 13362func (d *D) TryFieldS30LE(name string, sms ...scalar.Mapper) (int64, error) { 13363 s, err := d.TryFieldScalarS30LE(name, sms...) 13364 return s.ActualS(), err 13365} 13366 13367// FieldS30LE adds a field and reads 30 bit signed integer in little-endian 13368func (d *D) FieldS30LE(name string, sms ...scalar.Mapper) int64 { 13369 return d.FieldScalarS30LE(name, sms...).ActualS() 13370} 13371 13372// Reader S31LE 13373 13374// TryS31LE tries to read 31 bit signed integer in little-endian 13375func (d *D) TryS31LE() (int64, error) { return d.trySE(31, LittleEndian) } 13376 13377// S31LE reads 31 bit signed integer in little-endian 13378func (d *D) S31LE() int64 { 13379 v, err := d.trySE(31, LittleEndian) 13380 if err != nil { 13381 panic(IOError{Err: err, Op: "S31LE", Pos: d.Pos()}) 13382 } 13383 return v 13384} 13385 13386// TryFieldScalarS31LE tries to add a field and read 31 bit signed integer in little-endian 13387func (d *D) TryFieldScalarS31LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 13388 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 13389 v, err := d.trySE(31, LittleEndian) 13390 s.Actual = v 13391 return s, err 13392 }, sms...) 13393 if err != nil { 13394 return nil, err 13395 } 13396 return s, err 13397} 13398 13399// FieldScalarS31LE adds a field and reads 31 bit signed integer in little-endian 13400func (d *D) FieldScalarS31LE(name string, sms ...scalar.Mapper) *scalar.S { 13401 s, err := d.TryFieldScalarS31LE(name, sms...) 13402 if err != nil { 13403 panic(IOError{Err: err, Name: name, Op: "S31LE", Pos: d.Pos()}) 13404 } 13405 return s 13406} 13407 13408// TryFieldS31LE tries to add a field and read 31 bit signed integer in little-endian 13409func (d *D) TryFieldS31LE(name string, sms ...scalar.Mapper) (int64, error) { 13410 s, err := d.TryFieldScalarS31LE(name, sms...) 13411 return s.ActualS(), err 13412} 13413 13414// FieldS31LE adds a field and reads 31 bit signed integer in little-endian 13415func (d *D) FieldS31LE(name string, sms ...scalar.Mapper) int64 { 13416 return d.FieldScalarS31LE(name, sms...).ActualS() 13417} 13418 13419// Reader S32LE 13420 13421// TryS32LE tries to read 32 bit signed integer in little-endian 13422func (d *D) TryS32LE() (int64, error) { return d.trySE(32, LittleEndian) } 13423 13424// S32LE reads 32 bit signed integer in little-endian 13425func (d *D) S32LE() int64 { 13426 v, err := d.trySE(32, LittleEndian) 13427 if err != nil { 13428 panic(IOError{Err: err, Op: "S32LE", Pos: d.Pos()}) 13429 } 13430 return v 13431} 13432 13433// TryFieldScalarS32LE tries to add a field and read 32 bit signed integer in little-endian 13434func (d *D) TryFieldScalarS32LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 13435 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 13436 v, err := d.trySE(32, LittleEndian) 13437 s.Actual = v 13438 return s, err 13439 }, sms...) 13440 if err != nil { 13441 return nil, err 13442 } 13443 return s, err 13444} 13445 13446// FieldScalarS32LE adds a field and reads 32 bit signed integer in little-endian 13447func (d *D) FieldScalarS32LE(name string, sms ...scalar.Mapper) *scalar.S { 13448 s, err := d.TryFieldScalarS32LE(name, sms...) 13449 if err != nil { 13450 panic(IOError{Err: err, Name: name, Op: "S32LE", Pos: d.Pos()}) 13451 } 13452 return s 13453} 13454 13455// TryFieldS32LE tries to add a field and read 32 bit signed integer in little-endian 13456func (d *D) TryFieldS32LE(name string, sms ...scalar.Mapper) (int64, error) { 13457 s, err := d.TryFieldScalarS32LE(name, sms...) 13458 return s.ActualS(), err 13459} 13460 13461// FieldS32LE adds a field and reads 32 bit signed integer in little-endian 13462func (d *D) FieldS32LE(name string, sms ...scalar.Mapper) int64 { 13463 return d.FieldScalarS32LE(name, sms...).ActualS() 13464} 13465 13466// Reader S33LE 13467 13468// TryS33LE tries to read 33 bit signed integer in little-endian 13469func (d *D) TryS33LE() (int64, error) { return d.trySE(33, LittleEndian) } 13470 13471// S33LE reads 33 bit signed integer in little-endian 13472func (d *D) S33LE() int64 { 13473 v, err := d.trySE(33, LittleEndian) 13474 if err != nil { 13475 panic(IOError{Err: err, Op: "S33LE", Pos: d.Pos()}) 13476 } 13477 return v 13478} 13479 13480// TryFieldScalarS33LE tries to add a field and read 33 bit signed integer in little-endian 13481func (d *D) TryFieldScalarS33LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 13482 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 13483 v, err := d.trySE(33, LittleEndian) 13484 s.Actual = v 13485 return s, err 13486 }, sms...) 13487 if err != nil { 13488 return nil, err 13489 } 13490 return s, err 13491} 13492 13493// FieldScalarS33LE adds a field and reads 33 bit signed integer in little-endian 13494func (d *D) FieldScalarS33LE(name string, sms ...scalar.Mapper) *scalar.S { 13495 s, err := d.TryFieldScalarS33LE(name, sms...) 13496 if err != nil { 13497 panic(IOError{Err: err, Name: name, Op: "S33LE", Pos: d.Pos()}) 13498 } 13499 return s 13500} 13501 13502// TryFieldS33LE tries to add a field and read 33 bit signed integer in little-endian 13503func (d *D) TryFieldS33LE(name string, sms ...scalar.Mapper) (int64, error) { 13504 s, err := d.TryFieldScalarS33LE(name, sms...) 13505 return s.ActualS(), err 13506} 13507 13508// FieldS33LE adds a field and reads 33 bit signed integer in little-endian 13509func (d *D) FieldS33LE(name string, sms ...scalar.Mapper) int64 { 13510 return d.FieldScalarS33LE(name, sms...).ActualS() 13511} 13512 13513// Reader S34LE 13514 13515// TryS34LE tries to read 34 bit signed integer in little-endian 13516func (d *D) TryS34LE() (int64, error) { return d.trySE(34, LittleEndian) } 13517 13518// S34LE reads 34 bit signed integer in little-endian 13519func (d *D) S34LE() int64 { 13520 v, err := d.trySE(34, LittleEndian) 13521 if err != nil { 13522 panic(IOError{Err: err, Op: "S34LE", Pos: d.Pos()}) 13523 } 13524 return v 13525} 13526 13527// TryFieldScalarS34LE tries to add a field and read 34 bit signed integer in little-endian 13528func (d *D) TryFieldScalarS34LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 13529 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 13530 v, err := d.trySE(34, LittleEndian) 13531 s.Actual = v 13532 return s, err 13533 }, sms...) 13534 if err != nil { 13535 return nil, err 13536 } 13537 return s, err 13538} 13539 13540// FieldScalarS34LE adds a field and reads 34 bit signed integer in little-endian 13541func (d *D) FieldScalarS34LE(name string, sms ...scalar.Mapper) *scalar.S { 13542 s, err := d.TryFieldScalarS34LE(name, sms...) 13543 if err != nil { 13544 panic(IOError{Err: err, Name: name, Op: "S34LE", Pos: d.Pos()}) 13545 } 13546 return s 13547} 13548 13549// TryFieldS34LE tries to add a field and read 34 bit signed integer in little-endian 13550func (d *D) TryFieldS34LE(name string, sms ...scalar.Mapper) (int64, error) { 13551 s, err := d.TryFieldScalarS34LE(name, sms...) 13552 return s.ActualS(), err 13553} 13554 13555// FieldS34LE adds a field and reads 34 bit signed integer in little-endian 13556func (d *D) FieldS34LE(name string, sms ...scalar.Mapper) int64 { 13557 return d.FieldScalarS34LE(name, sms...).ActualS() 13558} 13559 13560// Reader S35LE 13561 13562// TryS35LE tries to read 35 bit signed integer in little-endian 13563func (d *D) TryS35LE() (int64, error) { return d.trySE(35, LittleEndian) } 13564 13565// S35LE reads 35 bit signed integer in little-endian 13566func (d *D) S35LE() int64 { 13567 v, err := d.trySE(35, LittleEndian) 13568 if err != nil { 13569 panic(IOError{Err: err, Op: "S35LE", Pos: d.Pos()}) 13570 } 13571 return v 13572} 13573 13574// TryFieldScalarS35LE tries to add a field and read 35 bit signed integer in little-endian 13575func (d *D) TryFieldScalarS35LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 13576 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 13577 v, err := d.trySE(35, LittleEndian) 13578 s.Actual = v 13579 return s, err 13580 }, sms...) 13581 if err != nil { 13582 return nil, err 13583 } 13584 return s, err 13585} 13586 13587// FieldScalarS35LE adds a field and reads 35 bit signed integer in little-endian 13588func (d *D) FieldScalarS35LE(name string, sms ...scalar.Mapper) *scalar.S { 13589 s, err := d.TryFieldScalarS35LE(name, sms...) 13590 if err != nil { 13591 panic(IOError{Err: err, Name: name, Op: "S35LE", Pos: d.Pos()}) 13592 } 13593 return s 13594} 13595 13596// TryFieldS35LE tries to add a field and read 35 bit signed integer in little-endian 13597func (d *D) TryFieldS35LE(name string, sms ...scalar.Mapper) (int64, error) { 13598 s, err := d.TryFieldScalarS35LE(name, sms...) 13599 return s.ActualS(), err 13600} 13601 13602// FieldS35LE adds a field and reads 35 bit signed integer in little-endian 13603func (d *D) FieldS35LE(name string, sms ...scalar.Mapper) int64 { 13604 return d.FieldScalarS35LE(name, sms...).ActualS() 13605} 13606 13607// Reader S36LE 13608 13609// TryS36LE tries to read 36 bit signed integer in little-endian 13610func (d *D) TryS36LE() (int64, error) { return d.trySE(36, LittleEndian) } 13611 13612// S36LE reads 36 bit signed integer in little-endian 13613func (d *D) S36LE() int64 { 13614 v, err := d.trySE(36, LittleEndian) 13615 if err != nil { 13616 panic(IOError{Err: err, Op: "S36LE", Pos: d.Pos()}) 13617 } 13618 return v 13619} 13620 13621// TryFieldScalarS36LE tries to add a field and read 36 bit signed integer in little-endian 13622func (d *D) TryFieldScalarS36LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 13623 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 13624 v, err := d.trySE(36, LittleEndian) 13625 s.Actual = v 13626 return s, err 13627 }, sms...) 13628 if err != nil { 13629 return nil, err 13630 } 13631 return s, err 13632} 13633 13634// FieldScalarS36LE adds a field and reads 36 bit signed integer in little-endian 13635func (d *D) FieldScalarS36LE(name string, sms ...scalar.Mapper) *scalar.S { 13636 s, err := d.TryFieldScalarS36LE(name, sms...) 13637 if err != nil { 13638 panic(IOError{Err: err, Name: name, Op: "S36LE", Pos: d.Pos()}) 13639 } 13640 return s 13641} 13642 13643// TryFieldS36LE tries to add a field and read 36 bit signed integer in little-endian 13644func (d *D) TryFieldS36LE(name string, sms ...scalar.Mapper) (int64, error) { 13645 s, err := d.TryFieldScalarS36LE(name, sms...) 13646 return s.ActualS(), err 13647} 13648 13649// FieldS36LE adds a field and reads 36 bit signed integer in little-endian 13650func (d *D) FieldS36LE(name string, sms ...scalar.Mapper) int64 { 13651 return d.FieldScalarS36LE(name, sms...).ActualS() 13652} 13653 13654// Reader S37LE 13655 13656// TryS37LE tries to read 37 bit signed integer in little-endian 13657func (d *D) TryS37LE() (int64, error) { return d.trySE(37, LittleEndian) } 13658 13659// S37LE reads 37 bit signed integer in little-endian 13660func (d *D) S37LE() int64 { 13661 v, err := d.trySE(37, LittleEndian) 13662 if err != nil { 13663 panic(IOError{Err: err, Op: "S37LE", Pos: d.Pos()}) 13664 } 13665 return v 13666} 13667 13668// TryFieldScalarS37LE tries to add a field and read 37 bit signed integer in little-endian 13669func (d *D) TryFieldScalarS37LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 13670 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 13671 v, err := d.trySE(37, LittleEndian) 13672 s.Actual = v 13673 return s, err 13674 }, sms...) 13675 if err != nil { 13676 return nil, err 13677 } 13678 return s, err 13679} 13680 13681// FieldScalarS37LE adds a field and reads 37 bit signed integer in little-endian 13682func (d *D) FieldScalarS37LE(name string, sms ...scalar.Mapper) *scalar.S { 13683 s, err := d.TryFieldScalarS37LE(name, sms...) 13684 if err != nil { 13685 panic(IOError{Err: err, Name: name, Op: "S37LE", Pos: d.Pos()}) 13686 } 13687 return s 13688} 13689 13690// TryFieldS37LE tries to add a field and read 37 bit signed integer in little-endian 13691func (d *D) TryFieldS37LE(name string, sms ...scalar.Mapper) (int64, error) { 13692 s, err := d.TryFieldScalarS37LE(name, sms...) 13693 return s.ActualS(), err 13694} 13695 13696// FieldS37LE adds a field and reads 37 bit signed integer in little-endian 13697func (d *D) FieldS37LE(name string, sms ...scalar.Mapper) int64 { 13698 return d.FieldScalarS37LE(name, sms...).ActualS() 13699} 13700 13701// Reader S38LE 13702 13703// TryS38LE tries to read 38 bit signed integer in little-endian 13704func (d *D) TryS38LE() (int64, error) { return d.trySE(38, LittleEndian) } 13705 13706// S38LE reads 38 bit signed integer in little-endian 13707func (d *D) S38LE() int64 { 13708 v, err := d.trySE(38, LittleEndian) 13709 if err != nil { 13710 panic(IOError{Err: err, Op: "S38LE", Pos: d.Pos()}) 13711 } 13712 return v 13713} 13714 13715// TryFieldScalarS38LE tries to add a field and read 38 bit signed integer in little-endian 13716func (d *D) TryFieldScalarS38LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 13717 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 13718 v, err := d.trySE(38, LittleEndian) 13719 s.Actual = v 13720 return s, err 13721 }, sms...) 13722 if err != nil { 13723 return nil, err 13724 } 13725 return s, err 13726} 13727 13728// FieldScalarS38LE adds a field and reads 38 bit signed integer in little-endian 13729func (d *D) FieldScalarS38LE(name string, sms ...scalar.Mapper) *scalar.S { 13730 s, err := d.TryFieldScalarS38LE(name, sms...) 13731 if err != nil { 13732 panic(IOError{Err: err, Name: name, Op: "S38LE", Pos: d.Pos()}) 13733 } 13734 return s 13735} 13736 13737// TryFieldS38LE tries to add a field and read 38 bit signed integer in little-endian 13738func (d *D) TryFieldS38LE(name string, sms ...scalar.Mapper) (int64, error) { 13739 s, err := d.TryFieldScalarS38LE(name, sms...) 13740 return s.ActualS(), err 13741} 13742 13743// FieldS38LE adds a field and reads 38 bit signed integer in little-endian 13744func (d *D) FieldS38LE(name string, sms ...scalar.Mapper) int64 { 13745 return d.FieldScalarS38LE(name, sms...).ActualS() 13746} 13747 13748// Reader S39LE 13749 13750// TryS39LE tries to read 39 bit signed integer in little-endian 13751func (d *D) TryS39LE() (int64, error) { return d.trySE(39, LittleEndian) } 13752 13753// S39LE reads 39 bit signed integer in little-endian 13754func (d *D) S39LE() int64 { 13755 v, err := d.trySE(39, LittleEndian) 13756 if err != nil { 13757 panic(IOError{Err: err, Op: "S39LE", Pos: d.Pos()}) 13758 } 13759 return v 13760} 13761 13762// TryFieldScalarS39LE tries to add a field and read 39 bit signed integer in little-endian 13763func (d *D) TryFieldScalarS39LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 13764 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 13765 v, err := d.trySE(39, LittleEndian) 13766 s.Actual = v 13767 return s, err 13768 }, sms...) 13769 if err != nil { 13770 return nil, err 13771 } 13772 return s, err 13773} 13774 13775// FieldScalarS39LE adds a field and reads 39 bit signed integer in little-endian 13776func (d *D) FieldScalarS39LE(name string, sms ...scalar.Mapper) *scalar.S { 13777 s, err := d.TryFieldScalarS39LE(name, sms...) 13778 if err != nil { 13779 panic(IOError{Err: err, Name: name, Op: "S39LE", Pos: d.Pos()}) 13780 } 13781 return s 13782} 13783 13784// TryFieldS39LE tries to add a field and read 39 bit signed integer in little-endian 13785func (d *D) TryFieldS39LE(name string, sms ...scalar.Mapper) (int64, error) { 13786 s, err := d.TryFieldScalarS39LE(name, sms...) 13787 return s.ActualS(), err 13788} 13789 13790// FieldS39LE adds a field and reads 39 bit signed integer in little-endian 13791func (d *D) FieldS39LE(name string, sms ...scalar.Mapper) int64 { 13792 return d.FieldScalarS39LE(name, sms...).ActualS() 13793} 13794 13795// Reader S40LE 13796 13797// TryS40LE tries to read 40 bit signed integer in little-endian 13798func (d *D) TryS40LE() (int64, error) { return d.trySE(40, LittleEndian) } 13799 13800// S40LE reads 40 bit signed integer in little-endian 13801func (d *D) S40LE() int64 { 13802 v, err := d.trySE(40, LittleEndian) 13803 if err != nil { 13804 panic(IOError{Err: err, Op: "S40LE", Pos: d.Pos()}) 13805 } 13806 return v 13807} 13808 13809// TryFieldScalarS40LE tries to add a field and read 40 bit signed integer in little-endian 13810func (d *D) TryFieldScalarS40LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 13811 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 13812 v, err := d.trySE(40, LittleEndian) 13813 s.Actual = v 13814 return s, err 13815 }, sms...) 13816 if err != nil { 13817 return nil, err 13818 } 13819 return s, err 13820} 13821 13822// FieldScalarS40LE adds a field and reads 40 bit signed integer in little-endian 13823func (d *D) FieldScalarS40LE(name string, sms ...scalar.Mapper) *scalar.S { 13824 s, err := d.TryFieldScalarS40LE(name, sms...) 13825 if err != nil { 13826 panic(IOError{Err: err, Name: name, Op: "S40LE", Pos: d.Pos()}) 13827 } 13828 return s 13829} 13830 13831// TryFieldS40LE tries to add a field and read 40 bit signed integer in little-endian 13832func (d *D) TryFieldS40LE(name string, sms ...scalar.Mapper) (int64, error) { 13833 s, err := d.TryFieldScalarS40LE(name, sms...) 13834 return s.ActualS(), err 13835} 13836 13837// FieldS40LE adds a field and reads 40 bit signed integer in little-endian 13838func (d *D) FieldS40LE(name string, sms ...scalar.Mapper) int64 { 13839 return d.FieldScalarS40LE(name, sms...).ActualS() 13840} 13841 13842// Reader S41LE 13843 13844// TryS41LE tries to read 41 bit signed integer in little-endian 13845func (d *D) TryS41LE() (int64, error) { return d.trySE(41, LittleEndian) } 13846 13847// S41LE reads 41 bit signed integer in little-endian 13848func (d *D) S41LE() int64 { 13849 v, err := d.trySE(41, LittleEndian) 13850 if err != nil { 13851 panic(IOError{Err: err, Op: "S41LE", Pos: d.Pos()}) 13852 } 13853 return v 13854} 13855 13856// TryFieldScalarS41LE tries to add a field and read 41 bit signed integer in little-endian 13857func (d *D) TryFieldScalarS41LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 13858 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 13859 v, err := d.trySE(41, LittleEndian) 13860 s.Actual = v 13861 return s, err 13862 }, sms...) 13863 if err != nil { 13864 return nil, err 13865 } 13866 return s, err 13867} 13868 13869// FieldScalarS41LE adds a field and reads 41 bit signed integer in little-endian 13870func (d *D) FieldScalarS41LE(name string, sms ...scalar.Mapper) *scalar.S { 13871 s, err := d.TryFieldScalarS41LE(name, sms...) 13872 if err != nil { 13873 panic(IOError{Err: err, Name: name, Op: "S41LE", Pos: d.Pos()}) 13874 } 13875 return s 13876} 13877 13878// TryFieldS41LE tries to add a field and read 41 bit signed integer in little-endian 13879func (d *D) TryFieldS41LE(name string, sms ...scalar.Mapper) (int64, error) { 13880 s, err := d.TryFieldScalarS41LE(name, sms...) 13881 return s.ActualS(), err 13882} 13883 13884// FieldS41LE adds a field and reads 41 bit signed integer in little-endian 13885func (d *D) FieldS41LE(name string, sms ...scalar.Mapper) int64 { 13886 return d.FieldScalarS41LE(name, sms...).ActualS() 13887} 13888 13889// Reader S42LE 13890 13891// TryS42LE tries to read 42 bit signed integer in little-endian 13892func (d *D) TryS42LE() (int64, error) { return d.trySE(42, LittleEndian) } 13893 13894// S42LE reads 42 bit signed integer in little-endian 13895func (d *D) S42LE() int64 { 13896 v, err := d.trySE(42, LittleEndian) 13897 if err != nil { 13898 panic(IOError{Err: err, Op: "S42LE", Pos: d.Pos()}) 13899 } 13900 return v 13901} 13902 13903// TryFieldScalarS42LE tries to add a field and read 42 bit signed integer in little-endian 13904func (d *D) TryFieldScalarS42LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 13905 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 13906 v, err := d.trySE(42, LittleEndian) 13907 s.Actual = v 13908 return s, err 13909 }, sms...) 13910 if err != nil { 13911 return nil, err 13912 } 13913 return s, err 13914} 13915 13916// FieldScalarS42LE adds a field and reads 42 bit signed integer in little-endian 13917func (d *D) FieldScalarS42LE(name string, sms ...scalar.Mapper) *scalar.S { 13918 s, err := d.TryFieldScalarS42LE(name, sms...) 13919 if err != nil { 13920 panic(IOError{Err: err, Name: name, Op: "S42LE", Pos: d.Pos()}) 13921 } 13922 return s 13923} 13924 13925// TryFieldS42LE tries to add a field and read 42 bit signed integer in little-endian 13926func (d *D) TryFieldS42LE(name string, sms ...scalar.Mapper) (int64, error) { 13927 s, err := d.TryFieldScalarS42LE(name, sms...) 13928 return s.ActualS(), err 13929} 13930 13931// FieldS42LE adds a field and reads 42 bit signed integer in little-endian 13932func (d *D) FieldS42LE(name string, sms ...scalar.Mapper) int64 { 13933 return d.FieldScalarS42LE(name, sms...).ActualS() 13934} 13935 13936// Reader S43LE 13937 13938// TryS43LE tries to read 43 bit signed integer in little-endian 13939func (d *D) TryS43LE() (int64, error) { return d.trySE(43, LittleEndian) } 13940 13941// S43LE reads 43 bit signed integer in little-endian 13942func (d *D) S43LE() int64 { 13943 v, err := d.trySE(43, LittleEndian) 13944 if err != nil { 13945 panic(IOError{Err: err, Op: "S43LE", Pos: d.Pos()}) 13946 } 13947 return v 13948} 13949 13950// TryFieldScalarS43LE tries to add a field and read 43 bit signed integer in little-endian 13951func (d *D) TryFieldScalarS43LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 13952 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 13953 v, err := d.trySE(43, LittleEndian) 13954 s.Actual = v 13955 return s, err 13956 }, sms...) 13957 if err != nil { 13958 return nil, err 13959 } 13960 return s, err 13961} 13962 13963// FieldScalarS43LE adds a field and reads 43 bit signed integer in little-endian 13964func (d *D) FieldScalarS43LE(name string, sms ...scalar.Mapper) *scalar.S { 13965 s, err := d.TryFieldScalarS43LE(name, sms...) 13966 if err != nil { 13967 panic(IOError{Err: err, Name: name, Op: "S43LE", Pos: d.Pos()}) 13968 } 13969 return s 13970} 13971 13972// TryFieldS43LE tries to add a field and read 43 bit signed integer in little-endian 13973func (d *D) TryFieldS43LE(name string, sms ...scalar.Mapper) (int64, error) { 13974 s, err := d.TryFieldScalarS43LE(name, sms...) 13975 return s.ActualS(), err 13976} 13977 13978// FieldS43LE adds a field and reads 43 bit signed integer in little-endian 13979func (d *D) FieldS43LE(name string, sms ...scalar.Mapper) int64 { 13980 return d.FieldScalarS43LE(name, sms...).ActualS() 13981} 13982 13983// Reader S44LE 13984 13985// TryS44LE tries to read 44 bit signed integer in little-endian 13986func (d *D) TryS44LE() (int64, error) { return d.trySE(44, LittleEndian) } 13987 13988// S44LE reads 44 bit signed integer in little-endian 13989func (d *D) S44LE() int64 { 13990 v, err := d.trySE(44, LittleEndian) 13991 if err != nil { 13992 panic(IOError{Err: err, Op: "S44LE", Pos: d.Pos()}) 13993 } 13994 return v 13995} 13996 13997// TryFieldScalarS44LE tries to add a field and read 44 bit signed integer in little-endian 13998func (d *D) TryFieldScalarS44LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 13999 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 14000 v, err := d.trySE(44, LittleEndian) 14001 s.Actual = v 14002 return s, err 14003 }, sms...) 14004 if err != nil { 14005 return nil, err 14006 } 14007 return s, err 14008} 14009 14010// FieldScalarS44LE adds a field and reads 44 bit signed integer in little-endian 14011func (d *D) FieldScalarS44LE(name string, sms ...scalar.Mapper) *scalar.S { 14012 s, err := d.TryFieldScalarS44LE(name, sms...) 14013 if err != nil { 14014 panic(IOError{Err: err, Name: name, Op: "S44LE", Pos: d.Pos()}) 14015 } 14016 return s 14017} 14018 14019// TryFieldS44LE tries to add a field and read 44 bit signed integer in little-endian 14020func (d *D) TryFieldS44LE(name string, sms ...scalar.Mapper) (int64, error) { 14021 s, err := d.TryFieldScalarS44LE(name, sms...) 14022 return s.ActualS(), err 14023} 14024 14025// FieldS44LE adds a field and reads 44 bit signed integer in little-endian 14026func (d *D) FieldS44LE(name string, sms ...scalar.Mapper) int64 { 14027 return d.FieldScalarS44LE(name, sms...).ActualS() 14028} 14029 14030// Reader S45LE 14031 14032// TryS45LE tries to read 45 bit signed integer in little-endian 14033func (d *D) TryS45LE() (int64, error) { return d.trySE(45, LittleEndian) } 14034 14035// S45LE reads 45 bit signed integer in little-endian 14036func (d *D) S45LE() int64 { 14037 v, err := d.trySE(45, LittleEndian) 14038 if err != nil { 14039 panic(IOError{Err: err, Op: "S45LE", Pos: d.Pos()}) 14040 } 14041 return v 14042} 14043 14044// TryFieldScalarS45LE tries to add a field and read 45 bit signed integer in little-endian 14045func (d *D) TryFieldScalarS45LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 14046 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 14047 v, err := d.trySE(45, LittleEndian) 14048 s.Actual = v 14049 return s, err 14050 }, sms...) 14051 if err != nil { 14052 return nil, err 14053 } 14054 return s, err 14055} 14056 14057// FieldScalarS45LE adds a field and reads 45 bit signed integer in little-endian 14058func (d *D) FieldScalarS45LE(name string, sms ...scalar.Mapper) *scalar.S { 14059 s, err := d.TryFieldScalarS45LE(name, sms...) 14060 if err != nil { 14061 panic(IOError{Err: err, Name: name, Op: "S45LE", Pos: d.Pos()}) 14062 } 14063 return s 14064} 14065 14066// TryFieldS45LE tries to add a field and read 45 bit signed integer in little-endian 14067func (d *D) TryFieldS45LE(name string, sms ...scalar.Mapper) (int64, error) { 14068 s, err := d.TryFieldScalarS45LE(name, sms...) 14069 return s.ActualS(), err 14070} 14071 14072// FieldS45LE adds a field and reads 45 bit signed integer in little-endian 14073func (d *D) FieldS45LE(name string, sms ...scalar.Mapper) int64 { 14074 return d.FieldScalarS45LE(name, sms...).ActualS() 14075} 14076 14077// Reader S46LE 14078 14079// TryS46LE tries to read 46 bit signed integer in little-endian 14080func (d *D) TryS46LE() (int64, error) { return d.trySE(46, LittleEndian) } 14081 14082// S46LE reads 46 bit signed integer in little-endian 14083func (d *D) S46LE() int64 { 14084 v, err := d.trySE(46, LittleEndian) 14085 if err != nil { 14086 panic(IOError{Err: err, Op: "S46LE", Pos: d.Pos()}) 14087 } 14088 return v 14089} 14090 14091// TryFieldScalarS46LE tries to add a field and read 46 bit signed integer in little-endian 14092func (d *D) TryFieldScalarS46LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 14093 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 14094 v, err := d.trySE(46, LittleEndian) 14095 s.Actual = v 14096 return s, err 14097 }, sms...) 14098 if err != nil { 14099 return nil, err 14100 } 14101 return s, err 14102} 14103 14104// FieldScalarS46LE adds a field and reads 46 bit signed integer in little-endian 14105func (d *D) FieldScalarS46LE(name string, sms ...scalar.Mapper) *scalar.S { 14106 s, err := d.TryFieldScalarS46LE(name, sms...) 14107 if err != nil { 14108 panic(IOError{Err: err, Name: name, Op: "S46LE", Pos: d.Pos()}) 14109 } 14110 return s 14111} 14112 14113// TryFieldS46LE tries to add a field and read 46 bit signed integer in little-endian 14114func (d *D) TryFieldS46LE(name string, sms ...scalar.Mapper) (int64, error) { 14115 s, err := d.TryFieldScalarS46LE(name, sms...) 14116 return s.ActualS(), err 14117} 14118 14119// FieldS46LE adds a field and reads 46 bit signed integer in little-endian 14120func (d *D) FieldS46LE(name string, sms ...scalar.Mapper) int64 { 14121 return d.FieldScalarS46LE(name, sms...).ActualS() 14122} 14123 14124// Reader S47LE 14125 14126// TryS47LE tries to read 47 bit signed integer in little-endian 14127func (d *D) TryS47LE() (int64, error) { return d.trySE(47, LittleEndian) } 14128 14129// S47LE reads 47 bit signed integer in little-endian 14130func (d *D) S47LE() int64 { 14131 v, err := d.trySE(47, LittleEndian) 14132 if err != nil { 14133 panic(IOError{Err: err, Op: "S47LE", Pos: d.Pos()}) 14134 } 14135 return v 14136} 14137 14138// TryFieldScalarS47LE tries to add a field and read 47 bit signed integer in little-endian 14139func (d *D) TryFieldScalarS47LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 14140 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 14141 v, err := d.trySE(47, LittleEndian) 14142 s.Actual = v 14143 return s, err 14144 }, sms...) 14145 if err != nil { 14146 return nil, err 14147 } 14148 return s, err 14149} 14150 14151// FieldScalarS47LE adds a field and reads 47 bit signed integer in little-endian 14152func (d *D) FieldScalarS47LE(name string, sms ...scalar.Mapper) *scalar.S { 14153 s, err := d.TryFieldScalarS47LE(name, sms...) 14154 if err != nil { 14155 panic(IOError{Err: err, Name: name, Op: "S47LE", Pos: d.Pos()}) 14156 } 14157 return s 14158} 14159 14160// TryFieldS47LE tries to add a field and read 47 bit signed integer in little-endian 14161func (d *D) TryFieldS47LE(name string, sms ...scalar.Mapper) (int64, error) { 14162 s, err := d.TryFieldScalarS47LE(name, sms...) 14163 return s.ActualS(), err 14164} 14165 14166// FieldS47LE adds a field and reads 47 bit signed integer in little-endian 14167func (d *D) FieldS47LE(name string, sms ...scalar.Mapper) int64 { 14168 return d.FieldScalarS47LE(name, sms...).ActualS() 14169} 14170 14171// Reader S48LE 14172 14173// TryS48LE tries to read 48 bit signed integer in little-endian 14174func (d *D) TryS48LE() (int64, error) { return d.trySE(48, LittleEndian) } 14175 14176// S48LE reads 48 bit signed integer in little-endian 14177func (d *D) S48LE() int64 { 14178 v, err := d.trySE(48, LittleEndian) 14179 if err != nil { 14180 panic(IOError{Err: err, Op: "S48LE", Pos: d.Pos()}) 14181 } 14182 return v 14183} 14184 14185// TryFieldScalarS48LE tries to add a field and read 48 bit signed integer in little-endian 14186func (d *D) TryFieldScalarS48LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 14187 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 14188 v, err := d.trySE(48, LittleEndian) 14189 s.Actual = v 14190 return s, err 14191 }, sms...) 14192 if err != nil { 14193 return nil, err 14194 } 14195 return s, err 14196} 14197 14198// FieldScalarS48LE adds a field and reads 48 bit signed integer in little-endian 14199func (d *D) FieldScalarS48LE(name string, sms ...scalar.Mapper) *scalar.S { 14200 s, err := d.TryFieldScalarS48LE(name, sms...) 14201 if err != nil { 14202 panic(IOError{Err: err, Name: name, Op: "S48LE", Pos: d.Pos()}) 14203 } 14204 return s 14205} 14206 14207// TryFieldS48LE tries to add a field and read 48 bit signed integer in little-endian 14208func (d *D) TryFieldS48LE(name string, sms ...scalar.Mapper) (int64, error) { 14209 s, err := d.TryFieldScalarS48LE(name, sms...) 14210 return s.ActualS(), err 14211} 14212 14213// FieldS48LE adds a field and reads 48 bit signed integer in little-endian 14214func (d *D) FieldS48LE(name string, sms ...scalar.Mapper) int64 { 14215 return d.FieldScalarS48LE(name, sms...).ActualS() 14216} 14217 14218// Reader S49LE 14219 14220// TryS49LE tries to read 49 bit signed integer in little-endian 14221func (d *D) TryS49LE() (int64, error) { return d.trySE(49, LittleEndian) } 14222 14223// S49LE reads 49 bit signed integer in little-endian 14224func (d *D) S49LE() int64 { 14225 v, err := d.trySE(49, LittleEndian) 14226 if err != nil { 14227 panic(IOError{Err: err, Op: "S49LE", Pos: d.Pos()}) 14228 } 14229 return v 14230} 14231 14232// TryFieldScalarS49LE tries to add a field and read 49 bit signed integer in little-endian 14233func (d *D) TryFieldScalarS49LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 14234 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 14235 v, err := d.trySE(49, LittleEndian) 14236 s.Actual = v 14237 return s, err 14238 }, sms...) 14239 if err != nil { 14240 return nil, err 14241 } 14242 return s, err 14243} 14244 14245// FieldScalarS49LE adds a field and reads 49 bit signed integer in little-endian 14246func (d *D) FieldScalarS49LE(name string, sms ...scalar.Mapper) *scalar.S { 14247 s, err := d.TryFieldScalarS49LE(name, sms...) 14248 if err != nil { 14249 panic(IOError{Err: err, Name: name, Op: "S49LE", Pos: d.Pos()}) 14250 } 14251 return s 14252} 14253 14254// TryFieldS49LE tries to add a field and read 49 bit signed integer in little-endian 14255func (d *D) TryFieldS49LE(name string, sms ...scalar.Mapper) (int64, error) { 14256 s, err := d.TryFieldScalarS49LE(name, sms...) 14257 return s.ActualS(), err 14258} 14259 14260// FieldS49LE adds a field and reads 49 bit signed integer in little-endian 14261func (d *D) FieldS49LE(name string, sms ...scalar.Mapper) int64 { 14262 return d.FieldScalarS49LE(name, sms...).ActualS() 14263} 14264 14265// Reader S50LE 14266 14267// TryS50LE tries to read 50 bit signed integer in little-endian 14268func (d *D) TryS50LE() (int64, error) { return d.trySE(50, LittleEndian) } 14269 14270// S50LE reads 50 bit signed integer in little-endian 14271func (d *D) S50LE() int64 { 14272 v, err := d.trySE(50, LittleEndian) 14273 if err != nil { 14274 panic(IOError{Err: err, Op: "S50LE", Pos: d.Pos()}) 14275 } 14276 return v 14277} 14278 14279// TryFieldScalarS50LE tries to add a field and read 50 bit signed integer in little-endian 14280func (d *D) TryFieldScalarS50LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 14281 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 14282 v, err := d.trySE(50, LittleEndian) 14283 s.Actual = v 14284 return s, err 14285 }, sms...) 14286 if err != nil { 14287 return nil, err 14288 } 14289 return s, err 14290} 14291 14292// FieldScalarS50LE adds a field and reads 50 bit signed integer in little-endian 14293func (d *D) FieldScalarS50LE(name string, sms ...scalar.Mapper) *scalar.S { 14294 s, err := d.TryFieldScalarS50LE(name, sms...) 14295 if err != nil { 14296 panic(IOError{Err: err, Name: name, Op: "S50LE", Pos: d.Pos()}) 14297 } 14298 return s 14299} 14300 14301// TryFieldS50LE tries to add a field and read 50 bit signed integer in little-endian 14302func (d *D) TryFieldS50LE(name string, sms ...scalar.Mapper) (int64, error) { 14303 s, err := d.TryFieldScalarS50LE(name, sms...) 14304 return s.ActualS(), err 14305} 14306 14307// FieldS50LE adds a field and reads 50 bit signed integer in little-endian 14308func (d *D) FieldS50LE(name string, sms ...scalar.Mapper) int64 { 14309 return d.FieldScalarS50LE(name, sms...).ActualS() 14310} 14311 14312// Reader S51LE 14313 14314// TryS51LE tries to read 51 bit signed integer in little-endian 14315func (d *D) TryS51LE() (int64, error) { return d.trySE(51, LittleEndian) } 14316 14317// S51LE reads 51 bit signed integer in little-endian 14318func (d *D) S51LE() int64 { 14319 v, err := d.trySE(51, LittleEndian) 14320 if err != nil { 14321 panic(IOError{Err: err, Op: "S51LE", Pos: d.Pos()}) 14322 } 14323 return v 14324} 14325 14326// TryFieldScalarS51LE tries to add a field and read 51 bit signed integer in little-endian 14327func (d *D) TryFieldScalarS51LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 14328 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 14329 v, err := d.trySE(51, LittleEndian) 14330 s.Actual = v 14331 return s, err 14332 }, sms...) 14333 if err != nil { 14334 return nil, err 14335 } 14336 return s, err 14337} 14338 14339// FieldScalarS51LE adds a field and reads 51 bit signed integer in little-endian 14340func (d *D) FieldScalarS51LE(name string, sms ...scalar.Mapper) *scalar.S { 14341 s, err := d.TryFieldScalarS51LE(name, sms...) 14342 if err != nil { 14343 panic(IOError{Err: err, Name: name, Op: "S51LE", Pos: d.Pos()}) 14344 } 14345 return s 14346} 14347 14348// TryFieldS51LE tries to add a field and read 51 bit signed integer in little-endian 14349func (d *D) TryFieldS51LE(name string, sms ...scalar.Mapper) (int64, error) { 14350 s, err := d.TryFieldScalarS51LE(name, sms...) 14351 return s.ActualS(), err 14352} 14353 14354// FieldS51LE adds a field and reads 51 bit signed integer in little-endian 14355func (d *D) FieldS51LE(name string, sms ...scalar.Mapper) int64 { 14356 return d.FieldScalarS51LE(name, sms...).ActualS() 14357} 14358 14359// Reader S52LE 14360 14361// TryS52LE tries to read 52 bit signed integer in little-endian 14362func (d *D) TryS52LE() (int64, error) { return d.trySE(52, LittleEndian) } 14363 14364// S52LE reads 52 bit signed integer in little-endian 14365func (d *D) S52LE() int64 { 14366 v, err := d.trySE(52, LittleEndian) 14367 if err != nil { 14368 panic(IOError{Err: err, Op: "S52LE", Pos: d.Pos()}) 14369 } 14370 return v 14371} 14372 14373// TryFieldScalarS52LE tries to add a field and read 52 bit signed integer in little-endian 14374func (d *D) TryFieldScalarS52LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 14375 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 14376 v, err := d.trySE(52, LittleEndian) 14377 s.Actual = v 14378 return s, err 14379 }, sms...) 14380 if err != nil { 14381 return nil, err 14382 } 14383 return s, err 14384} 14385 14386// FieldScalarS52LE adds a field and reads 52 bit signed integer in little-endian 14387func (d *D) FieldScalarS52LE(name string, sms ...scalar.Mapper) *scalar.S { 14388 s, err := d.TryFieldScalarS52LE(name, sms...) 14389 if err != nil { 14390 panic(IOError{Err: err, Name: name, Op: "S52LE", Pos: d.Pos()}) 14391 } 14392 return s 14393} 14394 14395// TryFieldS52LE tries to add a field and read 52 bit signed integer in little-endian 14396func (d *D) TryFieldS52LE(name string, sms ...scalar.Mapper) (int64, error) { 14397 s, err := d.TryFieldScalarS52LE(name, sms...) 14398 return s.ActualS(), err 14399} 14400 14401// FieldS52LE adds a field and reads 52 bit signed integer in little-endian 14402func (d *D) FieldS52LE(name string, sms ...scalar.Mapper) int64 { 14403 return d.FieldScalarS52LE(name, sms...).ActualS() 14404} 14405 14406// Reader S53LE 14407 14408// TryS53LE tries to read 53 bit signed integer in little-endian 14409func (d *D) TryS53LE() (int64, error) { return d.trySE(53, LittleEndian) } 14410 14411// S53LE reads 53 bit signed integer in little-endian 14412func (d *D) S53LE() int64 { 14413 v, err := d.trySE(53, LittleEndian) 14414 if err != nil { 14415 panic(IOError{Err: err, Op: "S53LE", Pos: d.Pos()}) 14416 } 14417 return v 14418} 14419 14420// TryFieldScalarS53LE tries to add a field and read 53 bit signed integer in little-endian 14421func (d *D) TryFieldScalarS53LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 14422 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 14423 v, err := d.trySE(53, LittleEndian) 14424 s.Actual = v 14425 return s, err 14426 }, sms...) 14427 if err != nil { 14428 return nil, err 14429 } 14430 return s, err 14431} 14432 14433// FieldScalarS53LE adds a field and reads 53 bit signed integer in little-endian 14434func (d *D) FieldScalarS53LE(name string, sms ...scalar.Mapper) *scalar.S { 14435 s, err := d.TryFieldScalarS53LE(name, sms...) 14436 if err != nil { 14437 panic(IOError{Err: err, Name: name, Op: "S53LE", Pos: d.Pos()}) 14438 } 14439 return s 14440} 14441 14442// TryFieldS53LE tries to add a field and read 53 bit signed integer in little-endian 14443func (d *D) TryFieldS53LE(name string, sms ...scalar.Mapper) (int64, error) { 14444 s, err := d.TryFieldScalarS53LE(name, sms...) 14445 return s.ActualS(), err 14446} 14447 14448// FieldS53LE adds a field and reads 53 bit signed integer in little-endian 14449func (d *D) FieldS53LE(name string, sms ...scalar.Mapper) int64 { 14450 return d.FieldScalarS53LE(name, sms...).ActualS() 14451} 14452 14453// Reader S54LE 14454 14455// TryS54LE tries to read 54 bit signed integer in little-endian 14456func (d *D) TryS54LE() (int64, error) { return d.trySE(54, LittleEndian) } 14457 14458// S54LE reads 54 bit signed integer in little-endian 14459func (d *D) S54LE() int64 { 14460 v, err := d.trySE(54, LittleEndian) 14461 if err != nil { 14462 panic(IOError{Err: err, Op: "S54LE", Pos: d.Pos()}) 14463 } 14464 return v 14465} 14466 14467// TryFieldScalarS54LE tries to add a field and read 54 bit signed integer in little-endian 14468func (d *D) TryFieldScalarS54LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 14469 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 14470 v, err := d.trySE(54, LittleEndian) 14471 s.Actual = v 14472 return s, err 14473 }, sms...) 14474 if err != nil { 14475 return nil, err 14476 } 14477 return s, err 14478} 14479 14480// FieldScalarS54LE adds a field and reads 54 bit signed integer in little-endian 14481func (d *D) FieldScalarS54LE(name string, sms ...scalar.Mapper) *scalar.S { 14482 s, err := d.TryFieldScalarS54LE(name, sms...) 14483 if err != nil { 14484 panic(IOError{Err: err, Name: name, Op: "S54LE", Pos: d.Pos()}) 14485 } 14486 return s 14487} 14488 14489// TryFieldS54LE tries to add a field and read 54 bit signed integer in little-endian 14490func (d *D) TryFieldS54LE(name string, sms ...scalar.Mapper) (int64, error) { 14491 s, err := d.TryFieldScalarS54LE(name, sms...) 14492 return s.ActualS(), err 14493} 14494 14495// FieldS54LE adds a field and reads 54 bit signed integer in little-endian 14496func (d *D) FieldS54LE(name string, sms ...scalar.Mapper) int64 { 14497 return d.FieldScalarS54LE(name, sms...).ActualS() 14498} 14499 14500// Reader S55LE 14501 14502// TryS55LE tries to read 55 bit signed integer in little-endian 14503func (d *D) TryS55LE() (int64, error) { return d.trySE(55, LittleEndian) } 14504 14505// S55LE reads 55 bit signed integer in little-endian 14506func (d *D) S55LE() int64 { 14507 v, err := d.trySE(55, LittleEndian) 14508 if err != nil { 14509 panic(IOError{Err: err, Op: "S55LE", Pos: d.Pos()}) 14510 } 14511 return v 14512} 14513 14514// TryFieldScalarS55LE tries to add a field and read 55 bit signed integer in little-endian 14515func (d *D) TryFieldScalarS55LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 14516 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 14517 v, err := d.trySE(55, LittleEndian) 14518 s.Actual = v 14519 return s, err 14520 }, sms...) 14521 if err != nil { 14522 return nil, err 14523 } 14524 return s, err 14525} 14526 14527// FieldScalarS55LE adds a field and reads 55 bit signed integer in little-endian 14528func (d *D) FieldScalarS55LE(name string, sms ...scalar.Mapper) *scalar.S { 14529 s, err := d.TryFieldScalarS55LE(name, sms...) 14530 if err != nil { 14531 panic(IOError{Err: err, Name: name, Op: "S55LE", Pos: d.Pos()}) 14532 } 14533 return s 14534} 14535 14536// TryFieldS55LE tries to add a field and read 55 bit signed integer in little-endian 14537func (d *D) TryFieldS55LE(name string, sms ...scalar.Mapper) (int64, error) { 14538 s, err := d.TryFieldScalarS55LE(name, sms...) 14539 return s.ActualS(), err 14540} 14541 14542// FieldS55LE adds a field and reads 55 bit signed integer in little-endian 14543func (d *D) FieldS55LE(name string, sms ...scalar.Mapper) int64 { 14544 return d.FieldScalarS55LE(name, sms...).ActualS() 14545} 14546 14547// Reader S56LE 14548 14549// TryS56LE tries to read 56 bit signed integer in little-endian 14550func (d *D) TryS56LE() (int64, error) { return d.trySE(56, LittleEndian) } 14551 14552// S56LE reads 56 bit signed integer in little-endian 14553func (d *D) S56LE() int64 { 14554 v, err := d.trySE(56, LittleEndian) 14555 if err != nil { 14556 panic(IOError{Err: err, Op: "S56LE", Pos: d.Pos()}) 14557 } 14558 return v 14559} 14560 14561// TryFieldScalarS56LE tries to add a field and read 56 bit signed integer in little-endian 14562func (d *D) TryFieldScalarS56LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 14563 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 14564 v, err := d.trySE(56, LittleEndian) 14565 s.Actual = v 14566 return s, err 14567 }, sms...) 14568 if err != nil { 14569 return nil, err 14570 } 14571 return s, err 14572} 14573 14574// FieldScalarS56LE adds a field and reads 56 bit signed integer in little-endian 14575func (d *D) FieldScalarS56LE(name string, sms ...scalar.Mapper) *scalar.S { 14576 s, err := d.TryFieldScalarS56LE(name, sms...) 14577 if err != nil { 14578 panic(IOError{Err: err, Name: name, Op: "S56LE", Pos: d.Pos()}) 14579 } 14580 return s 14581} 14582 14583// TryFieldS56LE tries to add a field and read 56 bit signed integer in little-endian 14584func (d *D) TryFieldS56LE(name string, sms ...scalar.Mapper) (int64, error) { 14585 s, err := d.TryFieldScalarS56LE(name, sms...) 14586 return s.ActualS(), err 14587} 14588 14589// FieldS56LE adds a field and reads 56 bit signed integer in little-endian 14590func (d *D) FieldS56LE(name string, sms ...scalar.Mapper) int64 { 14591 return d.FieldScalarS56LE(name, sms...).ActualS() 14592} 14593 14594// Reader S57LE 14595 14596// TryS57LE tries to read 57 bit signed integer in little-endian 14597func (d *D) TryS57LE() (int64, error) { return d.trySE(57, LittleEndian) } 14598 14599// S57LE reads 57 bit signed integer in little-endian 14600func (d *D) S57LE() int64 { 14601 v, err := d.trySE(57, LittleEndian) 14602 if err != nil { 14603 panic(IOError{Err: err, Op: "S57LE", Pos: d.Pos()}) 14604 } 14605 return v 14606} 14607 14608// TryFieldScalarS57LE tries to add a field and read 57 bit signed integer in little-endian 14609func (d *D) TryFieldScalarS57LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 14610 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 14611 v, err := d.trySE(57, LittleEndian) 14612 s.Actual = v 14613 return s, err 14614 }, sms...) 14615 if err != nil { 14616 return nil, err 14617 } 14618 return s, err 14619} 14620 14621// FieldScalarS57LE adds a field and reads 57 bit signed integer in little-endian 14622func (d *D) FieldScalarS57LE(name string, sms ...scalar.Mapper) *scalar.S { 14623 s, err := d.TryFieldScalarS57LE(name, sms...) 14624 if err != nil { 14625 panic(IOError{Err: err, Name: name, Op: "S57LE", Pos: d.Pos()}) 14626 } 14627 return s 14628} 14629 14630// TryFieldS57LE tries to add a field and read 57 bit signed integer in little-endian 14631func (d *D) TryFieldS57LE(name string, sms ...scalar.Mapper) (int64, error) { 14632 s, err := d.TryFieldScalarS57LE(name, sms...) 14633 return s.ActualS(), err 14634} 14635 14636// FieldS57LE adds a field and reads 57 bit signed integer in little-endian 14637func (d *D) FieldS57LE(name string, sms ...scalar.Mapper) int64 { 14638 return d.FieldScalarS57LE(name, sms...).ActualS() 14639} 14640 14641// Reader S58LE 14642 14643// TryS58LE tries to read 58 bit signed integer in little-endian 14644func (d *D) TryS58LE() (int64, error) { return d.trySE(58, LittleEndian) } 14645 14646// S58LE reads 58 bit signed integer in little-endian 14647func (d *D) S58LE() int64 { 14648 v, err := d.trySE(58, LittleEndian) 14649 if err != nil { 14650 panic(IOError{Err: err, Op: "S58LE", Pos: d.Pos()}) 14651 } 14652 return v 14653} 14654 14655// TryFieldScalarS58LE tries to add a field and read 58 bit signed integer in little-endian 14656func (d *D) TryFieldScalarS58LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 14657 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 14658 v, err := d.trySE(58, LittleEndian) 14659 s.Actual = v 14660 return s, err 14661 }, sms...) 14662 if err != nil { 14663 return nil, err 14664 } 14665 return s, err 14666} 14667 14668// FieldScalarS58LE adds a field and reads 58 bit signed integer in little-endian 14669func (d *D) FieldScalarS58LE(name string, sms ...scalar.Mapper) *scalar.S { 14670 s, err := d.TryFieldScalarS58LE(name, sms...) 14671 if err != nil { 14672 panic(IOError{Err: err, Name: name, Op: "S58LE", Pos: d.Pos()}) 14673 } 14674 return s 14675} 14676 14677// TryFieldS58LE tries to add a field and read 58 bit signed integer in little-endian 14678func (d *D) TryFieldS58LE(name string, sms ...scalar.Mapper) (int64, error) { 14679 s, err := d.TryFieldScalarS58LE(name, sms...) 14680 return s.ActualS(), err 14681} 14682 14683// FieldS58LE adds a field and reads 58 bit signed integer in little-endian 14684func (d *D) FieldS58LE(name string, sms ...scalar.Mapper) int64 { 14685 return d.FieldScalarS58LE(name, sms...).ActualS() 14686} 14687 14688// Reader S59LE 14689 14690// TryS59LE tries to read 59 bit signed integer in little-endian 14691func (d *D) TryS59LE() (int64, error) { return d.trySE(59, LittleEndian) } 14692 14693// S59LE reads 59 bit signed integer in little-endian 14694func (d *D) S59LE() int64 { 14695 v, err := d.trySE(59, LittleEndian) 14696 if err != nil { 14697 panic(IOError{Err: err, Op: "S59LE", Pos: d.Pos()}) 14698 } 14699 return v 14700} 14701 14702// TryFieldScalarS59LE tries to add a field and read 59 bit signed integer in little-endian 14703func (d *D) TryFieldScalarS59LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 14704 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 14705 v, err := d.trySE(59, LittleEndian) 14706 s.Actual = v 14707 return s, err 14708 }, sms...) 14709 if err != nil { 14710 return nil, err 14711 } 14712 return s, err 14713} 14714 14715// FieldScalarS59LE adds a field and reads 59 bit signed integer in little-endian 14716func (d *D) FieldScalarS59LE(name string, sms ...scalar.Mapper) *scalar.S { 14717 s, err := d.TryFieldScalarS59LE(name, sms...) 14718 if err != nil { 14719 panic(IOError{Err: err, Name: name, Op: "S59LE", Pos: d.Pos()}) 14720 } 14721 return s 14722} 14723 14724// TryFieldS59LE tries to add a field and read 59 bit signed integer in little-endian 14725func (d *D) TryFieldS59LE(name string, sms ...scalar.Mapper) (int64, error) { 14726 s, err := d.TryFieldScalarS59LE(name, sms...) 14727 return s.ActualS(), err 14728} 14729 14730// FieldS59LE adds a field and reads 59 bit signed integer in little-endian 14731func (d *D) FieldS59LE(name string, sms ...scalar.Mapper) int64 { 14732 return d.FieldScalarS59LE(name, sms...).ActualS() 14733} 14734 14735// Reader S60LE 14736 14737// TryS60LE tries to read 60 bit signed integer in little-endian 14738func (d *D) TryS60LE() (int64, error) { return d.trySE(60, LittleEndian) } 14739 14740// S60LE reads 60 bit signed integer in little-endian 14741func (d *D) S60LE() int64 { 14742 v, err := d.trySE(60, LittleEndian) 14743 if err != nil { 14744 panic(IOError{Err: err, Op: "S60LE", Pos: d.Pos()}) 14745 } 14746 return v 14747} 14748 14749// TryFieldScalarS60LE tries to add a field and read 60 bit signed integer in little-endian 14750func (d *D) TryFieldScalarS60LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 14751 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 14752 v, err := d.trySE(60, LittleEndian) 14753 s.Actual = v 14754 return s, err 14755 }, sms...) 14756 if err != nil { 14757 return nil, err 14758 } 14759 return s, err 14760} 14761 14762// FieldScalarS60LE adds a field and reads 60 bit signed integer in little-endian 14763func (d *D) FieldScalarS60LE(name string, sms ...scalar.Mapper) *scalar.S { 14764 s, err := d.TryFieldScalarS60LE(name, sms...) 14765 if err != nil { 14766 panic(IOError{Err: err, Name: name, Op: "S60LE", Pos: d.Pos()}) 14767 } 14768 return s 14769} 14770 14771// TryFieldS60LE tries to add a field and read 60 bit signed integer in little-endian 14772func (d *D) TryFieldS60LE(name string, sms ...scalar.Mapper) (int64, error) { 14773 s, err := d.TryFieldScalarS60LE(name, sms...) 14774 return s.ActualS(), err 14775} 14776 14777// FieldS60LE adds a field and reads 60 bit signed integer in little-endian 14778func (d *D) FieldS60LE(name string, sms ...scalar.Mapper) int64 { 14779 return d.FieldScalarS60LE(name, sms...).ActualS() 14780} 14781 14782// Reader S61LE 14783 14784// TryS61LE tries to read 61 bit signed integer in little-endian 14785func (d *D) TryS61LE() (int64, error) { return d.trySE(61, LittleEndian) } 14786 14787// S61LE reads 61 bit signed integer in little-endian 14788func (d *D) S61LE() int64 { 14789 v, err := d.trySE(61, LittleEndian) 14790 if err != nil { 14791 panic(IOError{Err: err, Op: "S61LE", Pos: d.Pos()}) 14792 } 14793 return v 14794} 14795 14796// TryFieldScalarS61LE tries to add a field and read 61 bit signed integer in little-endian 14797func (d *D) TryFieldScalarS61LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 14798 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 14799 v, err := d.trySE(61, LittleEndian) 14800 s.Actual = v 14801 return s, err 14802 }, sms...) 14803 if err != nil { 14804 return nil, err 14805 } 14806 return s, err 14807} 14808 14809// FieldScalarS61LE adds a field and reads 61 bit signed integer in little-endian 14810func (d *D) FieldScalarS61LE(name string, sms ...scalar.Mapper) *scalar.S { 14811 s, err := d.TryFieldScalarS61LE(name, sms...) 14812 if err != nil { 14813 panic(IOError{Err: err, Name: name, Op: "S61LE", Pos: d.Pos()}) 14814 } 14815 return s 14816} 14817 14818// TryFieldS61LE tries to add a field and read 61 bit signed integer in little-endian 14819func (d *D) TryFieldS61LE(name string, sms ...scalar.Mapper) (int64, error) { 14820 s, err := d.TryFieldScalarS61LE(name, sms...) 14821 return s.ActualS(), err 14822} 14823 14824// FieldS61LE adds a field and reads 61 bit signed integer in little-endian 14825func (d *D) FieldS61LE(name string, sms ...scalar.Mapper) int64 { 14826 return d.FieldScalarS61LE(name, sms...).ActualS() 14827} 14828 14829// Reader S62LE 14830 14831// TryS62LE tries to read 62 bit signed integer in little-endian 14832func (d *D) TryS62LE() (int64, error) { return d.trySE(62, LittleEndian) } 14833 14834// S62LE reads 62 bit signed integer in little-endian 14835func (d *D) S62LE() int64 { 14836 v, err := d.trySE(62, LittleEndian) 14837 if err != nil { 14838 panic(IOError{Err: err, Op: "S62LE", Pos: d.Pos()}) 14839 } 14840 return v 14841} 14842 14843// TryFieldScalarS62LE tries to add a field and read 62 bit signed integer in little-endian 14844func (d *D) TryFieldScalarS62LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 14845 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 14846 v, err := d.trySE(62, LittleEndian) 14847 s.Actual = v 14848 return s, err 14849 }, sms...) 14850 if err != nil { 14851 return nil, err 14852 } 14853 return s, err 14854} 14855 14856// FieldScalarS62LE adds a field and reads 62 bit signed integer in little-endian 14857func (d *D) FieldScalarS62LE(name string, sms ...scalar.Mapper) *scalar.S { 14858 s, err := d.TryFieldScalarS62LE(name, sms...) 14859 if err != nil { 14860 panic(IOError{Err: err, Name: name, Op: "S62LE", Pos: d.Pos()}) 14861 } 14862 return s 14863} 14864 14865// TryFieldS62LE tries to add a field and read 62 bit signed integer in little-endian 14866func (d *D) TryFieldS62LE(name string, sms ...scalar.Mapper) (int64, error) { 14867 s, err := d.TryFieldScalarS62LE(name, sms...) 14868 return s.ActualS(), err 14869} 14870 14871// FieldS62LE adds a field and reads 62 bit signed integer in little-endian 14872func (d *D) FieldS62LE(name string, sms ...scalar.Mapper) int64 { 14873 return d.FieldScalarS62LE(name, sms...).ActualS() 14874} 14875 14876// Reader S63LE 14877 14878// TryS63LE tries to read 63 bit signed integer in little-endian 14879func (d *D) TryS63LE() (int64, error) { return d.trySE(63, LittleEndian) } 14880 14881// S63LE reads 63 bit signed integer in little-endian 14882func (d *D) S63LE() int64 { 14883 v, err := d.trySE(63, LittleEndian) 14884 if err != nil { 14885 panic(IOError{Err: err, Op: "S63LE", Pos: d.Pos()}) 14886 } 14887 return v 14888} 14889 14890// TryFieldScalarS63LE tries to add a field and read 63 bit signed integer in little-endian 14891func (d *D) TryFieldScalarS63LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 14892 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 14893 v, err := d.trySE(63, LittleEndian) 14894 s.Actual = v 14895 return s, err 14896 }, sms...) 14897 if err != nil { 14898 return nil, err 14899 } 14900 return s, err 14901} 14902 14903// FieldScalarS63LE adds a field and reads 63 bit signed integer in little-endian 14904func (d *D) FieldScalarS63LE(name string, sms ...scalar.Mapper) *scalar.S { 14905 s, err := d.TryFieldScalarS63LE(name, sms...) 14906 if err != nil { 14907 panic(IOError{Err: err, Name: name, Op: "S63LE", Pos: d.Pos()}) 14908 } 14909 return s 14910} 14911 14912// TryFieldS63LE tries to add a field and read 63 bit signed integer in little-endian 14913func (d *D) TryFieldS63LE(name string, sms ...scalar.Mapper) (int64, error) { 14914 s, err := d.TryFieldScalarS63LE(name, sms...) 14915 return s.ActualS(), err 14916} 14917 14918// FieldS63LE adds a field and reads 63 bit signed integer in little-endian 14919func (d *D) FieldS63LE(name string, sms ...scalar.Mapper) int64 { 14920 return d.FieldScalarS63LE(name, sms...).ActualS() 14921} 14922 14923// Reader S64LE 14924 14925// TryS64LE tries to read 64 bit signed integer in little-endian 14926func (d *D) TryS64LE() (int64, error) { return d.trySE(64, LittleEndian) } 14927 14928// S64LE reads 64 bit signed integer in little-endian 14929func (d *D) S64LE() int64 { 14930 v, err := d.trySE(64, LittleEndian) 14931 if err != nil { 14932 panic(IOError{Err: err, Op: "S64LE", Pos: d.Pos()}) 14933 } 14934 return v 14935} 14936 14937// TryFieldScalarS64LE tries to add a field and read 64 bit signed integer in little-endian 14938func (d *D) TryFieldScalarS64LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 14939 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 14940 v, err := d.trySE(64, LittleEndian) 14941 s.Actual = v 14942 return s, err 14943 }, sms...) 14944 if err != nil { 14945 return nil, err 14946 } 14947 return s, err 14948} 14949 14950// FieldScalarS64LE adds a field and reads 64 bit signed integer in little-endian 14951func (d *D) FieldScalarS64LE(name string, sms ...scalar.Mapper) *scalar.S { 14952 s, err := d.TryFieldScalarS64LE(name, sms...) 14953 if err != nil { 14954 panic(IOError{Err: err, Name: name, Op: "S64LE", Pos: d.Pos()}) 14955 } 14956 return s 14957} 14958 14959// TryFieldS64LE tries to add a field and read 64 bit signed integer in little-endian 14960func (d *D) TryFieldS64LE(name string, sms ...scalar.Mapper) (int64, error) { 14961 s, err := d.TryFieldScalarS64LE(name, sms...) 14962 return s.ActualS(), err 14963} 14964 14965// FieldS64LE adds a field and reads 64 bit signed integer in little-endian 14966func (d *D) FieldS64LE(name string, sms ...scalar.Mapper) int64 { 14967 return d.FieldScalarS64LE(name, sms...).ActualS() 14968} 14969 14970// Reader S8BE 14971 14972// TryS8BE tries to read 8 bit signed integer in big-endian 14973func (d *D) TryS8BE() (int64, error) { return d.trySE(8, BigEndian) } 14974 14975// S8BE reads 8 bit signed integer in big-endian 14976func (d *D) S8BE() int64 { 14977 v, err := d.trySE(8, BigEndian) 14978 if err != nil { 14979 panic(IOError{Err: err, Op: "S8BE", Pos: d.Pos()}) 14980 } 14981 return v 14982} 14983 14984// TryFieldScalarS8BE tries to add a field and read 8 bit signed integer in big-endian 14985func (d *D) TryFieldScalarS8BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 14986 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 14987 v, err := d.trySE(8, BigEndian) 14988 s.Actual = v 14989 return s, err 14990 }, sms...) 14991 if err != nil { 14992 return nil, err 14993 } 14994 return s, err 14995} 14996 14997// FieldScalarS8BE adds a field and reads 8 bit signed integer in big-endian 14998func (d *D) FieldScalarS8BE(name string, sms ...scalar.Mapper) *scalar.S { 14999 s, err := d.TryFieldScalarS8BE(name, sms...) 15000 if err != nil { 15001 panic(IOError{Err: err, Name: name, Op: "S8BE", Pos: d.Pos()}) 15002 } 15003 return s 15004} 15005 15006// TryFieldS8BE tries to add a field and read 8 bit signed integer in big-endian 15007func (d *D) TryFieldS8BE(name string, sms ...scalar.Mapper) (int64, error) { 15008 s, err := d.TryFieldScalarS8BE(name, sms...) 15009 return s.ActualS(), err 15010} 15011 15012// FieldS8BE adds a field and reads 8 bit signed integer in big-endian 15013func (d *D) FieldS8BE(name string, sms ...scalar.Mapper) int64 { 15014 return d.FieldScalarS8BE(name, sms...).ActualS() 15015} 15016 15017// Reader S9BE 15018 15019// TryS9BE tries to read 9 bit signed integer in big-endian 15020func (d *D) TryS9BE() (int64, error) { return d.trySE(9, BigEndian) } 15021 15022// S9BE reads 9 bit signed integer in big-endian 15023func (d *D) S9BE() int64 { 15024 v, err := d.trySE(9, BigEndian) 15025 if err != nil { 15026 panic(IOError{Err: err, Op: "S9BE", Pos: d.Pos()}) 15027 } 15028 return v 15029} 15030 15031// TryFieldScalarS9BE tries to add a field and read 9 bit signed integer in big-endian 15032func (d *D) TryFieldScalarS9BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 15033 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 15034 v, err := d.trySE(9, BigEndian) 15035 s.Actual = v 15036 return s, err 15037 }, sms...) 15038 if err != nil { 15039 return nil, err 15040 } 15041 return s, err 15042} 15043 15044// FieldScalarS9BE adds a field and reads 9 bit signed integer in big-endian 15045func (d *D) FieldScalarS9BE(name string, sms ...scalar.Mapper) *scalar.S { 15046 s, err := d.TryFieldScalarS9BE(name, sms...) 15047 if err != nil { 15048 panic(IOError{Err: err, Name: name, Op: "S9BE", Pos: d.Pos()}) 15049 } 15050 return s 15051} 15052 15053// TryFieldS9BE tries to add a field and read 9 bit signed integer in big-endian 15054func (d *D) TryFieldS9BE(name string, sms ...scalar.Mapper) (int64, error) { 15055 s, err := d.TryFieldScalarS9BE(name, sms...) 15056 return s.ActualS(), err 15057} 15058 15059// FieldS9BE adds a field and reads 9 bit signed integer in big-endian 15060func (d *D) FieldS9BE(name string, sms ...scalar.Mapper) int64 { 15061 return d.FieldScalarS9BE(name, sms...).ActualS() 15062} 15063 15064// Reader S10BE 15065 15066// TryS10BE tries to read 10 bit signed integer in big-endian 15067func (d *D) TryS10BE() (int64, error) { return d.trySE(10, BigEndian) } 15068 15069// S10BE reads 10 bit signed integer in big-endian 15070func (d *D) S10BE() int64 { 15071 v, err := d.trySE(10, BigEndian) 15072 if err != nil { 15073 panic(IOError{Err: err, Op: "S10BE", Pos: d.Pos()}) 15074 } 15075 return v 15076} 15077 15078// TryFieldScalarS10BE tries to add a field and read 10 bit signed integer in big-endian 15079func (d *D) TryFieldScalarS10BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 15080 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 15081 v, err := d.trySE(10, BigEndian) 15082 s.Actual = v 15083 return s, err 15084 }, sms...) 15085 if err != nil { 15086 return nil, err 15087 } 15088 return s, err 15089} 15090 15091// FieldScalarS10BE adds a field and reads 10 bit signed integer in big-endian 15092func (d *D) FieldScalarS10BE(name string, sms ...scalar.Mapper) *scalar.S { 15093 s, err := d.TryFieldScalarS10BE(name, sms...) 15094 if err != nil { 15095 panic(IOError{Err: err, Name: name, Op: "S10BE", Pos: d.Pos()}) 15096 } 15097 return s 15098} 15099 15100// TryFieldS10BE tries to add a field and read 10 bit signed integer in big-endian 15101func (d *D) TryFieldS10BE(name string, sms ...scalar.Mapper) (int64, error) { 15102 s, err := d.TryFieldScalarS10BE(name, sms...) 15103 return s.ActualS(), err 15104} 15105 15106// FieldS10BE adds a field and reads 10 bit signed integer in big-endian 15107func (d *D) FieldS10BE(name string, sms ...scalar.Mapper) int64 { 15108 return d.FieldScalarS10BE(name, sms...).ActualS() 15109} 15110 15111// Reader S11BE 15112 15113// TryS11BE tries to read 11 bit signed integer in big-endian 15114func (d *D) TryS11BE() (int64, error) { return d.trySE(11, BigEndian) } 15115 15116// S11BE reads 11 bit signed integer in big-endian 15117func (d *D) S11BE() int64 { 15118 v, err := d.trySE(11, BigEndian) 15119 if err != nil { 15120 panic(IOError{Err: err, Op: "S11BE", Pos: d.Pos()}) 15121 } 15122 return v 15123} 15124 15125// TryFieldScalarS11BE tries to add a field and read 11 bit signed integer in big-endian 15126func (d *D) TryFieldScalarS11BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 15127 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 15128 v, err := d.trySE(11, BigEndian) 15129 s.Actual = v 15130 return s, err 15131 }, sms...) 15132 if err != nil { 15133 return nil, err 15134 } 15135 return s, err 15136} 15137 15138// FieldScalarS11BE adds a field and reads 11 bit signed integer in big-endian 15139func (d *D) FieldScalarS11BE(name string, sms ...scalar.Mapper) *scalar.S { 15140 s, err := d.TryFieldScalarS11BE(name, sms...) 15141 if err != nil { 15142 panic(IOError{Err: err, Name: name, Op: "S11BE", Pos: d.Pos()}) 15143 } 15144 return s 15145} 15146 15147// TryFieldS11BE tries to add a field and read 11 bit signed integer in big-endian 15148func (d *D) TryFieldS11BE(name string, sms ...scalar.Mapper) (int64, error) { 15149 s, err := d.TryFieldScalarS11BE(name, sms...) 15150 return s.ActualS(), err 15151} 15152 15153// FieldS11BE adds a field and reads 11 bit signed integer in big-endian 15154func (d *D) FieldS11BE(name string, sms ...scalar.Mapper) int64 { 15155 return d.FieldScalarS11BE(name, sms...).ActualS() 15156} 15157 15158// Reader S12BE 15159 15160// TryS12BE tries to read 12 bit signed integer in big-endian 15161func (d *D) TryS12BE() (int64, error) { return d.trySE(12, BigEndian) } 15162 15163// S12BE reads 12 bit signed integer in big-endian 15164func (d *D) S12BE() int64 { 15165 v, err := d.trySE(12, BigEndian) 15166 if err != nil { 15167 panic(IOError{Err: err, Op: "S12BE", Pos: d.Pos()}) 15168 } 15169 return v 15170} 15171 15172// TryFieldScalarS12BE tries to add a field and read 12 bit signed integer in big-endian 15173func (d *D) TryFieldScalarS12BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 15174 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 15175 v, err := d.trySE(12, BigEndian) 15176 s.Actual = v 15177 return s, err 15178 }, sms...) 15179 if err != nil { 15180 return nil, err 15181 } 15182 return s, err 15183} 15184 15185// FieldScalarS12BE adds a field and reads 12 bit signed integer in big-endian 15186func (d *D) FieldScalarS12BE(name string, sms ...scalar.Mapper) *scalar.S { 15187 s, err := d.TryFieldScalarS12BE(name, sms...) 15188 if err != nil { 15189 panic(IOError{Err: err, Name: name, Op: "S12BE", Pos: d.Pos()}) 15190 } 15191 return s 15192} 15193 15194// TryFieldS12BE tries to add a field and read 12 bit signed integer in big-endian 15195func (d *D) TryFieldS12BE(name string, sms ...scalar.Mapper) (int64, error) { 15196 s, err := d.TryFieldScalarS12BE(name, sms...) 15197 return s.ActualS(), err 15198} 15199 15200// FieldS12BE adds a field and reads 12 bit signed integer in big-endian 15201func (d *D) FieldS12BE(name string, sms ...scalar.Mapper) int64 { 15202 return d.FieldScalarS12BE(name, sms...).ActualS() 15203} 15204 15205// Reader S13BE 15206 15207// TryS13BE tries to read 13 bit signed integer in big-endian 15208func (d *D) TryS13BE() (int64, error) { return d.trySE(13, BigEndian) } 15209 15210// S13BE reads 13 bit signed integer in big-endian 15211func (d *D) S13BE() int64 { 15212 v, err := d.trySE(13, BigEndian) 15213 if err != nil { 15214 panic(IOError{Err: err, Op: "S13BE", Pos: d.Pos()}) 15215 } 15216 return v 15217} 15218 15219// TryFieldScalarS13BE tries to add a field and read 13 bit signed integer in big-endian 15220func (d *D) TryFieldScalarS13BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 15221 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 15222 v, err := d.trySE(13, BigEndian) 15223 s.Actual = v 15224 return s, err 15225 }, sms...) 15226 if err != nil { 15227 return nil, err 15228 } 15229 return s, err 15230} 15231 15232// FieldScalarS13BE adds a field and reads 13 bit signed integer in big-endian 15233func (d *D) FieldScalarS13BE(name string, sms ...scalar.Mapper) *scalar.S { 15234 s, err := d.TryFieldScalarS13BE(name, sms...) 15235 if err != nil { 15236 panic(IOError{Err: err, Name: name, Op: "S13BE", Pos: d.Pos()}) 15237 } 15238 return s 15239} 15240 15241// TryFieldS13BE tries to add a field and read 13 bit signed integer in big-endian 15242func (d *D) TryFieldS13BE(name string, sms ...scalar.Mapper) (int64, error) { 15243 s, err := d.TryFieldScalarS13BE(name, sms...) 15244 return s.ActualS(), err 15245} 15246 15247// FieldS13BE adds a field and reads 13 bit signed integer in big-endian 15248func (d *D) FieldS13BE(name string, sms ...scalar.Mapper) int64 { 15249 return d.FieldScalarS13BE(name, sms...).ActualS() 15250} 15251 15252// Reader S14BE 15253 15254// TryS14BE tries to read 14 bit signed integer in big-endian 15255func (d *D) TryS14BE() (int64, error) { return d.trySE(14, BigEndian) } 15256 15257// S14BE reads 14 bit signed integer in big-endian 15258func (d *D) S14BE() int64 { 15259 v, err := d.trySE(14, BigEndian) 15260 if err != nil { 15261 panic(IOError{Err: err, Op: "S14BE", Pos: d.Pos()}) 15262 } 15263 return v 15264} 15265 15266// TryFieldScalarS14BE tries to add a field and read 14 bit signed integer in big-endian 15267func (d *D) TryFieldScalarS14BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 15268 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 15269 v, err := d.trySE(14, BigEndian) 15270 s.Actual = v 15271 return s, err 15272 }, sms...) 15273 if err != nil { 15274 return nil, err 15275 } 15276 return s, err 15277} 15278 15279// FieldScalarS14BE adds a field and reads 14 bit signed integer in big-endian 15280func (d *D) FieldScalarS14BE(name string, sms ...scalar.Mapper) *scalar.S { 15281 s, err := d.TryFieldScalarS14BE(name, sms...) 15282 if err != nil { 15283 panic(IOError{Err: err, Name: name, Op: "S14BE", Pos: d.Pos()}) 15284 } 15285 return s 15286} 15287 15288// TryFieldS14BE tries to add a field and read 14 bit signed integer in big-endian 15289func (d *D) TryFieldS14BE(name string, sms ...scalar.Mapper) (int64, error) { 15290 s, err := d.TryFieldScalarS14BE(name, sms...) 15291 return s.ActualS(), err 15292} 15293 15294// FieldS14BE adds a field and reads 14 bit signed integer in big-endian 15295func (d *D) FieldS14BE(name string, sms ...scalar.Mapper) int64 { 15296 return d.FieldScalarS14BE(name, sms...).ActualS() 15297} 15298 15299// Reader S15BE 15300 15301// TryS15BE tries to read 15 bit signed integer in big-endian 15302func (d *D) TryS15BE() (int64, error) { return d.trySE(15, BigEndian) } 15303 15304// S15BE reads 15 bit signed integer in big-endian 15305func (d *D) S15BE() int64 { 15306 v, err := d.trySE(15, BigEndian) 15307 if err != nil { 15308 panic(IOError{Err: err, Op: "S15BE", Pos: d.Pos()}) 15309 } 15310 return v 15311} 15312 15313// TryFieldScalarS15BE tries to add a field and read 15 bit signed integer in big-endian 15314func (d *D) TryFieldScalarS15BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 15315 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 15316 v, err := d.trySE(15, BigEndian) 15317 s.Actual = v 15318 return s, err 15319 }, sms...) 15320 if err != nil { 15321 return nil, err 15322 } 15323 return s, err 15324} 15325 15326// FieldScalarS15BE adds a field and reads 15 bit signed integer in big-endian 15327func (d *D) FieldScalarS15BE(name string, sms ...scalar.Mapper) *scalar.S { 15328 s, err := d.TryFieldScalarS15BE(name, sms...) 15329 if err != nil { 15330 panic(IOError{Err: err, Name: name, Op: "S15BE", Pos: d.Pos()}) 15331 } 15332 return s 15333} 15334 15335// TryFieldS15BE tries to add a field and read 15 bit signed integer in big-endian 15336func (d *D) TryFieldS15BE(name string, sms ...scalar.Mapper) (int64, error) { 15337 s, err := d.TryFieldScalarS15BE(name, sms...) 15338 return s.ActualS(), err 15339} 15340 15341// FieldS15BE adds a field and reads 15 bit signed integer in big-endian 15342func (d *D) FieldS15BE(name string, sms ...scalar.Mapper) int64 { 15343 return d.FieldScalarS15BE(name, sms...).ActualS() 15344} 15345 15346// Reader S16BE 15347 15348// TryS16BE tries to read 16 bit signed integer in big-endian 15349func (d *D) TryS16BE() (int64, error) { return d.trySE(16, BigEndian) } 15350 15351// S16BE reads 16 bit signed integer in big-endian 15352func (d *D) S16BE() int64 { 15353 v, err := d.trySE(16, BigEndian) 15354 if err != nil { 15355 panic(IOError{Err: err, Op: "S16BE", Pos: d.Pos()}) 15356 } 15357 return v 15358} 15359 15360// TryFieldScalarS16BE tries to add a field and read 16 bit signed integer in big-endian 15361func (d *D) TryFieldScalarS16BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 15362 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 15363 v, err := d.trySE(16, BigEndian) 15364 s.Actual = v 15365 return s, err 15366 }, sms...) 15367 if err != nil { 15368 return nil, err 15369 } 15370 return s, err 15371} 15372 15373// FieldScalarS16BE adds a field and reads 16 bit signed integer in big-endian 15374func (d *D) FieldScalarS16BE(name string, sms ...scalar.Mapper) *scalar.S { 15375 s, err := d.TryFieldScalarS16BE(name, sms...) 15376 if err != nil { 15377 panic(IOError{Err: err, Name: name, Op: "S16BE", Pos: d.Pos()}) 15378 } 15379 return s 15380} 15381 15382// TryFieldS16BE tries to add a field and read 16 bit signed integer in big-endian 15383func (d *D) TryFieldS16BE(name string, sms ...scalar.Mapper) (int64, error) { 15384 s, err := d.TryFieldScalarS16BE(name, sms...) 15385 return s.ActualS(), err 15386} 15387 15388// FieldS16BE adds a field and reads 16 bit signed integer in big-endian 15389func (d *D) FieldS16BE(name string, sms ...scalar.Mapper) int64 { 15390 return d.FieldScalarS16BE(name, sms...).ActualS() 15391} 15392 15393// Reader S17BE 15394 15395// TryS17BE tries to read 17 bit signed integer in big-endian 15396func (d *D) TryS17BE() (int64, error) { return d.trySE(17, BigEndian) } 15397 15398// S17BE reads 17 bit signed integer in big-endian 15399func (d *D) S17BE() int64 { 15400 v, err := d.trySE(17, BigEndian) 15401 if err != nil { 15402 panic(IOError{Err: err, Op: "S17BE", Pos: d.Pos()}) 15403 } 15404 return v 15405} 15406 15407// TryFieldScalarS17BE tries to add a field and read 17 bit signed integer in big-endian 15408func (d *D) TryFieldScalarS17BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 15409 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 15410 v, err := d.trySE(17, BigEndian) 15411 s.Actual = v 15412 return s, err 15413 }, sms...) 15414 if err != nil { 15415 return nil, err 15416 } 15417 return s, err 15418} 15419 15420// FieldScalarS17BE adds a field and reads 17 bit signed integer in big-endian 15421func (d *D) FieldScalarS17BE(name string, sms ...scalar.Mapper) *scalar.S { 15422 s, err := d.TryFieldScalarS17BE(name, sms...) 15423 if err != nil { 15424 panic(IOError{Err: err, Name: name, Op: "S17BE", Pos: d.Pos()}) 15425 } 15426 return s 15427} 15428 15429// TryFieldS17BE tries to add a field and read 17 bit signed integer in big-endian 15430func (d *D) TryFieldS17BE(name string, sms ...scalar.Mapper) (int64, error) { 15431 s, err := d.TryFieldScalarS17BE(name, sms...) 15432 return s.ActualS(), err 15433} 15434 15435// FieldS17BE adds a field and reads 17 bit signed integer in big-endian 15436func (d *D) FieldS17BE(name string, sms ...scalar.Mapper) int64 { 15437 return d.FieldScalarS17BE(name, sms...).ActualS() 15438} 15439 15440// Reader S18BE 15441 15442// TryS18BE tries to read 18 bit signed integer in big-endian 15443func (d *D) TryS18BE() (int64, error) { return d.trySE(18, BigEndian) } 15444 15445// S18BE reads 18 bit signed integer in big-endian 15446func (d *D) S18BE() int64 { 15447 v, err := d.trySE(18, BigEndian) 15448 if err != nil { 15449 panic(IOError{Err: err, Op: "S18BE", Pos: d.Pos()}) 15450 } 15451 return v 15452} 15453 15454// TryFieldScalarS18BE tries to add a field and read 18 bit signed integer in big-endian 15455func (d *D) TryFieldScalarS18BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 15456 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 15457 v, err := d.trySE(18, BigEndian) 15458 s.Actual = v 15459 return s, err 15460 }, sms...) 15461 if err != nil { 15462 return nil, err 15463 } 15464 return s, err 15465} 15466 15467// FieldScalarS18BE adds a field and reads 18 bit signed integer in big-endian 15468func (d *D) FieldScalarS18BE(name string, sms ...scalar.Mapper) *scalar.S { 15469 s, err := d.TryFieldScalarS18BE(name, sms...) 15470 if err != nil { 15471 panic(IOError{Err: err, Name: name, Op: "S18BE", Pos: d.Pos()}) 15472 } 15473 return s 15474} 15475 15476// TryFieldS18BE tries to add a field and read 18 bit signed integer in big-endian 15477func (d *D) TryFieldS18BE(name string, sms ...scalar.Mapper) (int64, error) { 15478 s, err := d.TryFieldScalarS18BE(name, sms...) 15479 return s.ActualS(), err 15480} 15481 15482// FieldS18BE adds a field and reads 18 bit signed integer in big-endian 15483func (d *D) FieldS18BE(name string, sms ...scalar.Mapper) int64 { 15484 return d.FieldScalarS18BE(name, sms...).ActualS() 15485} 15486 15487// Reader S19BE 15488 15489// TryS19BE tries to read 19 bit signed integer in big-endian 15490func (d *D) TryS19BE() (int64, error) { return d.trySE(19, BigEndian) } 15491 15492// S19BE reads 19 bit signed integer in big-endian 15493func (d *D) S19BE() int64 { 15494 v, err := d.trySE(19, BigEndian) 15495 if err != nil { 15496 panic(IOError{Err: err, Op: "S19BE", Pos: d.Pos()}) 15497 } 15498 return v 15499} 15500 15501// TryFieldScalarS19BE tries to add a field and read 19 bit signed integer in big-endian 15502func (d *D) TryFieldScalarS19BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 15503 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 15504 v, err := d.trySE(19, BigEndian) 15505 s.Actual = v 15506 return s, err 15507 }, sms...) 15508 if err != nil { 15509 return nil, err 15510 } 15511 return s, err 15512} 15513 15514// FieldScalarS19BE adds a field and reads 19 bit signed integer in big-endian 15515func (d *D) FieldScalarS19BE(name string, sms ...scalar.Mapper) *scalar.S { 15516 s, err := d.TryFieldScalarS19BE(name, sms...) 15517 if err != nil { 15518 panic(IOError{Err: err, Name: name, Op: "S19BE", Pos: d.Pos()}) 15519 } 15520 return s 15521} 15522 15523// TryFieldS19BE tries to add a field and read 19 bit signed integer in big-endian 15524func (d *D) TryFieldS19BE(name string, sms ...scalar.Mapper) (int64, error) { 15525 s, err := d.TryFieldScalarS19BE(name, sms...) 15526 return s.ActualS(), err 15527} 15528 15529// FieldS19BE adds a field and reads 19 bit signed integer in big-endian 15530func (d *D) FieldS19BE(name string, sms ...scalar.Mapper) int64 { 15531 return d.FieldScalarS19BE(name, sms...).ActualS() 15532} 15533 15534// Reader S20BE 15535 15536// TryS20BE tries to read 20 bit signed integer in big-endian 15537func (d *D) TryS20BE() (int64, error) { return d.trySE(20, BigEndian) } 15538 15539// S20BE reads 20 bit signed integer in big-endian 15540func (d *D) S20BE() int64 { 15541 v, err := d.trySE(20, BigEndian) 15542 if err != nil { 15543 panic(IOError{Err: err, Op: "S20BE", Pos: d.Pos()}) 15544 } 15545 return v 15546} 15547 15548// TryFieldScalarS20BE tries to add a field and read 20 bit signed integer in big-endian 15549func (d *D) TryFieldScalarS20BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 15550 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 15551 v, err := d.trySE(20, BigEndian) 15552 s.Actual = v 15553 return s, err 15554 }, sms...) 15555 if err != nil { 15556 return nil, err 15557 } 15558 return s, err 15559} 15560 15561// FieldScalarS20BE adds a field and reads 20 bit signed integer in big-endian 15562func (d *D) FieldScalarS20BE(name string, sms ...scalar.Mapper) *scalar.S { 15563 s, err := d.TryFieldScalarS20BE(name, sms...) 15564 if err != nil { 15565 panic(IOError{Err: err, Name: name, Op: "S20BE", Pos: d.Pos()}) 15566 } 15567 return s 15568} 15569 15570// TryFieldS20BE tries to add a field and read 20 bit signed integer in big-endian 15571func (d *D) TryFieldS20BE(name string, sms ...scalar.Mapper) (int64, error) { 15572 s, err := d.TryFieldScalarS20BE(name, sms...) 15573 return s.ActualS(), err 15574} 15575 15576// FieldS20BE adds a field and reads 20 bit signed integer in big-endian 15577func (d *D) FieldS20BE(name string, sms ...scalar.Mapper) int64 { 15578 return d.FieldScalarS20BE(name, sms...).ActualS() 15579} 15580 15581// Reader S21BE 15582 15583// TryS21BE tries to read 21 bit signed integer in big-endian 15584func (d *D) TryS21BE() (int64, error) { return d.trySE(21, BigEndian) } 15585 15586// S21BE reads 21 bit signed integer in big-endian 15587func (d *D) S21BE() int64 { 15588 v, err := d.trySE(21, BigEndian) 15589 if err != nil { 15590 panic(IOError{Err: err, Op: "S21BE", Pos: d.Pos()}) 15591 } 15592 return v 15593} 15594 15595// TryFieldScalarS21BE tries to add a field and read 21 bit signed integer in big-endian 15596func (d *D) TryFieldScalarS21BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 15597 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 15598 v, err := d.trySE(21, BigEndian) 15599 s.Actual = v 15600 return s, err 15601 }, sms...) 15602 if err != nil { 15603 return nil, err 15604 } 15605 return s, err 15606} 15607 15608// FieldScalarS21BE adds a field and reads 21 bit signed integer in big-endian 15609func (d *D) FieldScalarS21BE(name string, sms ...scalar.Mapper) *scalar.S { 15610 s, err := d.TryFieldScalarS21BE(name, sms...) 15611 if err != nil { 15612 panic(IOError{Err: err, Name: name, Op: "S21BE", Pos: d.Pos()}) 15613 } 15614 return s 15615} 15616 15617// TryFieldS21BE tries to add a field and read 21 bit signed integer in big-endian 15618func (d *D) TryFieldS21BE(name string, sms ...scalar.Mapper) (int64, error) { 15619 s, err := d.TryFieldScalarS21BE(name, sms...) 15620 return s.ActualS(), err 15621} 15622 15623// FieldS21BE adds a field and reads 21 bit signed integer in big-endian 15624func (d *D) FieldS21BE(name string, sms ...scalar.Mapper) int64 { 15625 return d.FieldScalarS21BE(name, sms...).ActualS() 15626} 15627 15628// Reader S22BE 15629 15630// TryS22BE tries to read 22 bit signed integer in big-endian 15631func (d *D) TryS22BE() (int64, error) { return d.trySE(22, BigEndian) } 15632 15633// S22BE reads 22 bit signed integer in big-endian 15634func (d *D) S22BE() int64 { 15635 v, err := d.trySE(22, BigEndian) 15636 if err != nil { 15637 panic(IOError{Err: err, Op: "S22BE", Pos: d.Pos()}) 15638 } 15639 return v 15640} 15641 15642// TryFieldScalarS22BE tries to add a field and read 22 bit signed integer in big-endian 15643func (d *D) TryFieldScalarS22BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 15644 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 15645 v, err := d.trySE(22, BigEndian) 15646 s.Actual = v 15647 return s, err 15648 }, sms...) 15649 if err != nil { 15650 return nil, err 15651 } 15652 return s, err 15653} 15654 15655// FieldScalarS22BE adds a field and reads 22 bit signed integer in big-endian 15656func (d *D) FieldScalarS22BE(name string, sms ...scalar.Mapper) *scalar.S { 15657 s, err := d.TryFieldScalarS22BE(name, sms...) 15658 if err != nil { 15659 panic(IOError{Err: err, Name: name, Op: "S22BE", Pos: d.Pos()}) 15660 } 15661 return s 15662} 15663 15664// TryFieldS22BE tries to add a field and read 22 bit signed integer in big-endian 15665func (d *D) TryFieldS22BE(name string, sms ...scalar.Mapper) (int64, error) { 15666 s, err := d.TryFieldScalarS22BE(name, sms...) 15667 return s.ActualS(), err 15668} 15669 15670// FieldS22BE adds a field and reads 22 bit signed integer in big-endian 15671func (d *D) FieldS22BE(name string, sms ...scalar.Mapper) int64 { 15672 return d.FieldScalarS22BE(name, sms...).ActualS() 15673} 15674 15675// Reader S23BE 15676 15677// TryS23BE tries to read 23 bit signed integer in big-endian 15678func (d *D) TryS23BE() (int64, error) { return d.trySE(23, BigEndian) } 15679 15680// S23BE reads 23 bit signed integer in big-endian 15681func (d *D) S23BE() int64 { 15682 v, err := d.trySE(23, BigEndian) 15683 if err != nil { 15684 panic(IOError{Err: err, Op: "S23BE", Pos: d.Pos()}) 15685 } 15686 return v 15687} 15688 15689// TryFieldScalarS23BE tries to add a field and read 23 bit signed integer in big-endian 15690func (d *D) TryFieldScalarS23BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 15691 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 15692 v, err := d.trySE(23, BigEndian) 15693 s.Actual = v 15694 return s, err 15695 }, sms...) 15696 if err != nil { 15697 return nil, err 15698 } 15699 return s, err 15700} 15701 15702// FieldScalarS23BE adds a field and reads 23 bit signed integer in big-endian 15703func (d *D) FieldScalarS23BE(name string, sms ...scalar.Mapper) *scalar.S { 15704 s, err := d.TryFieldScalarS23BE(name, sms...) 15705 if err != nil { 15706 panic(IOError{Err: err, Name: name, Op: "S23BE", Pos: d.Pos()}) 15707 } 15708 return s 15709} 15710 15711// TryFieldS23BE tries to add a field and read 23 bit signed integer in big-endian 15712func (d *D) TryFieldS23BE(name string, sms ...scalar.Mapper) (int64, error) { 15713 s, err := d.TryFieldScalarS23BE(name, sms...) 15714 return s.ActualS(), err 15715} 15716 15717// FieldS23BE adds a field and reads 23 bit signed integer in big-endian 15718func (d *D) FieldS23BE(name string, sms ...scalar.Mapper) int64 { 15719 return d.FieldScalarS23BE(name, sms...).ActualS() 15720} 15721 15722// Reader S24BE 15723 15724// TryS24BE tries to read 24 bit signed integer in big-endian 15725func (d *D) TryS24BE() (int64, error) { return d.trySE(24, BigEndian) } 15726 15727// S24BE reads 24 bit signed integer in big-endian 15728func (d *D) S24BE() int64 { 15729 v, err := d.trySE(24, BigEndian) 15730 if err != nil { 15731 panic(IOError{Err: err, Op: "S24BE", Pos: d.Pos()}) 15732 } 15733 return v 15734} 15735 15736// TryFieldScalarS24BE tries to add a field and read 24 bit signed integer in big-endian 15737func (d *D) TryFieldScalarS24BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 15738 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 15739 v, err := d.trySE(24, BigEndian) 15740 s.Actual = v 15741 return s, err 15742 }, sms...) 15743 if err != nil { 15744 return nil, err 15745 } 15746 return s, err 15747} 15748 15749// FieldScalarS24BE adds a field and reads 24 bit signed integer in big-endian 15750func (d *D) FieldScalarS24BE(name string, sms ...scalar.Mapper) *scalar.S { 15751 s, err := d.TryFieldScalarS24BE(name, sms...) 15752 if err != nil { 15753 panic(IOError{Err: err, Name: name, Op: "S24BE", Pos: d.Pos()}) 15754 } 15755 return s 15756} 15757 15758// TryFieldS24BE tries to add a field and read 24 bit signed integer in big-endian 15759func (d *D) TryFieldS24BE(name string, sms ...scalar.Mapper) (int64, error) { 15760 s, err := d.TryFieldScalarS24BE(name, sms...) 15761 return s.ActualS(), err 15762} 15763 15764// FieldS24BE adds a field and reads 24 bit signed integer in big-endian 15765func (d *D) FieldS24BE(name string, sms ...scalar.Mapper) int64 { 15766 return d.FieldScalarS24BE(name, sms...).ActualS() 15767} 15768 15769// Reader S25BE 15770 15771// TryS25BE tries to read 25 bit signed integer in big-endian 15772func (d *D) TryS25BE() (int64, error) { return d.trySE(25, BigEndian) } 15773 15774// S25BE reads 25 bit signed integer in big-endian 15775func (d *D) S25BE() int64 { 15776 v, err := d.trySE(25, BigEndian) 15777 if err != nil { 15778 panic(IOError{Err: err, Op: "S25BE", Pos: d.Pos()}) 15779 } 15780 return v 15781} 15782 15783// TryFieldScalarS25BE tries to add a field and read 25 bit signed integer in big-endian 15784func (d *D) TryFieldScalarS25BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 15785 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 15786 v, err := d.trySE(25, BigEndian) 15787 s.Actual = v 15788 return s, err 15789 }, sms...) 15790 if err != nil { 15791 return nil, err 15792 } 15793 return s, err 15794} 15795 15796// FieldScalarS25BE adds a field and reads 25 bit signed integer in big-endian 15797func (d *D) FieldScalarS25BE(name string, sms ...scalar.Mapper) *scalar.S { 15798 s, err := d.TryFieldScalarS25BE(name, sms...) 15799 if err != nil { 15800 panic(IOError{Err: err, Name: name, Op: "S25BE", Pos: d.Pos()}) 15801 } 15802 return s 15803} 15804 15805// TryFieldS25BE tries to add a field and read 25 bit signed integer in big-endian 15806func (d *D) TryFieldS25BE(name string, sms ...scalar.Mapper) (int64, error) { 15807 s, err := d.TryFieldScalarS25BE(name, sms...) 15808 return s.ActualS(), err 15809} 15810 15811// FieldS25BE adds a field and reads 25 bit signed integer in big-endian 15812func (d *D) FieldS25BE(name string, sms ...scalar.Mapper) int64 { 15813 return d.FieldScalarS25BE(name, sms...).ActualS() 15814} 15815 15816// Reader S26BE 15817 15818// TryS26BE tries to read 26 bit signed integer in big-endian 15819func (d *D) TryS26BE() (int64, error) { return d.trySE(26, BigEndian) } 15820 15821// S26BE reads 26 bit signed integer in big-endian 15822func (d *D) S26BE() int64 { 15823 v, err := d.trySE(26, BigEndian) 15824 if err != nil { 15825 panic(IOError{Err: err, Op: "S26BE", Pos: d.Pos()}) 15826 } 15827 return v 15828} 15829 15830// TryFieldScalarS26BE tries to add a field and read 26 bit signed integer in big-endian 15831func (d *D) TryFieldScalarS26BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 15832 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 15833 v, err := d.trySE(26, BigEndian) 15834 s.Actual = v 15835 return s, err 15836 }, sms...) 15837 if err != nil { 15838 return nil, err 15839 } 15840 return s, err 15841} 15842 15843// FieldScalarS26BE adds a field and reads 26 bit signed integer in big-endian 15844func (d *D) FieldScalarS26BE(name string, sms ...scalar.Mapper) *scalar.S { 15845 s, err := d.TryFieldScalarS26BE(name, sms...) 15846 if err != nil { 15847 panic(IOError{Err: err, Name: name, Op: "S26BE", Pos: d.Pos()}) 15848 } 15849 return s 15850} 15851 15852// TryFieldS26BE tries to add a field and read 26 bit signed integer in big-endian 15853func (d *D) TryFieldS26BE(name string, sms ...scalar.Mapper) (int64, error) { 15854 s, err := d.TryFieldScalarS26BE(name, sms...) 15855 return s.ActualS(), err 15856} 15857 15858// FieldS26BE adds a field and reads 26 bit signed integer in big-endian 15859func (d *D) FieldS26BE(name string, sms ...scalar.Mapper) int64 { 15860 return d.FieldScalarS26BE(name, sms...).ActualS() 15861} 15862 15863// Reader S27BE 15864 15865// TryS27BE tries to read 27 bit signed integer in big-endian 15866func (d *D) TryS27BE() (int64, error) { return d.trySE(27, BigEndian) } 15867 15868// S27BE reads 27 bit signed integer in big-endian 15869func (d *D) S27BE() int64 { 15870 v, err := d.trySE(27, BigEndian) 15871 if err != nil { 15872 panic(IOError{Err: err, Op: "S27BE", Pos: d.Pos()}) 15873 } 15874 return v 15875} 15876 15877// TryFieldScalarS27BE tries to add a field and read 27 bit signed integer in big-endian 15878func (d *D) TryFieldScalarS27BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 15879 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 15880 v, err := d.trySE(27, BigEndian) 15881 s.Actual = v 15882 return s, err 15883 }, sms...) 15884 if err != nil { 15885 return nil, err 15886 } 15887 return s, err 15888} 15889 15890// FieldScalarS27BE adds a field and reads 27 bit signed integer in big-endian 15891func (d *D) FieldScalarS27BE(name string, sms ...scalar.Mapper) *scalar.S { 15892 s, err := d.TryFieldScalarS27BE(name, sms...) 15893 if err != nil { 15894 panic(IOError{Err: err, Name: name, Op: "S27BE", Pos: d.Pos()}) 15895 } 15896 return s 15897} 15898 15899// TryFieldS27BE tries to add a field and read 27 bit signed integer in big-endian 15900func (d *D) TryFieldS27BE(name string, sms ...scalar.Mapper) (int64, error) { 15901 s, err := d.TryFieldScalarS27BE(name, sms...) 15902 return s.ActualS(), err 15903} 15904 15905// FieldS27BE adds a field and reads 27 bit signed integer in big-endian 15906func (d *D) FieldS27BE(name string, sms ...scalar.Mapper) int64 { 15907 return d.FieldScalarS27BE(name, sms...).ActualS() 15908} 15909 15910// Reader S28BE 15911 15912// TryS28BE tries to read 28 bit signed integer in big-endian 15913func (d *D) TryS28BE() (int64, error) { return d.trySE(28, BigEndian) } 15914 15915// S28BE reads 28 bit signed integer in big-endian 15916func (d *D) S28BE() int64 { 15917 v, err := d.trySE(28, BigEndian) 15918 if err != nil { 15919 panic(IOError{Err: err, Op: "S28BE", Pos: d.Pos()}) 15920 } 15921 return v 15922} 15923 15924// TryFieldScalarS28BE tries to add a field and read 28 bit signed integer in big-endian 15925func (d *D) TryFieldScalarS28BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 15926 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 15927 v, err := d.trySE(28, BigEndian) 15928 s.Actual = v 15929 return s, err 15930 }, sms...) 15931 if err != nil { 15932 return nil, err 15933 } 15934 return s, err 15935} 15936 15937// FieldScalarS28BE adds a field and reads 28 bit signed integer in big-endian 15938func (d *D) FieldScalarS28BE(name string, sms ...scalar.Mapper) *scalar.S { 15939 s, err := d.TryFieldScalarS28BE(name, sms...) 15940 if err != nil { 15941 panic(IOError{Err: err, Name: name, Op: "S28BE", Pos: d.Pos()}) 15942 } 15943 return s 15944} 15945 15946// TryFieldS28BE tries to add a field and read 28 bit signed integer in big-endian 15947func (d *D) TryFieldS28BE(name string, sms ...scalar.Mapper) (int64, error) { 15948 s, err := d.TryFieldScalarS28BE(name, sms...) 15949 return s.ActualS(), err 15950} 15951 15952// FieldS28BE adds a field and reads 28 bit signed integer in big-endian 15953func (d *D) FieldS28BE(name string, sms ...scalar.Mapper) int64 { 15954 return d.FieldScalarS28BE(name, sms...).ActualS() 15955} 15956 15957// Reader S29BE 15958 15959// TryS29BE tries to read 29 bit signed integer in big-endian 15960func (d *D) TryS29BE() (int64, error) { return d.trySE(29, BigEndian) } 15961 15962// S29BE reads 29 bit signed integer in big-endian 15963func (d *D) S29BE() int64 { 15964 v, err := d.trySE(29, BigEndian) 15965 if err != nil { 15966 panic(IOError{Err: err, Op: "S29BE", Pos: d.Pos()}) 15967 } 15968 return v 15969} 15970 15971// TryFieldScalarS29BE tries to add a field and read 29 bit signed integer in big-endian 15972func (d *D) TryFieldScalarS29BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 15973 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 15974 v, err := d.trySE(29, BigEndian) 15975 s.Actual = v 15976 return s, err 15977 }, sms...) 15978 if err != nil { 15979 return nil, err 15980 } 15981 return s, err 15982} 15983 15984// FieldScalarS29BE adds a field and reads 29 bit signed integer in big-endian 15985func (d *D) FieldScalarS29BE(name string, sms ...scalar.Mapper) *scalar.S { 15986 s, err := d.TryFieldScalarS29BE(name, sms...) 15987 if err != nil { 15988 panic(IOError{Err: err, Name: name, Op: "S29BE", Pos: d.Pos()}) 15989 } 15990 return s 15991} 15992 15993// TryFieldS29BE tries to add a field and read 29 bit signed integer in big-endian 15994func (d *D) TryFieldS29BE(name string, sms ...scalar.Mapper) (int64, error) { 15995 s, err := d.TryFieldScalarS29BE(name, sms...) 15996 return s.ActualS(), err 15997} 15998 15999// FieldS29BE adds a field and reads 29 bit signed integer in big-endian 16000func (d *D) FieldS29BE(name string, sms ...scalar.Mapper) int64 { 16001 return d.FieldScalarS29BE(name, sms...).ActualS() 16002} 16003 16004// Reader S30BE 16005 16006// TryS30BE tries to read 30 bit signed integer in big-endian 16007func (d *D) TryS30BE() (int64, error) { return d.trySE(30, BigEndian) } 16008 16009// S30BE reads 30 bit signed integer in big-endian 16010func (d *D) S30BE() int64 { 16011 v, err := d.trySE(30, BigEndian) 16012 if err != nil { 16013 panic(IOError{Err: err, Op: "S30BE", Pos: d.Pos()}) 16014 } 16015 return v 16016} 16017 16018// TryFieldScalarS30BE tries to add a field and read 30 bit signed integer in big-endian 16019func (d *D) TryFieldScalarS30BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 16020 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 16021 v, err := d.trySE(30, BigEndian) 16022 s.Actual = v 16023 return s, err 16024 }, sms...) 16025 if err != nil { 16026 return nil, err 16027 } 16028 return s, err 16029} 16030 16031// FieldScalarS30BE adds a field and reads 30 bit signed integer in big-endian 16032func (d *D) FieldScalarS30BE(name string, sms ...scalar.Mapper) *scalar.S { 16033 s, err := d.TryFieldScalarS30BE(name, sms...) 16034 if err != nil { 16035 panic(IOError{Err: err, Name: name, Op: "S30BE", Pos: d.Pos()}) 16036 } 16037 return s 16038} 16039 16040// TryFieldS30BE tries to add a field and read 30 bit signed integer in big-endian 16041func (d *D) TryFieldS30BE(name string, sms ...scalar.Mapper) (int64, error) { 16042 s, err := d.TryFieldScalarS30BE(name, sms...) 16043 return s.ActualS(), err 16044} 16045 16046// FieldS30BE adds a field and reads 30 bit signed integer in big-endian 16047func (d *D) FieldS30BE(name string, sms ...scalar.Mapper) int64 { 16048 return d.FieldScalarS30BE(name, sms...).ActualS() 16049} 16050 16051// Reader S31BE 16052 16053// TryS31BE tries to read 31 bit signed integer in big-endian 16054func (d *D) TryS31BE() (int64, error) { return d.trySE(31, BigEndian) } 16055 16056// S31BE reads 31 bit signed integer in big-endian 16057func (d *D) S31BE() int64 { 16058 v, err := d.trySE(31, BigEndian) 16059 if err != nil { 16060 panic(IOError{Err: err, Op: "S31BE", Pos: d.Pos()}) 16061 } 16062 return v 16063} 16064 16065// TryFieldScalarS31BE tries to add a field and read 31 bit signed integer in big-endian 16066func (d *D) TryFieldScalarS31BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 16067 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 16068 v, err := d.trySE(31, BigEndian) 16069 s.Actual = v 16070 return s, err 16071 }, sms...) 16072 if err != nil { 16073 return nil, err 16074 } 16075 return s, err 16076} 16077 16078// FieldScalarS31BE adds a field and reads 31 bit signed integer in big-endian 16079func (d *D) FieldScalarS31BE(name string, sms ...scalar.Mapper) *scalar.S { 16080 s, err := d.TryFieldScalarS31BE(name, sms...) 16081 if err != nil { 16082 panic(IOError{Err: err, Name: name, Op: "S31BE", Pos: d.Pos()}) 16083 } 16084 return s 16085} 16086 16087// TryFieldS31BE tries to add a field and read 31 bit signed integer in big-endian 16088func (d *D) TryFieldS31BE(name string, sms ...scalar.Mapper) (int64, error) { 16089 s, err := d.TryFieldScalarS31BE(name, sms...) 16090 return s.ActualS(), err 16091} 16092 16093// FieldS31BE adds a field and reads 31 bit signed integer in big-endian 16094func (d *D) FieldS31BE(name string, sms ...scalar.Mapper) int64 { 16095 return d.FieldScalarS31BE(name, sms...).ActualS() 16096} 16097 16098// Reader S32BE 16099 16100// TryS32BE tries to read 32 bit signed integer in big-endian 16101func (d *D) TryS32BE() (int64, error) { return d.trySE(32, BigEndian) } 16102 16103// S32BE reads 32 bit signed integer in big-endian 16104func (d *D) S32BE() int64 { 16105 v, err := d.trySE(32, BigEndian) 16106 if err != nil { 16107 panic(IOError{Err: err, Op: "S32BE", Pos: d.Pos()}) 16108 } 16109 return v 16110} 16111 16112// TryFieldScalarS32BE tries to add a field and read 32 bit signed integer in big-endian 16113func (d *D) TryFieldScalarS32BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 16114 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 16115 v, err := d.trySE(32, BigEndian) 16116 s.Actual = v 16117 return s, err 16118 }, sms...) 16119 if err != nil { 16120 return nil, err 16121 } 16122 return s, err 16123} 16124 16125// FieldScalarS32BE adds a field and reads 32 bit signed integer in big-endian 16126func (d *D) FieldScalarS32BE(name string, sms ...scalar.Mapper) *scalar.S { 16127 s, err := d.TryFieldScalarS32BE(name, sms...) 16128 if err != nil { 16129 panic(IOError{Err: err, Name: name, Op: "S32BE", Pos: d.Pos()}) 16130 } 16131 return s 16132} 16133 16134// TryFieldS32BE tries to add a field and read 32 bit signed integer in big-endian 16135func (d *D) TryFieldS32BE(name string, sms ...scalar.Mapper) (int64, error) { 16136 s, err := d.TryFieldScalarS32BE(name, sms...) 16137 return s.ActualS(), err 16138} 16139 16140// FieldS32BE adds a field and reads 32 bit signed integer in big-endian 16141func (d *D) FieldS32BE(name string, sms ...scalar.Mapper) int64 { 16142 return d.FieldScalarS32BE(name, sms...).ActualS() 16143} 16144 16145// Reader S33BE 16146 16147// TryS33BE tries to read 33 bit signed integer in big-endian 16148func (d *D) TryS33BE() (int64, error) { return d.trySE(33, BigEndian) } 16149 16150// S33BE reads 33 bit signed integer in big-endian 16151func (d *D) S33BE() int64 { 16152 v, err := d.trySE(33, BigEndian) 16153 if err != nil { 16154 panic(IOError{Err: err, Op: "S33BE", Pos: d.Pos()}) 16155 } 16156 return v 16157} 16158 16159// TryFieldScalarS33BE tries to add a field and read 33 bit signed integer in big-endian 16160func (d *D) TryFieldScalarS33BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 16161 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 16162 v, err := d.trySE(33, BigEndian) 16163 s.Actual = v 16164 return s, err 16165 }, sms...) 16166 if err != nil { 16167 return nil, err 16168 } 16169 return s, err 16170} 16171 16172// FieldScalarS33BE adds a field and reads 33 bit signed integer in big-endian 16173func (d *D) FieldScalarS33BE(name string, sms ...scalar.Mapper) *scalar.S { 16174 s, err := d.TryFieldScalarS33BE(name, sms...) 16175 if err != nil { 16176 panic(IOError{Err: err, Name: name, Op: "S33BE", Pos: d.Pos()}) 16177 } 16178 return s 16179} 16180 16181// TryFieldS33BE tries to add a field and read 33 bit signed integer in big-endian 16182func (d *D) TryFieldS33BE(name string, sms ...scalar.Mapper) (int64, error) { 16183 s, err := d.TryFieldScalarS33BE(name, sms...) 16184 return s.ActualS(), err 16185} 16186 16187// FieldS33BE adds a field and reads 33 bit signed integer in big-endian 16188func (d *D) FieldS33BE(name string, sms ...scalar.Mapper) int64 { 16189 return d.FieldScalarS33BE(name, sms...).ActualS() 16190} 16191 16192// Reader S34BE 16193 16194// TryS34BE tries to read 34 bit signed integer in big-endian 16195func (d *D) TryS34BE() (int64, error) { return d.trySE(34, BigEndian) } 16196 16197// S34BE reads 34 bit signed integer in big-endian 16198func (d *D) S34BE() int64 { 16199 v, err := d.trySE(34, BigEndian) 16200 if err != nil { 16201 panic(IOError{Err: err, Op: "S34BE", Pos: d.Pos()}) 16202 } 16203 return v 16204} 16205 16206// TryFieldScalarS34BE tries to add a field and read 34 bit signed integer in big-endian 16207func (d *D) TryFieldScalarS34BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 16208 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 16209 v, err := d.trySE(34, BigEndian) 16210 s.Actual = v 16211 return s, err 16212 }, sms...) 16213 if err != nil { 16214 return nil, err 16215 } 16216 return s, err 16217} 16218 16219// FieldScalarS34BE adds a field and reads 34 bit signed integer in big-endian 16220func (d *D) FieldScalarS34BE(name string, sms ...scalar.Mapper) *scalar.S { 16221 s, err := d.TryFieldScalarS34BE(name, sms...) 16222 if err != nil { 16223 panic(IOError{Err: err, Name: name, Op: "S34BE", Pos: d.Pos()}) 16224 } 16225 return s 16226} 16227 16228// TryFieldS34BE tries to add a field and read 34 bit signed integer in big-endian 16229func (d *D) TryFieldS34BE(name string, sms ...scalar.Mapper) (int64, error) { 16230 s, err := d.TryFieldScalarS34BE(name, sms...) 16231 return s.ActualS(), err 16232} 16233 16234// FieldS34BE adds a field and reads 34 bit signed integer in big-endian 16235func (d *D) FieldS34BE(name string, sms ...scalar.Mapper) int64 { 16236 return d.FieldScalarS34BE(name, sms...).ActualS() 16237} 16238 16239// Reader S35BE 16240 16241// TryS35BE tries to read 35 bit signed integer in big-endian 16242func (d *D) TryS35BE() (int64, error) { return d.trySE(35, BigEndian) } 16243 16244// S35BE reads 35 bit signed integer in big-endian 16245func (d *D) S35BE() int64 { 16246 v, err := d.trySE(35, BigEndian) 16247 if err != nil { 16248 panic(IOError{Err: err, Op: "S35BE", Pos: d.Pos()}) 16249 } 16250 return v 16251} 16252 16253// TryFieldScalarS35BE tries to add a field and read 35 bit signed integer in big-endian 16254func (d *D) TryFieldScalarS35BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 16255 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 16256 v, err := d.trySE(35, BigEndian) 16257 s.Actual = v 16258 return s, err 16259 }, sms...) 16260 if err != nil { 16261 return nil, err 16262 } 16263 return s, err 16264} 16265 16266// FieldScalarS35BE adds a field and reads 35 bit signed integer in big-endian 16267func (d *D) FieldScalarS35BE(name string, sms ...scalar.Mapper) *scalar.S { 16268 s, err := d.TryFieldScalarS35BE(name, sms...) 16269 if err != nil { 16270 panic(IOError{Err: err, Name: name, Op: "S35BE", Pos: d.Pos()}) 16271 } 16272 return s 16273} 16274 16275// TryFieldS35BE tries to add a field and read 35 bit signed integer in big-endian 16276func (d *D) TryFieldS35BE(name string, sms ...scalar.Mapper) (int64, error) { 16277 s, err := d.TryFieldScalarS35BE(name, sms...) 16278 return s.ActualS(), err 16279} 16280 16281// FieldS35BE adds a field and reads 35 bit signed integer in big-endian 16282func (d *D) FieldS35BE(name string, sms ...scalar.Mapper) int64 { 16283 return d.FieldScalarS35BE(name, sms...).ActualS() 16284} 16285 16286// Reader S36BE 16287 16288// TryS36BE tries to read 36 bit signed integer in big-endian 16289func (d *D) TryS36BE() (int64, error) { return d.trySE(36, BigEndian) } 16290 16291// S36BE reads 36 bit signed integer in big-endian 16292func (d *D) S36BE() int64 { 16293 v, err := d.trySE(36, BigEndian) 16294 if err != nil { 16295 panic(IOError{Err: err, Op: "S36BE", Pos: d.Pos()}) 16296 } 16297 return v 16298} 16299 16300// TryFieldScalarS36BE tries to add a field and read 36 bit signed integer in big-endian 16301func (d *D) TryFieldScalarS36BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 16302 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 16303 v, err := d.trySE(36, BigEndian) 16304 s.Actual = v 16305 return s, err 16306 }, sms...) 16307 if err != nil { 16308 return nil, err 16309 } 16310 return s, err 16311} 16312 16313// FieldScalarS36BE adds a field and reads 36 bit signed integer in big-endian 16314func (d *D) FieldScalarS36BE(name string, sms ...scalar.Mapper) *scalar.S { 16315 s, err := d.TryFieldScalarS36BE(name, sms...) 16316 if err != nil { 16317 panic(IOError{Err: err, Name: name, Op: "S36BE", Pos: d.Pos()}) 16318 } 16319 return s 16320} 16321 16322// TryFieldS36BE tries to add a field and read 36 bit signed integer in big-endian 16323func (d *D) TryFieldS36BE(name string, sms ...scalar.Mapper) (int64, error) { 16324 s, err := d.TryFieldScalarS36BE(name, sms...) 16325 return s.ActualS(), err 16326} 16327 16328// FieldS36BE adds a field and reads 36 bit signed integer in big-endian 16329func (d *D) FieldS36BE(name string, sms ...scalar.Mapper) int64 { 16330 return d.FieldScalarS36BE(name, sms...).ActualS() 16331} 16332 16333// Reader S37BE 16334 16335// TryS37BE tries to read 37 bit signed integer in big-endian 16336func (d *D) TryS37BE() (int64, error) { return d.trySE(37, BigEndian) } 16337 16338// S37BE reads 37 bit signed integer in big-endian 16339func (d *D) S37BE() int64 { 16340 v, err := d.trySE(37, BigEndian) 16341 if err != nil { 16342 panic(IOError{Err: err, Op: "S37BE", Pos: d.Pos()}) 16343 } 16344 return v 16345} 16346 16347// TryFieldScalarS37BE tries to add a field and read 37 bit signed integer in big-endian 16348func (d *D) TryFieldScalarS37BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 16349 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 16350 v, err := d.trySE(37, BigEndian) 16351 s.Actual = v 16352 return s, err 16353 }, sms...) 16354 if err != nil { 16355 return nil, err 16356 } 16357 return s, err 16358} 16359 16360// FieldScalarS37BE adds a field and reads 37 bit signed integer in big-endian 16361func (d *D) FieldScalarS37BE(name string, sms ...scalar.Mapper) *scalar.S { 16362 s, err := d.TryFieldScalarS37BE(name, sms...) 16363 if err != nil { 16364 panic(IOError{Err: err, Name: name, Op: "S37BE", Pos: d.Pos()}) 16365 } 16366 return s 16367} 16368 16369// TryFieldS37BE tries to add a field and read 37 bit signed integer in big-endian 16370func (d *D) TryFieldS37BE(name string, sms ...scalar.Mapper) (int64, error) { 16371 s, err := d.TryFieldScalarS37BE(name, sms...) 16372 return s.ActualS(), err 16373} 16374 16375// FieldS37BE adds a field and reads 37 bit signed integer in big-endian 16376func (d *D) FieldS37BE(name string, sms ...scalar.Mapper) int64 { 16377 return d.FieldScalarS37BE(name, sms...).ActualS() 16378} 16379 16380// Reader S38BE 16381 16382// TryS38BE tries to read 38 bit signed integer in big-endian 16383func (d *D) TryS38BE() (int64, error) { return d.trySE(38, BigEndian) } 16384 16385// S38BE reads 38 bit signed integer in big-endian 16386func (d *D) S38BE() int64 { 16387 v, err := d.trySE(38, BigEndian) 16388 if err != nil { 16389 panic(IOError{Err: err, Op: "S38BE", Pos: d.Pos()}) 16390 } 16391 return v 16392} 16393 16394// TryFieldScalarS38BE tries to add a field and read 38 bit signed integer in big-endian 16395func (d *D) TryFieldScalarS38BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 16396 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 16397 v, err := d.trySE(38, BigEndian) 16398 s.Actual = v 16399 return s, err 16400 }, sms...) 16401 if err != nil { 16402 return nil, err 16403 } 16404 return s, err 16405} 16406 16407// FieldScalarS38BE adds a field and reads 38 bit signed integer in big-endian 16408func (d *D) FieldScalarS38BE(name string, sms ...scalar.Mapper) *scalar.S { 16409 s, err := d.TryFieldScalarS38BE(name, sms...) 16410 if err != nil { 16411 panic(IOError{Err: err, Name: name, Op: "S38BE", Pos: d.Pos()}) 16412 } 16413 return s 16414} 16415 16416// TryFieldS38BE tries to add a field and read 38 bit signed integer in big-endian 16417func (d *D) TryFieldS38BE(name string, sms ...scalar.Mapper) (int64, error) { 16418 s, err := d.TryFieldScalarS38BE(name, sms...) 16419 return s.ActualS(), err 16420} 16421 16422// FieldS38BE adds a field and reads 38 bit signed integer in big-endian 16423func (d *D) FieldS38BE(name string, sms ...scalar.Mapper) int64 { 16424 return d.FieldScalarS38BE(name, sms...).ActualS() 16425} 16426 16427// Reader S39BE 16428 16429// TryS39BE tries to read 39 bit signed integer in big-endian 16430func (d *D) TryS39BE() (int64, error) { return d.trySE(39, BigEndian) } 16431 16432// S39BE reads 39 bit signed integer in big-endian 16433func (d *D) S39BE() int64 { 16434 v, err := d.trySE(39, BigEndian) 16435 if err != nil { 16436 panic(IOError{Err: err, Op: "S39BE", Pos: d.Pos()}) 16437 } 16438 return v 16439} 16440 16441// TryFieldScalarS39BE tries to add a field and read 39 bit signed integer in big-endian 16442func (d *D) TryFieldScalarS39BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 16443 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 16444 v, err := d.trySE(39, BigEndian) 16445 s.Actual = v 16446 return s, err 16447 }, sms...) 16448 if err != nil { 16449 return nil, err 16450 } 16451 return s, err 16452} 16453 16454// FieldScalarS39BE adds a field and reads 39 bit signed integer in big-endian 16455func (d *D) FieldScalarS39BE(name string, sms ...scalar.Mapper) *scalar.S { 16456 s, err := d.TryFieldScalarS39BE(name, sms...) 16457 if err != nil { 16458 panic(IOError{Err: err, Name: name, Op: "S39BE", Pos: d.Pos()}) 16459 } 16460 return s 16461} 16462 16463// TryFieldS39BE tries to add a field and read 39 bit signed integer in big-endian 16464func (d *D) TryFieldS39BE(name string, sms ...scalar.Mapper) (int64, error) { 16465 s, err := d.TryFieldScalarS39BE(name, sms...) 16466 return s.ActualS(), err 16467} 16468 16469// FieldS39BE adds a field and reads 39 bit signed integer in big-endian 16470func (d *D) FieldS39BE(name string, sms ...scalar.Mapper) int64 { 16471 return d.FieldScalarS39BE(name, sms...).ActualS() 16472} 16473 16474// Reader S40BE 16475 16476// TryS40BE tries to read 40 bit signed integer in big-endian 16477func (d *D) TryS40BE() (int64, error) { return d.trySE(40, BigEndian) } 16478 16479// S40BE reads 40 bit signed integer in big-endian 16480func (d *D) S40BE() int64 { 16481 v, err := d.trySE(40, BigEndian) 16482 if err != nil { 16483 panic(IOError{Err: err, Op: "S40BE", Pos: d.Pos()}) 16484 } 16485 return v 16486} 16487 16488// TryFieldScalarS40BE tries to add a field and read 40 bit signed integer in big-endian 16489func (d *D) TryFieldScalarS40BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 16490 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 16491 v, err := d.trySE(40, BigEndian) 16492 s.Actual = v 16493 return s, err 16494 }, sms...) 16495 if err != nil { 16496 return nil, err 16497 } 16498 return s, err 16499} 16500 16501// FieldScalarS40BE adds a field and reads 40 bit signed integer in big-endian 16502func (d *D) FieldScalarS40BE(name string, sms ...scalar.Mapper) *scalar.S { 16503 s, err := d.TryFieldScalarS40BE(name, sms...) 16504 if err != nil { 16505 panic(IOError{Err: err, Name: name, Op: "S40BE", Pos: d.Pos()}) 16506 } 16507 return s 16508} 16509 16510// TryFieldS40BE tries to add a field and read 40 bit signed integer in big-endian 16511func (d *D) TryFieldS40BE(name string, sms ...scalar.Mapper) (int64, error) { 16512 s, err := d.TryFieldScalarS40BE(name, sms...) 16513 return s.ActualS(), err 16514} 16515 16516// FieldS40BE adds a field and reads 40 bit signed integer in big-endian 16517func (d *D) FieldS40BE(name string, sms ...scalar.Mapper) int64 { 16518 return d.FieldScalarS40BE(name, sms...).ActualS() 16519} 16520 16521// Reader S41BE 16522 16523// TryS41BE tries to read 41 bit signed integer in big-endian 16524func (d *D) TryS41BE() (int64, error) { return d.trySE(41, BigEndian) } 16525 16526// S41BE reads 41 bit signed integer in big-endian 16527func (d *D) S41BE() int64 { 16528 v, err := d.trySE(41, BigEndian) 16529 if err != nil { 16530 panic(IOError{Err: err, Op: "S41BE", Pos: d.Pos()}) 16531 } 16532 return v 16533} 16534 16535// TryFieldScalarS41BE tries to add a field and read 41 bit signed integer in big-endian 16536func (d *D) TryFieldScalarS41BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 16537 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 16538 v, err := d.trySE(41, BigEndian) 16539 s.Actual = v 16540 return s, err 16541 }, sms...) 16542 if err != nil { 16543 return nil, err 16544 } 16545 return s, err 16546} 16547 16548// FieldScalarS41BE adds a field and reads 41 bit signed integer in big-endian 16549func (d *D) FieldScalarS41BE(name string, sms ...scalar.Mapper) *scalar.S { 16550 s, err := d.TryFieldScalarS41BE(name, sms...) 16551 if err != nil { 16552 panic(IOError{Err: err, Name: name, Op: "S41BE", Pos: d.Pos()}) 16553 } 16554 return s 16555} 16556 16557// TryFieldS41BE tries to add a field and read 41 bit signed integer in big-endian 16558func (d *D) TryFieldS41BE(name string, sms ...scalar.Mapper) (int64, error) { 16559 s, err := d.TryFieldScalarS41BE(name, sms...) 16560 return s.ActualS(), err 16561} 16562 16563// FieldS41BE adds a field and reads 41 bit signed integer in big-endian 16564func (d *D) FieldS41BE(name string, sms ...scalar.Mapper) int64 { 16565 return d.FieldScalarS41BE(name, sms...).ActualS() 16566} 16567 16568// Reader S42BE 16569 16570// TryS42BE tries to read 42 bit signed integer in big-endian 16571func (d *D) TryS42BE() (int64, error) { return d.trySE(42, BigEndian) } 16572 16573// S42BE reads 42 bit signed integer in big-endian 16574func (d *D) S42BE() int64 { 16575 v, err := d.trySE(42, BigEndian) 16576 if err != nil { 16577 panic(IOError{Err: err, Op: "S42BE", Pos: d.Pos()}) 16578 } 16579 return v 16580} 16581 16582// TryFieldScalarS42BE tries to add a field and read 42 bit signed integer in big-endian 16583func (d *D) TryFieldScalarS42BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 16584 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 16585 v, err := d.trySE(42, BigEndian) 16586 s.Actual = v 16587 return s, err 16588 }, sms...) 16589 if err != nil { 16590 return nil, err 16591 } 16592 return s, err 16593} 16594 16595// FieldScalarS42BE adds a field and reads 42 bit signed integer in big-endian 16596func (d *D) FieldScalarS42BE(name string, sms ...scalar.Mapper) *scalar.S { 16597 s, err := d.TryFieldScalarS42BE(name, sms...) 16598 if err != nil { 16599 panic(IOError{Err: err, Name: name, Op: "S42BE", Pos: d.Pos()}) 16600 } 16601 return s 16602} 16603 16604// TryFieldS42BE tries to add a field and read 42 bit signed integer in big-endian 16605func (d *D) TryFieldS42BE(name string, sms ...scalar.Mapper) (int64, error) { 16606 s, err := d.TryFieldScalarS42BE(name, sms...) 16607 return s.ActualS(), err 16608} 16609 16610// FieldS42BE adds a field and reads 42 bit signed integer in big-endian 16611func (d *D) FieldS42BE(name string, sms ...scalar.Mapper) int64 { 16612 return d.FieldScalarS42BE(name, sms...).ActualS() 16613} 16614 16615// Reader S43BE 16616 16617// TryS43BE tries to read 43 bit signed integer in big-endian 16618func (d *D) TryS43BE() (int64, error) { return d.trySE(43, BigEndian) } 16619 16620// S43BE reads 43 bit signed integer in big-endian 16621func (d *D) S43BE() int64 { 16622 v, err := d.trySE(43, BigEndian) 16623 if err != nil { 16624 panic(IOError{Err: err, Op: "S43BE", Pos: d.Pos()}) 16625 } 16626 return v 16627} 16628 16629// TryFieldScalarS43BE tries to add a field and read 43 bit signed integer in big-endian 16630func (d *D) TryFieldScalarS43BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 16631 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 16632 v, err := d.trySE(43, BigEndian) 16633 s.Actual = v 16634 return s, err 16635 }, sms...) 16636 if err != nil { 16637 return nil, err 16638 } 16639 return s, err 16640} 16641 16642// FieldScalarS43BE adds a field and reads 43 bit signed integer in big-endian 16643func (d *D) FieldScalarS43BE(name string, sms ...scalar.Mapper) *scalar.S { 16644 s, err := d.TryFieldScalarS43BE(name, sms...) 16645 if err != nil { 16646 panic(IOError{Err: err, Name: name, Op: "S43BE", Pos: d.Pos()}) 16647 } 16648 return s 16649} 16650 16651// TryFieldS43BE tries to add a field and read 43 bit signed integer in big-endian 16652func (d *D) TryFieldS43BE(name string, sms ...scalar.Mapper) (int64, error) { 16653 s, err := d.TryFieldScalarS43BE(name, sms...) 16654 return s.ActualS(), err 16655} 16656 16657// FieldS43BE adds a field and reads 43 bit signed integer in big-endian 16658func (d *D) FieldS43BE(name string, sms ...scalar.Mapper) int64 { 16659 return d.FieldScalarS43BE(name, sms...).ActualS() 16660} 16661 16662// Reader S44BE 16663 16664// TryS44BE tries to read 44 bit signed integer in big-endian 16665func (d *D) TryS44BE() (int64, error) { return d.trySE(44, BigEndian) } 16666 16667// S44BE reads 44 bit signed integer in big-endian 16668func (d *D) S44BE() int64 { 16669 v, err := d.trySE(44, BigEndian) 16670 if err != nil { 16671 panic(IOError{Err: err, Op: "S44BE", Pos: d.Pos()}) 16672 } 16673 return v 16674} 16675 16676// TryFieldScalarS44BE tries to add a field and read 44 bit signed integer in big-endian 16677func (d *D) TryFieldScalarS44BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 16678 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 16679 v, err := d.trySE(44, BigEndian) 16680 s.Actual = v 16681 return s, err 16682 }, sms...) 16683 if err != nil { 16684 return nil, err 16685 } 16686 return s, err 16687} 16688 16689// FieldScalarS44BE adds a field and reads 44 bit signed integer in big-endian 16690func (d *D) FieldScalarS44BE(name string, sms ...scalar.Mapper) *scalar.S { 16691 s, err := d.TryFieldScalarS44BE(name, sms...) 16692 if err != nil { 16693 panic(IOError{Err: err, Name: name, Op: "S44BE", Pos: d.Pos()}) 16694 } 16695 return s 16696} 16697 16698// TryFieldS44BE tries to add a field and read 44 bit signed integer in big-endian 16699func (d *D) TryFieldS44BE(name string, sms ...scalar.Mapper) (int64, error) { 16700 s, err := d.TryFieldScalarS44BE(name, sms...) 16701 return s.ActualS(), err 16702} 16703 16704// FieldS44BE adds a field and reads 44 bit signed integer in big-endian 16705func (d *D) FieldS44BE(name string, sms ...scalar.Mapper) int64 { 16706 return d.FieldScalarS44BE(name, sms...).ActualS() 16707} 16708 16709// Reader S45BE 16710 16711// TryS45BE tries to read 45 bit signed integer in big-endian 16712func (d *D) TryS45BE() (int64, error) { return d.trySE(45, BigEndian) } 16713 16714// S45BE reads 45 bit signed integer in big-endian 16715func (d *D) S45BE() int64 { 16716 v, err := d.trySE(45, BigEndian) 16717 if err != nil { 16718 panic(IOError{Err: err, Op: "S45BE", Pos: d.Pos()}) 16719 } 16720 return v 16721} 16722 16723// TryFieldScalarS45BE tries to add a field and read 45 bit signed integer in big-endian 16724func (d *D) TryFieldScalarS45BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 16725 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 16726 v, err := d.trySE(45, BigEndian) 16727 s.Actual = v 16728 return s, err 16729 }, sms...) 16730 if err != nil { 16731 return nil, err 16732 } 16733 return s, err 16734} 16735 16736// FieldScalarS45BE adds a field and reads 45 bit signed integer in big-endian 16737func (d *D) FieldScalarS45BE(name string, sms ...scalar.Mapper) *scalar.S { 16738 s, err := d.TryFieldScalarS45BE(name, sms...) 16739 if err != nil { 16740 panic(IOError{Err: err, Name: name, Op: "S45BE", Pos: d.Pos()}) 16741 } 16742 return s 16743} 16744 16745// TryFieldS45BE tries to add a field and read 45 bit signed integer in big-endian 16746func (d *D) TryFieldS45BE(name string, sms ...scalar.Mapper) (int64, error) { 16747 s, err := d.TryFieldScalarS45BE(name, sms...) 16748 return s.ActualS(), err 16749} 16750 16751// FieldS45BE adds a field and reads 45 bit signed integer in big-endian 16752func (d *D) FieldS45BE(name string, sms ...scalar.Mapper) int64 { 16753 return d.FieldScalarS45BE(name, sms...).ActualS() 16754} 16755 16756// Reader S46BE 16757 16758// TryS46BE tries to read 46 bit signed integer in big-endian 16759func (d *D) TryS46BE() (int64, error) { return d.trySE(46, BigEndian) } 16760 16761// S46BE reads 46 bit signed integer in big-endian 16762func (d *D) S46BE() int64 { 16763 v, err := d.trySE(46, BigEndian) 16764 if err != nil { 16765 panic(IOError{Err: err, Op: "S46BE", Pos: d.Pos()}) 16766 } 16767 return v 16768} 16769 16770// TryFieldScalarS46BE tries to add a field and read 46 bit signed integer in big-endian 16771func (d *D) TryFieldScalarS46BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 16772 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 16773 v, err := d.trySE(46, BigEndian) 16774 s.Actual = v 16775 return s, err 16776 }, sms...) 16777 if err != nil { 16778 return nil, err 16779 } 16780 return s, err 16781} 16782 16783// FieldScalarS46BE adds a field and reads 46 bit signed integer in big-endian 16784func (d *D) FieldScalarS46BE(name string, sms ...scalar.Mapper) *scalar.S { 16785 s, err := d.TryFieldScalarS46BE(name, sms...) 16786 if err != nil { 16787 panic(IOError{Err: err, Name: name, Op: "S46BE", Pos: d.Pos()}) 16788 } 16789 return s 16790} 16791 16792// TryFieldS46BE tries to add a field and read 46 bit signed integer in big-endian 16793func (d *D) TryFieldS46BE(name string, sms ...scalar.Mapper) (int64, error) { 16794 s, err := d.TryFieldScalarS46BE(name, sms...) 16795 return s.ActualS(), err 16796} 16797 16798// FieldS46BE adds a field and reads 46 bit signed integer in big-endian 16799func (d *D) FieldS46BE(name string, sms ...scalar.Mapper) int64 { 16800 return d.FieldScalarS46BE(name, sms...).ActualS() 16801} 16802 16803// Reader S47BE 16804 16805// TryS47BE tries to read 47 bit signed integer in big-endian 16806func (d *D) TryS47BE() (int64, error) { return d.trySE(47, BigEndian) } 16807 16808// S47BE reads 47 bit signed integer in big-endian 16809func (d *D) S47BE() int64 { 16810 v, err := d.trySE(47, BigEndian) 16811 if err != nil { 16812 panic(IOError{Err: err, Op: "S47BE", Pos: d.Pos()}) 16813 } 16814 return v 16815} 16816 16817// TryFieldScalarS47BE tries to add a field and read 47 bit signed integer in big-endian 16818func (d *D) TryFieldScalarS47BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 16819 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 16820 v, err := d.trySE(47, BigEndian) 16821 s.Actual = v 16822 return s, err 16823 }, sms...) 16824 if err != nil { 16825 return nil, err 16826 } 16827 return s, err 16828} 16829 16830// FieldScalarS47BE adds a field and reads 47 bit signed integer in big-endian 16831func (d *D) FieldScalarS47BE(name string, sms ...scalar.Mapper) *scalar.S { 16832 s, err := d.TryFieldScalarS47BE(name, sms...) 16833 if err != nil { 16834 panic(IOError{Err: err, Name: name, Op: "S47BE", Pos: d.Pos()}) 16835 } 16836 return s 16837} 16838 16839// TryFieldS47BE tries to add a field and read 47 bit signed integer in big-endian 16840func (d *D) TryFieldS47BE(name string, sms ...scalar.Mapper) (int64, error) { 16841 s, err := d.TryFieldScalarS47BE(name, sms...) 16842 return s.ActualS(), err 16843} 16844 16845// FieldS47BE adds a field and reads 47 bit signed integer in big-endian 16846func (d *D) FieldS47BE(name string, sms ...scalar.Mapper) int64 { 16847 return d.FieldScalarS47BE(name, sms...).ActualS() 16848} 16849 16850// Reader S48BE 16851 16852// TryS48BE tries to read 48 bit signed integer in big-endian 16853func (d *D) TryS48BE() (int64, error) { return d.trySE(48, BigEndian) } 16854 16855// S48BE reads 48 bit signed integer in big-endian 16856func (d *D) S48BE() int64 { 16857 v, err := d.trySE(48, BigEndian) 16858 if err != nil { 16859 panic(IOError{Err: err, Op: "S48BE", Pos: d.Pos()}) 16860 } 16861 return v 16862} 16863 16864// TryFieldScalarS48BE tries to add a field and read 48 bit signed integer in big-endian 16865func (d *D) TryFieldScalarS48BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 16866 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 16867 v, err := d.trySE(48, BigEndian) 16868 s.Actual = v 16869 return s, err 16870 }, sms...) 16871 if err != nil { 16872 return nil, err 16873 } 16874 return s, err 16875} 16876 16877// FieldScalarS48BE adds a field and reads 48 bit signed integer in big-endian 16878func (d *D) FieldScalarS48BE(name string, sms ...scalar.Mapper) *scalar.S { 16879 s, err := d.TryFieldScalarS48BE(name, sms...) 16880 if err != nil { 16881 panic(IOError{Err: err, Name: name, Op: "S48BE", Pos: d.Pos()}) 16882 } 16883 return s 16884} 16885 16886// TryFieldS48BE tries to add a field and read 48 bit signed integer in big-endian 16887func (d *D) TryFieldS48BE(name string, sms ...scalar.Mapper) (int64, error) { 16888 s, err := d.TryFieldScalarS48BE(name, sms...) 16889 return s.ActualS(), err 16890} 16891 16892// FieldS48BE adds a field and reads 48 bit signed integer in big-endian 16893func (d *D) FieldS48BE(name string, sms ...scalar.Mapper) int64 { 16894 return d.FieldScalarS48BE(name, sms...).ActualS() 16895} 16896 16897// Reader S49BE 16898 16899// TryS49BE tries to read 49 bit signed integer in big-endian 16900func (d *D) TryS49BE() (int64, error) { return d.trySE(49, BigEndian) } 16901 16902// S49BE reads 49 bit signed integer in big-endian 16903func (d *D) S49BE() int64 { 16904 v, err := d.trySE(49, BigEndian) 16905 if err != nil { 16906 panic(IOError{Err: err, Op: "S49BE", Pos: d.Pos()}) 16907 } 16908 return v 16909} 16910 16911// TryFieldScalarS49BE tries to add a field and read 49 bit signed integer in big-endian 16912func (d *D) TryFieldScalarS49BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 16913 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 16914 v, err := d.trySE(49, BigEndian) 16915 s.Actual = v 16916 return s, err 16917 }, sms...) 16918 if err != nil { 16919 return nil, err 16920 } 16921 return s, err 16922} 16923 16924// FieldScalarS49BE adds a field and reads 49 bit signed integer in big-endian 16925func (d *D) FieldScalarS49BE(name string, sms ...scalar.Mapper) *scalar.S { 16926 s, err := d.TryFieldScalarS49BE(name, sms...) 16927 if err != nil { 16928 panic(IOError{Err: err, Name: name, Op: "S49BE", Pos: d.Pos()}) 16929 } 16930 return s 16931} 16932 16933// TryFieldS49BE tries to add a field and read 49 bit signed integer in big-endian 16934func (d *D) TryFieldS49BE(name string, sms ...scalar.Mapper) (int64, error) { 16935 s, err := d.TryFieldScalarS49BE(name, sms...) 16936 return s.ActualS(), err 16937} 16938 16939// FieldS49BE adds a field and reads 49 bit signed integer in big-endian 16940func (d *D) FieldS49BE(name string, sms ...scalar.Mapper) int64 { 16941 return d.FieldScalarS49BE(name, sms...).ActualS() 16942} 16943 16944// Reader S50BE 16945 16946// TryS50BE tries to read 50 bit signed integer in big-endian 16947func (d *D) TryS50BE() (int64, error) { return d.trySE(50, BigEndian) } 16948 16949// S50BE reads 50 bit signed integer in big-endian 16950func (d *D) S50BE() int64 { 16951 v, err := d.trySE(50, BigEndian) 16952 if err != nil { 16953 panic(IOError{Err: err, Op: "S50BE", Pos: d.Pos()}) 16954 } 16955 return v 16956} 16957 16958// TryFieldScalarS50BE tries to add a field and read 50 bit signed integer in big-endian 16959func (d *D) TryFieldScalarS50BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 16960 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 16961 v, err := d.trySE(50, BigEndian) 16962 s.Actual = v 16963 return s, err 16964 }, sms...) 16965 if err != nil { 16966 return nil, err 16967 } 16968 return s, err 16969} 16970 16971// FieldScalarS50BE adds a field and reads 50 bit signed integer in big-endian 16972func (d *D) FieldScalarS50BE(name string, sms ...scalar.Mapper) *scalar.S { 16973 s, err := d.TryFieldScalarS50BE(name, sms...) 16974 if err != nil { 16975 panic(IOError{Err: err, Name: name, Op: "S50BE", Pos: d.Pos()}) 16976 } 16977 return s 16978} 16979 16980// TryFieldS50BE tries to add a field and read 50 bit signed integer in big-endian 16981func (d *D) TryFieldS50BE(name string, sms ...scalar.Mapper) (int64, error) { 16982 s, err := d.TryFieldScalarS50BE(name, sms...) 16983 return s.ActualS(), err 16984} 16985 16986// FieldS50BE adds a field and reads 50 bit signed integer in big-endian 16987func (d *D) FieldS50BE(name string, sms ...scalar.Mapper) int64 { 16988 return d.FieldScalarS50BE(name, sms...).ActualS() 16989} 16990 16991// Reader S51BE 16992 16993// TryS51BE tries to read 51 bit signed integer in big-endian 16994func (d *D) TryS51BE() (int64, error) { return d.trySE(51, BigEndian) } 16995 16996// S51BE reads 51 bit signed integer in big-endian 16997func (d *D) S51BE() int64 { 16998 v, err := d.trySE(51, BigEndian) 16999 if err != nil { 17000 panic(IOError{Err: err, Op: "S51BE", Pos: d.Pos()}) 17001 } 17002 return v 17003} 17004 17005// TryFieldScalarS51BE tries to add a field and read 51 bit signed integer in big-endian 17006func (d *D) TryFieldScalarS51BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 17007 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 17008 v, err := d.trySE(51, BigEndian) 17009 s.Actual = v 17010 return s, err 17011 }, sms...) 17012 if err != nil { 17013 return nil, err 17014 } 17015 return s, err 17016} 17017 17018// FieldScalarS51BE adds a field and reads 51 bit signed integer in big-endian 17019func (d *D) FieldScalarS51BE(name string, sms ...scalar.Mapper) *scalar.S { 17020 s, err := d.TryFieldScalarS51BE(name, sms...) 17021 if err != nil { 17022 panic(IOError{Err: err, Name: name, Op: "S51BE", Pos: d.Pos()}) 17023 } 17024 return s 17025} 17026 17027// TryFieldS51BE tries to add a field and read 51 bit signed integer in big-endian 17028func (d *D) TryFieldS51BE(name string, sms ...scalar.Mapper) (int64, error) { 17029 s, err := d.TryFieldScalarS51BE(name, sms...) 17030 return s.ActualS(), err 17031} 17032 17033// FieldS51BE adds a field and reads 51 bit signed integer in big-endian 17034func (d *D) FieldS51BE(name string, sms ...scalar.Mapper) int64 { 17035 return d.FieldScalarS51BE(name, sms...).ActualS() 17036} 17037 17038// Reader S52BE 17039 17040// TryS52BE tries to read 52 bit signed integer in big-endian 17041func (d *D) TryS52BE() (int64, error) { return d.trySE(52, BigEndian) } 17042 17043// S52BE reads 52 bit signed integer in big-endian 17044func (d *D) S52BE() int64 { 17045 v, err := d.trySE(52, BigEndian) 17046 if err != nil { 17047 panic(IOError{Err: err, Op: "S52BE", Pos: d.Pos()}) 17048 } 17049 return v 17050} 17051 17052// TryFieldScalarS52BE tries to add a field and read 52 bit signed integer in big-endian 17053func (d *D) TryFieldScalarS52BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 17054 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 17055 v, err := d.trySE(52, BigEndian) 17056 s.Actual = v 17057 return s, err 17058 }, sms...) 17059 if err != nil { 17060 return nil, err 17061 } 17062 return s, err 17063} 17064 17065// FieldScalarS52BE adds a field and reads 52 bit signed integer in big-endian 17066func (d *D) FieldScalarS52BE(name string, sms ...scalar.Mapper) *scalar.S { 17067 s, err := d.TryFieldScalarS52BE(name, sms...) 17068 if err != nil { 17069 panic(IOError{Err: err, Name: name, Op: "S52BE", Pos: d.Pos()}) 17070 } 17071 return s 17072} 17073 17074// TryFieldS52BE tries to add a field and read 52 bit signed integer in big-endian 17075func (d *D) TryFieldS52BE(name string, sms ...scalar.Mapper) (int64, error) { 17076 s, err := d.TryFieldScalarS52BE(name, sms...) 17077 return s.ActualS(), err 17078} 17079 17080// FieldS52BE adds a field and reads 52 bit signed integer in big-endian 17081func (d *D) FieldS52BE(name string, sms ...scalar.Mapper) int64 { 17082 return d.FieldScalarS52BE(name, sms...).ActualS() 17083} 17084 17085// Reader S53BE 17086 17087// TryS53BE tries to read 53 bit signed integer in big-endian 17088func (d *D) TryS53BE() (int64, error) { return d.trySE(53, BigEndian) } 17089 17090// S53BE reads 53 bit signed integer in big-endian 17091func (d *D) S53BE() int64 { 17092 v, err := d.trySE(53, BigEndian) 17093 if err != nil { 17094 panic(IOError{Err: err, Op: "S53BE", Pos: d.Pos()}) 17095 } 17096 return v 17097} 17098 17099// TryFieldScalarS53BE tries to add a field and read 53 bit signed integer in big-endian 17100func (d *D) TryFieldScalarS53BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 17101 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 17102 v, err := d.trySE(53, BigEndian) 17103 s.Actual = v 17104 return s, err 17105 }, sms...) 17106 if err != nil { 17107 return nil, err 17108 } 17109 return s, err 17110} 17111 17112// FieldScalarS53BE adds a field and reads 53 bit signed integer in big-endian 17113func (d *D) FieldScalarS53BE(name string, sms ...scalar.Mapper) *scalar.S { 17114 s, err := d.TryFieldScalarS53BE(name, sms...) 17115 if err != nil { 17116 panic(IOError{Err: err, Name: name, Op: "S53BE", Pos: d.Pos()}) 17117 } 17118 return s 17119} 17120 17121// TryFieldS53BE tries to add a field and read 53 bit signed integer in big-endian 17122func (d *D) TryFieldS53BE(name string, sms ...scalar.Mapper) (int64, error) { 17123 s, err := d.TryFieldScalarS53BE(name, sms...) 17124 return s.ActualS(), err 17125} 17126 17127// FieldS53BE adds a field and reads 53 bit signed integer in big-endian 17128func (d *D) FieldS53BE(name string, sms ...scalar.Mapper) int64 { 17129 return d.FieldScalarS53BE(name, sms...).ActualS() 17130} 17131 17132// Reader S54BE 17133 17134// TryS54BE tries to read 54 bit signed integer in big-endian 17135func (d *D) TryS54BE() (int64, error) { return d.trySE(54, BigEndian) } 17136 17137// S54BE reads 54 bit signed integer in big-endian 17138func (d *D) S54BE() int64 { 17139 v, err := d.trySE(54, BigEndian) 17140 if err != nil { 17141 panic(IOError{Err: err, Op: "S54BE", Pos: d.Pos()}) 17142 } 17143 return v 17144} 17145 17146// TryFieldScalarS54BE tries to add a field and read 54 bit signed integer in big-endian 17147func (d *D) TryFieldScalarS54BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 17148 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 17149 v, err := d.trySE(54, BigEndian) 17150 s.Actual = v 17151 return s, err 17152 }, sms...) 17153 if err != nil { 17154 return nil, err 17155 } 17156 return s, err 17157} 17158 17159// FieldScalarS54BE adds a field and reads 54 bit signed integer in big-endian 17160func (d *D) FieldScalarS54BE(name string, sms ...scalar.Mapper) *scalar.S { 17161 s, err := d.TryFieldScalarS54BE(name, sms...) 17162 if err != nil { 17163 panic(IOError{Err: err, Name: name, Op: "S54BE", Pos: d.Pos()}) 17164 } 17165 return s 17166} 17167 17168// TryFieldS54BE tries to add a field and read 54 bit signed integer in big-endian 17169func (d *D) TryFieldS54BE(name string, sms ...scalar.Mapper) (int64, error) { 17170 s, err := d.TryFieldScalarS54BE(name, sms...) 17171 return s.ActualS(), err 17172} 17173 17174// FieldS54BE adds a field and reads 54 bit signed integer in big-endian 17175func (d *D) FieldS54BE(name string, sms ...scalar.Mapper) int64 { 17176 return d.FieldScalarS54BE(name, sms...).ActualS() 17177} 17178 17179// Reader S55BE 17180 17181// TryS55BE tries to read 55 bit signed integer in big-endian 17182func (d *D) TryS55BE() (int64, error) { return d.trySE(55, BigEndian) } 17183 17184// S55BE reads 55 bit signed integer in big-endian 17185func (d *D) S55BE() int64 { 17186 v, err := d.trySE(55, BigEndian) 17187 if err != nil { 17188 panic(IOError{Err: err, Op: "S55BE", Pos: d.Pos()}) 17189 } 17190 return v 17191} 17192 17193// TryFieldScalarS55BE tries to add a field and read 55 bit signed integer in big-endian 17194func (d *D) TryFieldScalarS55BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 17195 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 17196 v, err := d.trySE(55, BigEndian) 17197 s.Actual = v 17198 return s, err 17199 }, sms...) 17200 if err != nil { 17201 return nil, err 17202 } 17203 return s, err 17204} 17205 17206// FieldScalarS55BE adds a field and reads 55 bit signed integer in big-endian 17207func (d *D) FieldScalarS55BE(name string, sms ...scalar.Mapper) *scalar.S { 17208 s, err := d.TryFieldScalarS55BE(name, sms...) 17209 if err != nil { 17210 panic(IOError{Err: err, Name: name, Op: "S55BE", Pos: d.Pos()}) 17211 } 17212 return s 17213} 17214 17215// TryFieldS55BE tries to add a field and read 55 bit signed integer in big-endian 17216func (d *D) TryFieldS55BE(name string, sms ...scalar.Mapper) (int64, error) { 17217 s, err := d.TryFieldScalarS55BE(name, sms...) 17218 return s.ActualS(), err 17219} 17220 17221// FieldS55BE adds a field and reads 55 bit signed integer in big-endian 17222func (d *D) FieldS55BE(name string, sms ...scalar.Mapper) int64 { 17223 return d.FieldScalarS55BE(name, sms...).ActualS() 17224} 17225 17226// Reader S56BE 17227 17228// TryS56BE tries to read 56 bit signed integer in big-endian 17229func (d *D) TryS56BE() (int64, error) { return d.trySE(56, BigEndian) } 17230 17231// S56BE reads 56 bit signed integer in big-endian 17232func (d *D) S56BE() int64 { 17233 v, err := d.trySE(56, BigEndian) 17234 if err != nil { 17235 panic(IOError{Err: err, Op: "S56BE", Pos: d.Pos()}) 17236 } 17237 return v 17238} 17239 17240// TryFieldScalarS56BE tries to add a field and read 56 bit signed integer in big-endian 17241func (d *D) TryFieldScalarS56BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 17242 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 17243 v, err := d.trySE(56, BigEndian) 17244 s.Actual = v 17245 return s, err 17246 }, sms...) 17247 if err != nil { 17248 return nil, err 17249 } 17250 return s, err 17251} 17252 17253// FieldScalarS56BE adds a field and reads 56 bit signed integer in big-endian 17254func (d *D) FieldScalarS56BE(name string, sms ...scalar.Mapper) *scalar.S { 17255 s, err := d.TryFieldScalarS56BE(name, sms...) 17256 if err != nil { 17257 panic(IOError{Err: err, Name: name, Op: "S56BE", Pos: d.Pos()}) 17258 } 17259 return s 17260} 17261 17262// TryFieldS56BE tries to add a field and read 56 bit signed integer in big-endian 17263func (d *D) TryFieldS56BE(name string, sms ...scalar.Mapper) (int64, error) { 17264 s, err := d.TryFieldScalarS56BE(name, sms...) 17265 return s.ActualS(), err 17266} 17267 17268// FieldS56BE adds a field and reads 56 bit signed integer in big-endian 17269func (d *D) FieldS56BE(name string, sms ...scalar.Mapper) int64 { 17270 return d.FieldScalarS56BE(name, sms...).ActualS() 17271} 17272 17273// Reader S57BE 17274 17275// TryS57BE tries to read 57 bit signed integer in big-endian 17276func (d *D) TryS57BE() (int64, error) { return d.trySE(57, BigEndian) } 17277 17278// S57BE reads 57 bit signed integer in big-endian 17279func (d *D) S57BE() int64 { 17280 v, err := d.trySE(57, BigEndian) 17281 if err != nil { 17282 panic(IOError{Err: err, Op: "S57BE", Pos: d.Pos()}) 17283 } 17284 return v 17285} 17286 17287// TryFieldScalarS57BE tries to add a field and read 57 bit signed integer in big-endian 17288func (d *D) TryFieldScalarS57BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 17289 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 17290 v, err := d.trySE(57, BigEndian) 17291 s.Actual = v 17292 return s, err 17293 }, sms...) 17294 if err != nil { 17295 return nil, err 17296 } 17297 return s, err 17298} 17299 17300// FieldScalarS57BE adds a field and reads 57 bit signed integer in big-endian 17301func (d *D) FieldScalarS57BE(name string, sms ...scalar.Mapper) *scalar.S { 17302 s, err := d.TryFieldScalarS57BE(name, sms...) 17303 if err != nil { 17304 panic(IOError{Err: err, Name: name, Op: "S57BE", Pos: d.Pos()}) 17305 } 17306 return s 17307} 17308 17309// TryFieldS57BE tries to add a field and read 57 bit signed integer in big-endian 17310func (d *D) TryFieldS57BE(name string, sms ...scalar.Mapper) (int64, error) { 17311 s, err := d.TryFieldScalarS57BE(name, sms...) 17312 return s.ActualS(), err 17313} 17314 17315// FieldS57BE adds a field and reads 57 bit signed integer in big-endian 17316func (d *D) FieldS57BE(name string, sms ...scalar.Mapper) int64 { 17317 return d.FieldScalarS57BE(name, sms...).ActualS() 17318} 17319 17320// Reader S58BE 17321 17322// TryS58BE tries to read 58 bit signed integer in big-endian 17323func (d *D) TryS58BE() (int64, error) { return d.trySE(58, BigEndian) } 17324 17325// S58BE reads 58 bit signed integer in big-endian 17326func (d *D) S58BE() int64 { 17327 v, err := d.trySE(58, BigEndian) 17328 if err != nil { 17329 panic(IOError{Err: err, Op: "S58BE", Pos: d.Pos()}) 17330 } 17331 return v 17332} 17333 17334// TryFieldScalarS58BE tries to add a field and read 58 bit signed integer in big-endian 17335func (d *D) TryFieldScalarS58BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 17336 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 17337 v, err := d.trySE(58, BigEndian) 17338 s.Actual = v 17339 return s, err 17340 }, sms...) 17341 if err != nil { 17342 return nil, err 17343 } 17344 return s, err 17345} 17346 17347// FieldScalarS58BE adds a field and reads 58 bit signed integer in big-endian 17348func (d *D) FieldScalarS58BE(name string, sms ...scalar.Mapper) *scalar.S { 17349 s, err := d.TryFieldScalarS58BE(name, sms...) 17350 if err != nil { 17351 panic(IOError{Err: err, Name: name, Op: "S58BE", Pos: d.Pos()}) 17352 } 17353 return s 17354} 17355 17356// TryFieldS58BE tries to add a field and read 58 bit signed integer in big-endian 17357func (d *D) TryFieldS58BE(name string, sms ...scalar.Mapper) (int64, error) { 17358 s, err := d.TryFieldScalarS58BE(name, sms...) 17359 return s.ActualS(), err 17360} 17361 17362// FieldS58BE adds a field and reads 58 bit signed integer in big-endian 17363func (d *D) FieldS58BE(name string, sms ...scalar.Mapper) int64 { 17364 return d.FieldScalarS58BE(name, sms...).ActualS() 17365} 17366 17367// Reader S59BE 17368 17369// TryS59BE tries to read 59 bit signed integer in big-endian 17370func (d *D) TryS59BE() (int64, error) { return d.trySE(59, BigEndian) } 17371 17372// S59BE reads 59 bit signed integer in big-endian 17373func (d *D) S59BE() int64 { 17374 v, err := d.trySE(59, BigEndian) 17375 if err != nil { 17376 panic(IOError{Err: err, Op: "S59BE", Pos: d.Pos()}) 17377 } 17378 return v 17379} 17380 17381// TryFieldScalarS59BE tries to add a field and read 59 bit signed integer in big-endian 17382func (d *D) TryFieldScalarS59BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 17383 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 17384 v, err := d.trySE(59, BigEndian) 17385 s.Actual = v 17386 return s, err 17387 }, sms...) 17388 if err != nil { 17389 return nil, err 17390 } 17391 return s, err 17392} 17393 17394// FieldScalarS59BE adds a field and reads 59 bit signed integer in big-endian 17395func (d *D) FieldScalarS59BE(name string, sms ...scalar.Mapper) *scalar.S { 17396 s, err := d.TryFieldScalarS59BE(name, sms...) 17397 if err != nil { 17398 panic(IOError{Err: err, Name: name, Op: "S59BE", Pos: d.Pos()}) 17399 } 17400 return s 17401} 17402 17403// TryFieldS59BE tries to add a field and read 59 bit signed integer in big-endian 17404func (d *D) TryFieldS59BE(name string, sms ...scalar.Mapper) (int64, error) { 17405 s, err := d.TryFieldScalarS59BE(name, sms...) 17406 return s.ActualS(), err 17407} 17408 17409// FieldS59BE adds a field and reads 59 bit signed integer in big-endian 17410func (d *D) FieldS59BE(name string, sms ...scalar.Mapper) int64 { 17411 return d.FieldScalarS59BE(name, sms...).ActualS() 17412} 17413 17414// Reader S60BE 17415 17416// TryS60BE tries to read 60 bit signed integer in big-endian 17417func (d *D) TryS60BE() (int64, error) { return d.trySE(60, BigEndian) } 17418 17419// S60BE reads 60 bit signed integer in big-endian 17420func (d *D) S60BE() int64 { 17421 v, err := d.trySE(60, BigEndian) 17422 if err != nil { 17423 panic(IOError{Err: err, Op: "S60BE", Pos: d.Pos()}) 17424 } 17425 return v 17426} 17427 17428// TryFieldScalarS60BE tries to add a field and read 60 bit signed integer in big-endian 17429func (d *D) TryFieldScalarS60BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 17430 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 17431 v, err := d.trySE(60, BigEndian) 17432 s.Actual = v 17433 return s, err 17434 }, sms...) 17435 if err != nil { 17436 return nil, err 17437 } 17438 return s, err 17439} 17440 17441// FieldScalarS60BE adds a field and reads 60 bit signed integer in big-endian 17442func (d *D) FieldScalarS60BE(name string, sms ...scalar.Mapper) *scalar.S { 17443 s, err := d.TryFieldScalarS60BE(name, sms...) 17444 if err != nil { 17445 panic(IOError{Err: err, Name: name, Op: "S60BE", Pos: d.Pos()}) 17446 } 17447 return s 17448} 17449 17450// TryFieldS60BE tries to add a field and read 60 bit signed integer in big-endian 17451func (d *D) TryFieldS60BE(name string, sms ...scalar.Mapper) (int64, error) { 17452 s, err := d.TryFieldScalarS60BE(name, sms...) 17453 return s.ActualS(), err 17454} 17455 17456// FieldS60BE adds a field and reads 60 bit signed integer in big-endian 17457func (d *D) FieldS60BE(name string, sms ...scalar.Mapper) int64 { 17458 return d.FieldScalarS60BE(name, sms...).ActualS() 17459} 17460 17461// Reader S61BE 17462 17463// TryS61BE tries to read 61 bit signed integer in big-endian 17464func (d *D) TryS61BE() (int64, error) { return d.trySE(61, BigEndian) } 17465 17466// S61BE reads 61 bit signed integer in big-endian 17467func (d *D) S61BE() int64 { 17468 v, err := d.trySE(61, BigEndian) 17469 if err != nil { 17470 panic(IOError{Err: err, Op: "S61BE", Pos: d.Pos()}) 17471 } 17472 return v 17473} 17474 17475// TryFieldScalarS61BE tries to add a field and read 61 bit signed integer in big-endian 17476func (d *D) TryFieldScalarS61BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 17477 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 17478 v, err := d.trySE(61, BigEndian) 17479 s.Actual = v 17480 return s, err 17481 }, sms...) 17482 if err != nil { 17483 return nil, err 17484 } 17485 return s, err 17486} 17487 17488// FieldScalarS61BE adds a field and reads 61 bit signed integer in big-endian 17489func (d *D) FieldScalarS61BE(name string, sms ...scalar.Mapper) *scalar.S { 17490 s, err := d.TryFieldScalarS61BE(name, sms...) 17491 if err != nil { 17492 panic(IOError{Err: err, Name: name, Op: "S61BE", Pos: d.Pos()}) 17493 } 17494 return s 17495} 17496 17497// TryFieldS61BE tries to add a field and read 61 bit signed integer in big-endian 17498func (d *D) TryFieldS61BE(name string, sms ...scalar.Mapper) (int64, error) { 17499 s, err := d.TryFieldScalarS61BE(name, sms...) 17500 return s.ActualS(), err 17501} 17502 17503// FieldS61BE adds a field and reads 61 bit signed integer in big-endian 17504func (d *D) FieldS61BE(name string, sms ...scalar.Mapper) int64 { 17505 return d.FieldScalarS61BE(name, sms...).ActualS() 17506} 17507 17508// Reader S62BE 17509 17510// TryS62BE tries to read 62 bit signed integer in big-endian 17511func (d *D) TryS62BE() (int64, error) { return d.trySE(62, BigEndian) } 17512 17513// S62BE reads 62 bit signed integer in big-endian 17514func (d *D) S62BE() int64 { 17515 v, err := d.trySE(62, BigEndian) 17516 if err != nil { 17517 panic(IOError{Err: err, Op: "S62BE", Pos: d.Pos()}) 17518 } 17519 return v 17520} 17521 17522// TryFieldScalarS62BE tries to add a field and read 62 bit signed integer in big-endian 17523func (d *D) TryFieldScalarS62BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 17524 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 17525 v, err := d.trySE(62, BigEndian) 17526 s.Actual = v 17527 return s, err 17528 }, sms...) 17529 if err != nil { 17530 return nil, err 17531 } 17532 return s, err 17533} 17534 17535// FieldScalarS62BE adds a field and reads 62 bit signed integer in big-endian 17536func (d *D) FieldScalarS62BE(name string, sms ...scalar.Mapper) *scalar.S { 17537 s, err := d.TryFieldScalarS62BE(name, sms...) 17538 if err != nil { 17539 panic(IOError{Err: err, Name: name, Op: "S62BE", Pos: d.Pos()}) 17540 } 17541 return s 17542} 17543 17544// TryFieldS62BE tries to add a field and read 62 bit signed integer in big-endian 17545func (d *D) TryFieldS62BE(name string, sms ...scalar.Mapper) (int64, error) { 17546 s, err := d.TryFieldScalarS62BE(name, sms...) 17547 return s.ActualS(), err 17548} 17549 17550// FieldS62BE adds a field and reads 62 bit signed integer in big-endian 17551func (d *D) FieldS62BE(name string, sms ...scalar.Mapper) int64 { 17552 return d.FieldScalarS62BE(name, sms...).ActualS() 17553} 17554 17555// Reader S63BE 17556 17557// TryS63BE tries to read 63 bit signed integer in big-endian 17558func (d *D) TryS63BE() (int64, error) { return d.trySE(63, BigEndian) } 17559 17560// S63BE reads 63 bit signed integer in big-endian 17561func (d *D) S63BE() int64 { 17562 v, err := d.trySE(63, BigEndian) 17563 if err != nil { 17564 panic(IOError{Err: err, Op: "S63BE", Pos: d.Pos()}) 17565 } 17566 return v 17567} 17568 17569// TryFieldScalarS63BE tries to add a field and read 63 bit signed integer in big-endian 17570func (d *D) TryFieldScalarS63BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 17571 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 17572 v, err := d.trySE(63, BigEndian) 17573 s.Actual = v 17574 return s, err 17575 }, sms...) 17576 if err != nil { 17577 return nil, err 17578 } 17579 return s, err 17580} 17581 17582// FieldScalarS63BE adds a field and reads 63 bit signed integer in big-endian 17583func (d *D) FieldScalarS63BE(name string, sms ...scalar.Mapper) *scalar.S { 17584 s, err := d.TryFieldScalarS63BE(name, sms...) 17585 if err != nil { 17586 panic(IOError{Err: err, Name: name, Op: "S63BE", Pos: d.Pos()}) 17587 } 17588 return s 17589} 17590 17591// TryFieldS63BE tries to add a field and read 63 bit signed integer in big-endian 17592func (d *D) TryFieldS63BE(name string, sms ...scalar.Mapper) (int64, error) { 17593 s, err := d.TryFieldScalarS63BE(name, sms...) 17594 return s.ActualS(), err 17595} 17596 17597// FieldS63BE adds a field and reads 63 bit signed integer in big-endian 17598func (d *D) FieldS63BE(name string, sms ...scalar.Mapper) int64 { 17599 return d.FieldScalarS63BE(name, sms...).ActualS() 17600} 17601 17602// Reader S64BE 17603 17604// TryS64BE tries to read 64 bit signed integer in big-endian 17605func (d *D) TryS64BE() (int64, error) { return d.trySE(64, BigEndian) } 17606 17607// S64BE reads 64 bit signed integer in big-endian 17608func (d *D) S64BE() int64 { 17609 v, err := d.trySE(64, BigEndian) 17610 if err != nil { 17611 panic(IOError{Err: err, Op: "S64BE", Pos: d.Pos()}) 17612 } 17613 return v 17614} 17615 17616// TryFieldScalarS64BE tries to add a field and read 64 bit signed integer in big-endian 17617func (d *D) TryFieldScalarS64BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 17618 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 17619 v, err := d.trySE(64, BigEndian) 17620 s.Actual = v 17621 return s, err 17622 }, sms...) 17623 if err != nil { 17624 return nil, err 17625 } 17626 return s, err 17627} 17628 17629// FieldScalarS64BE adds a field and reads 64 bit signed integer in big-endian 17630func (d *D) FieldScalarS64BE(name string, sms ...scalar.Mapper) *scalar.S { 17631 s, err := d.TryFieldScalarS64BE(name, sms...) 17632 if err != nil { 17633 panic(IOError{Err: err, Name: name, Op: "S64BE", Pos: d.Pos()}) 17634 } 17635 return s 17636} 17637 17638// TryFieldS64BE tries to add a field and read 64 bit signed integer in big-endian 17639func (d *D) TryFieldS64BE(name string, sms ...scalar.Mapper) (int64, error) { 17640 s, err := d.TryFieldScalarS64BE(name, sms...) 17641 return s.ActualS(), err 17642} 17643 17644// FieldS64BE adds a field and reads 64 bit signed integer in big-endian 17645func (d *D) FieldS64BE(name string, sms ...scalar.Mapper) int64 { 17646 return d.FieldScalarS64BE(name, sms...).ActualS() 17647} 17648 17649// Reader F 17650 17651// TryF tries to read nBit IEEE 754 float in current endian 17652func (d *D) TryF(nBits int) (float64, error) { return d.tryFE(nBits, d.Endian) } 17653 17654// F reads nBit IEEE 754 float in current endian 17655func (d *D) F(nBits int) float64 { 17656 v, err := d.tryFE(nBits, d.Endian) 17657 if err != nil { 17658 panic(IOError{Err: err, Op: "F", Pos: d.Pos()}) 17659 } 17660 return v 17661} 17662 17663// TryFieldScalarF tries to add a field and read nBit IEEE 754 float in current endian 17664func (d *D) TryFieldScalarF(name string, nBits int, sms ...scalar.Mapper) (*scalar.S, error) { 17665 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 17666 v, err := d.tryFE(nBits, d.Endian) 17667 s.Actual = v 17668 return s, err 17669 }, sms...) 17670 if err != nil { 17671 return nil, err 17672 } 17673 return s, err 17674} 17675 17676// FieldScalarF adds a field and reads nBit IEEE 754 float in current endian 17677func (d *D) FieldScalarF(name string, nBits int, sms ...scalar.Mapper) *scalar.S { 17678 s, err := d.TryFieldScalarF(name, nBits, sms...) 17679 if err != nil { 17680 panic(IOError{Err: err, Name: name, Op: "F", Pos: d.Pos()}) 17681 } 17682 return s 17683} 17684 17685// TryFieldF tries to add a field and read nBit IEEE 754 float in current endian 17686func (d *D) TryFieldF(name string, nBits int, sms ...scalar.Mapper) (float64, error) { 17687 s, err := d.TryFieldScalarF(name, nBits, sms...) 17688 return s.ActualF(), err 17689} 17690 17691// FieldF adds a field and reads nBit IEEE 754 float in current endian 17692func (d *D) FieldF(name string, nBits int, sms ...scalar.Mapper) float64 { 17693 return d.FieldScalarF(name, nBits, sms...).ActualF() 17694} 17695 17696// Reader FE 17697 17698// TryFE tries to read nBit IEEE 754 float in specified endian 17699func (d *D) TryFE(nBits int, endian Endian) (float64, error) { return d.tryFE(nBits, endian) } 17700 17701// FE reads nBit IEEE 754 float in specified endian 17702func (d *D) FE(nBits int, endian Endian) float64 { 17703 v, err := d.tryFE(nBits, endian) 17704 if err != nil { 17705 panic(IOError{Err: err, Op: "FE", Pos: d.Pos()}) 17706 } 17707 return v 17708} 17709 17710// TryFieldScalarFE tries to add a field and read nBit IEEE 754 float in specified endian 17711func (d *D) TryFieldScalarFE(name string, nBits int, endian Endian, sms ...scalar.Mapper) (*scalar.S, error) { 17712 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 17713 v, err := d.tryFE(nBits, endian) 17714 s.Actual = v 17715 return s, err 17716 }, sms...) 17717 if err != nil { 17718 return nil, err 17719 } 17720 return s, err 17721} 17722 17723// FieldScalarFE adds a field and reads nBit IEEE 754 float in specified endian 17724func (d *D) FieldScalarFE(name string, nBits int, endian Endian, sms ...scalar.Mapper) *scalar.S { 17725 s, err := d.TryFieldScalarFE(name, nBits, endian, sms...) 17726 if err != nil { 17727 panic(IOError{Err: err, Name: name, Op: "FE", Pos: d.Pos()}) 17728 } 17729 return s 17730} 17731 17732// TryFieldFE tries to add a field and read nBit IEEE 754 float in specified endian 17733func (d *D) TryFieldFE(name string, nBits int, endian Endian, sms ...scalar.Mapper) (float64, error) { 17734 s, err := d.TryFieldScalarFE(name, nBits, endian, sms...) 17735 return s.ActualF(), err 17736} 17737 17738// FieldFE adds a field and reads nBit IEEE 754 float in specified endian 17739func (d *D) FieldFE(name string, nBits int, endian Endian, sms ...scalar.Mapper) float64 { 17740 return d.FieldScalarFE(name, nBits, endian, sms...).ActualF() 17741} 17742 17743// Reader F16 17744 17745// TryF16 tries to read 16 bit IEEE 754 float in current endian 17746func (d *D) TryF16() (float64, error) { return d.tryFE(16, d.Endian) } 17747 17748// F16 reads 16 bit IEEE 754 float in current endian 17749func (d *D) F16() float64 { 17750 v, err := d.tryFE(16, d.Endian) 17751 if err != nil { 17752 panic(IOError{Err: err, Op: "F16", Pos: d.Pos()}) 17753 } 17754 return v 17755} 17756 17757// TryFieldScalarF16 tries to add a field and read 16 bit IEEE 754 float in current endian 17758func (d *D) TryFieldScalarF16(name string, sms ...scalar.Mapper) (*scalar.S, error) { 17759 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 17760 v, err := d.tryFE(16, d.Endian) 17761 s.Actual = v 17762 return s, err 17763 }, sms...) 17764 if err != nil { 17765 return nil, err 17766 } 17767 return s, err 17768} 17769 17770// FieldScalarF16 adds a field and reads 16 bit IEEE 754 float in current endian 17771func (d *D) FieldScalarF16(name string, sms ...scalar.Mapper) *scalar.S { 17772 s, err := d.TryFieldScalarF16(name, sms...) 17773 if err != nil { 17774 panic(IOError{Err: err, Name: name, Op: "F16", Pos: d.Pos()}) 17775 } 17776 return s 17777} 17778 17779// TryFieldF16 tries to add a field and read 16 bit IEEE 754 float in current endian 17780func (d *D) TryFieldF16(name string, sms ...scalar.Mapper) (float64, error) { 17781 s, err := d.TryFieldScalarF16(name, sms...) 17782 return s.ActualF(), err 17783} 17784 17785// FieldF16 adds a field and reads 16 bit IEEE 754 float in current endian 17786func (d *D) FieldF16(name string, sms ...scalar.Mapper) float64 { 17787 return d.FieldScalarF16(name, sms...).ActualF() 17788} 17789 17790// Reader F32 17791 17792// TryF32 tries to read 32 bit IEEE 754 float in current endian 17793func (d *D) TryF32() (float64, error) { return d.tryFE(32, d.Endian) } 17794 17795// F32 reads 32 bit IEEE 754 float in current endian 17796func (d *D) F32() float64 { 17797 v, err := d.tryFE(32, d.Endian) 17798 if err != nil { 17799 panic(IOError{Err: err, Op: "F32", Pos: d.Pos()}) 17800 } 17801 return v 17802} 17803 17804// TryFieldScalarF32 tries to add a field and read 32 bit IEEE 754 float in current endian 17805func (d *D) TryFieldScalarF32(name string, sms ...scalar.Mapper) (*scalar.S, error) { 17806 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 17807 v, err := d.tryFE(32, d.Endian) 17808 s.Actual = v 17809 return s, err 17810 }, sms...) 17811 if err != nil { 17812 return nil, err 17813 } 17814 return s, err 17815} 17816 17817// FieldScalarF32 adds a field and reads 32 bit IEEE 754 float in current endian 17818func (d *D) FieldScalarF32(name string, sms ...scalar.Mapper) *scalar.S { 17819 s, err := d.TryFieldScalarF32(name, sms...) 17820 if err != nil { 17821 panic(IOError{Err: err, Name: name, Op: "F32", Pos: d.Pos()}) 17822 } 17823 return s 17824} 17825 17826// TryFieldF32 tries to add a field and read 32 bit IEEE 754 float in current endian 17827func (d *D) TryFieldF32(name string, sms ...scalar.Mapper) (float64, error) { 17828 s, err := d.TryFieldScalarF32(name, sms...) 17829 return s.ActualF(), err 17830} 17831 17832// FieldF32 adds a field and reads 32 bit IEEE 754 float in current endian 17833func (d *D) FieldF32(name string, sms ...scalar.Mapper) float64 { 17834 return d.FieldScalarF32(name, sms...).ActualF() 17835} 17836 17837// Reader F64 17838 17839// TryF64 tries to read 64 bit IEEE 754 float in current endian 17840func (d *D) TryF64() (float64, error) { return d.tryFE(64, d.Endian) } 17841 17842// F64 reads 64 bit IEEE 754 float in current endian 17843func (d *D) F64() float64 { 17844 v, err := d.tryFE(64, d.Endian) 17845 if err != nil { 17846 panic(IOError{Err: err, Op: "F64", Pos: d.Pos()}) 17847 } 17848 return v 17849} 17850 17851// TryFieldScalarF64 tries to add a field and read 64 bit IEEE 754 float in current endian 17852func (d *D) TryFieldScalarF64(name string, sms ...scalar.Mapper) (*scalar.S, error) { 17853 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 17854 v, err := d.tryFE(64, d.Endian) 17855 s.Actual = v 17856 return s, err 17857 }, sms...) 17858 if err != nil { 17859 return nil, err 17860 } 17861 return s, err 17862} 17863 17864// FieldScalarF64 adds a field and reads 64 bit IEEE 754 float in current endian 17865func (d *D) FieldScalarF64(name string, sms ...scalar.Mapper) *scalar.S { 17866 s, err := d.TryFieldScalarF64(name, sms...) 17867 if err != nil { 17868 panic(IOError{Err: err, Name: name, Op: "F64", Pos: d.Pos()}) 17869 } 17870 return s 17871} 17872 17873// TryFieldF64 tries to add a field and read 64 bit IEEE 754 float in current endian 17874func (d *D) TryFieldF64(name string, sms ...scalar.Mapper) (float64, error) { 17875 s, err := d.TryFieldScalarF64(name, sms...) 17876 return s.ActualF(), err 17877} 17878 17879// FieldF64 adds a field and reads 64 bit IEEE 754 float in current endian 17880func (d *D) FieldF64(name string, sms ...scalar.Mapper) float64 { 17881 return d.FieldScalarF64(name, sms...).ActualF() 17882} 17883 17884// Reader F16LE 17885 17886// TryF16LE tries to read 16 bit IEEE 754 float in little-endian 17887func (d *D) TryF16LE() (float64, error) { return d.tryFE(16, LittleEndian) } 17888 17889// F16LE reads 16 bit IEEE 754 float in little-endian 17890func (d *D) F16LE() float64 { 17891 v, err := d.tryFE(16, LittleEndian) 17892 if err != nil { 17893 panic(IOError{Err: err, Op: "F16LE", Pos: d.Pos()}) 17894 } 17895 return v 17896} 17897 17898// TryFieldScalarF16LE tries to add a field and read 16 bit IEEE 754 float in little-endian 17899func (d *D) TryFieldScalarF16LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 17900 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 17901 v, err := d.tryFE(16, LittleEndian) 17902 s.Actual = v 17903 return s, err 17904 }, sms...) 17905 if err != nil { 17906 return nil, err 17907 } 17908 return s, err 17909} 17910 17911// FieldScalarF16LE adds a field and reads 16 bit IEEE 754 float in little-endian 17912func (d *D) FieldScalarF16LE(name string, sms ...scalar.Mapper) *scalar.S { 17913 s, err := d.TryFieldScalarF16LE(name, sms...) 17914 if err != nil { 17915 panic(IOError{Err: err, Name: name, Op: "F16LE", Pos: d.Pos()}) 17916 } 17917 return s 17918} 17919 17920// TryFieldF16LE tries to add a field and read 16 bit IEEE 754 float in little-endian 17921func (d *D) TryFieldF16LE(name string, sms ...scalar.Mapper) (float64, error) { 17922 s, err := d.TryFieldScalarF16LE(name, sms...) 17923 return s.ActualF(), err 17924} 17925 17926// FieldF16LE adds a field and reads 16 bit IEEE 754 float in little-endian 17927func (d *D) FieldF16LE(name string, sms ...scalar.Mapper) float64 { 17928 return d.FieldScalarF16LE(name, sms...).ActualF() 17929} 17930 17931// Reader F32LE 17932 17933// TryF32LE tries to read 32 bit IEEE 754 float in little-endian 17934func (d *D) TryF32LE() (float64, error) { return d.tryFE(32, LittleEndian) } 17935 17936// F32LE reads 32 bit IEEE 754 float in little-endian 17937func (d *D) F32LE() float64 { 17938 v, err := d.tryFE(32, LittleEndian) 17939 if err != nil { 17940 panic(IOError{Err: err, Op: "F32LE", Pos: d.Pos()}) 17941 } 17942 return v 17943} 17944 17945// TryFieldScalarF32LE tries to add a field and read 32 bit IEEE 754 float in little-endian 17946func (d *D) TryFieldScalarF32LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 17947 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 17948 v, err := d.tryFE(32, LittleEndian) 17949 s.Actual = v 17950 return s, err 17951 }, sms...) 17952 if err != nil { 17953 return nil, err 17954 } 17955 return s, err 17956} 17957 17958// FieldScalarF32LE adds a field and reads 32 bit IEEE 754 float in little-endian 17959func (d *D) FieldScalarF32LE(name string, sms ...scalar.Mapper) *scalar.S { 17960 s, err := d.TryFieldScalarF32LE(name, sms...) 17961 if err != nil { 17962 panic(IOError{Err: err, Name: name, Op: "F32LE", Pos: d.Pos()}) 17963 } 17964 return s 17965} 17966 17967// TryFieldF32LE tries to add a field and read 32 bit IEEE 754 float in little-endian 17968func (d *D) TryFieldF32LE(name string, sms ...scalar.Mapper) (float64, error) { 17969 s, err := d.TryFieldScalarF32LE(name, sms...) 17970 return s.ActualF(), err 17971} 17972 17973// FieldF32LE adds a field and reads 32 bit IEEE 754 float in little-endian 17974func (d *D) FieldF32LE(name string, sms ...scalar.Mapper) float64 { 17975 return d.FieldScalarF32LE(name, sms...).ActualF() 17976} 17977 17978// Reader F64LE 17979 17980// TryF64LE tries to read 64 bit IEEE 754 float in little-endian 17981func (d *D) TryF64LE() (float64, error) { return d.tryFE(64, LittleEndian) } 17982 17983// F64LE reads 64 bit IEEE 754 float in little-endian 17984func (d *D) F64LE() float64 { 17985 v, err := d.tryFE(64, LittleEndian) 17986 if err != nil { 17987 panic(IOError{Err: err, Op: "F64LE", Pos: d.Pos()}) 17988 } 17989 return v 17990} 17991 17992// TryFieldScalarF64LE tries to add a field and read 64 bit IEEE 754 float in little-endian 17993func (d *D) TryFieldScalarF64LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 17994 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 17995 v, err := d.tryFE(64, LittleEndian) 17996 s.Actual = v 17997 return s, err 17998 }, sms...) 17999 if err != nil { 18000 return nil, err 18001 } 18002 return s, err 18003} 18004 18005// FieldScalarF64LE adds a field and reads 64 bit IEEE 754 float in little-endian 18006func (d *D) FieldScalarF64LE(name string, sms ...scalar.Mapper) *scalar.S { 18007 s, err := d.TryFieldScalarF64LE(name, sms...) 18008 if err != nil { 18009 panic(IOError{Err: err, Name: name, Op: "F64LE", Pos: d.Pos()}) 18010 } 18011 return s 18012} 18013 18014// TryFieldF64LE tries to add a field and read 64 bit IEEE 754 float in little-endian 18015func (d *D) TryFieldF64LE(name string, sms ...scalar.Mapper) (float64, error) { 18016 s, err := d.TryFieldScalarF64LE(name, sms...) 18017 return s.ActualF(), err 18018} 18019 18020// FieldF64LE adds a field and reads 64 bit IEEE 754 float in little-endian 18021func (d *D) FieldF64LE(name string, sms ...scalar.Mapper) float64 { 18022 return d.FieldScalarF64LE(name, sms...).ActualF() 18023} 18024 18025// Reader F16BE 18026 18027// TryF16BE tries to read 16 bit IEEE 754 float in big-endian 18028func (d *D) TryF16BE() (float64, error) { return d.tryFE(16, BigEndian) } 18029 18030// F16BE reads 16 bit IEEE 754 float in big-endian 18031func (d *D) F16BE() float64 { 18032 v, err := d.tryFE(16, BigEndian) 18033 if err != nil { 18034 panic(IOError{Err: err, Op: "F16BE", Pos: d.Pos()}) 18035 } 18036 return v 18037} 18038 18039// TryFieldScalarF16BE tries to add a field and read 16 bit IEEE 754 float in big-endian 18040func (d *D) TryFieldScalarF16BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 18041 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 18042 v, err := d.tryFE(16, BigEndian) 18043 s.Actual = v 18044 return s, err 18045 }, sms...) 18046 if err != nil { 18047 return nil, err 18048 } 18049 return s, err 18050} 18051 18052// FieldScalarF16BE adds a field and reads 16 bit IEEE 754 float in big-endian 18053func (d *D) FieldScalarF16BE(name string, sms ...scalar.Mapper) *scalar.S { 18054 s, err := d.TryFieldScalarF16BE(name, sms...) 18055 if err != nil { 18056 panic(IOError{Err: err, Name: name, Op: "F16BE", Pos: d.Pos()}) 18057 } 18058 return s 18059} 18060 18061// TryFieldF16BE tries to add a field and read 16 bit IEEE 754 float in big-endian 18062func (d *D) TryFieldF16BE(name string, sms ...scalar.Mapper) (float64, error) { 18063 s, err := d.TryFieldScalarF16BE(name, sms...) 18064 return s.ActualF(), err 18065} 18066 18067// FieldF16BE adds a field and reads 16 bit IEEE 754 float in big-endian 18068func (d *D) FieldF16BE(name string, sms ...scalar.Mapper) float64 { 18069 return d.FieldScalarF16BE(name, sms...).ActualF() 18070} 18071 18072// Reader F32BE 18073 18074// TryF32BE tries to read 32 bit IEEE 754 float in big-endian 18075func (d *D) TryF32BE() (float64, error) { return d.tryFE(32, BigEndian) } 18076 18077// F32BE reads 32 bit IEEE 754 float in big-endian 18078func (d *D) F32BE() float64 { 18079 v, err := d.tryFE(32, BigEndian) 18080 if err != nil { 18081 panic(IOError{Err: err, Op: "F32BE", Pos: d.Pos()}) 18082 } 18083 return v 18084} 18085 18086// TryFieldScalarF32BE tries to add a field and read 32 bit IEEE 754 float in big-endian 18087func (d *D) TryFieldScalarF32BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 18088 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 18089 v, err := d.tryFE(32, BigEndian) 18090 s.Actual = v 18091 return s, err 18092 }, sms...) 18093 if err != nil { 18094 return nil, err 18095 } 18096 return s, err 18097} 18098 18099// FieldScalarF32BE adds a field and reads 32 bit IEEE 754 float in big-endian 18100func (d *D) FieldScalarF32BE(name string, sms ...scalar.Mapper) *scalar.S { 18101 s, err := d.TryFieldScalarF32BE(name, sms...) 18102 if err != nil { 18103 panic(IOError{Err: err, Name: name, Op: "F32BE", Pos: d.Pos()}) 18104 } 18105 return s 18106} 18107 18108// TryFieldF32BE tries to add a field and read 32 bit IEEE 754 float in big-endian 18109func (d *D) TryFieldF32BE(name string, sms ...scalar.Mapper) (float64, error) { 18110 s, err := d.TryFieldScalarF32BE(name, sms...) 18111 return s.ActualF(), err 18112} 18113 18114// FieldF32BE adds a field and reads 32 bit IEEE 754 float in big-endian 18115func (d *D) FieldF32BE(name string, sms ...scalar.Mapper) float64 { 18116 return d.FieldScalarF32BE(name, sms...).ActualF() 18117} 18118 18119// Reader F64BE 18120 18121// TryF64BE tries to read 64 bit IEEE 754 float in big-endian 18122func (d *D) TryF64BE() (float64, error) { return d.tryFE(64, BigEndian) } 18123 18124// F64BE reads 64 bit IEEE 754 float in big-endian 18125func (d *D) F64BE() float64 { 18126 v, err := d.tryFE(64, BigEndian) 18127 if err != nil { 18128 panic(IOError{Err: err, Op: "F64BE", Pos: d.Pos()}) 18129 } 18130 return v 18131} 18132 18133// TryFieldScalarF64BE tries to add a field and read 64 bit IEEE 754 float in big-endian 18134func (d *D) TryFieldScalarF64BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 18135 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 18136 v, err := d.tryFE(64, BigEndian) 18137 s.Actual = v 18138 return s, err 18139 }, sms...) 18140 if err != nil { 18141 return nil, err 18142 } 18143 return s, err 18144} 18145 18146// FieldScalarF64BE adds a field and reads 64 bit IEEE 754 float in big-endian 18147func (d *D) FieldScalarF64BE(name string, sms ...scalar.Mapper) *scalar.S { 18148 s, err := d.TryFieldScalarF64BE(name, sms...) 18149 if err != nil { 18150 panic(IOError{Err: err, Name: name, Op: "F64BE", Pos: d.Pos()}) 18151 } 18152 return s 18153} 18154 18155// TryFieldF64BE tries to add a field and read 64 bit IEEE 754 float in big-endian 18156func (d *D) TryFieldF64BE(name string, sms ...scalar.Mapper) (float64, error) { 18157 s, err := d.TryFieldScalarF64BE(name, sms...) 18158 return s.ActualF(), err 18159} 18160 18161// FieldF64BE adds a field and reads 64 bit IEEE 754 float in big-endian 18162func (d *D) FieldF64BE(name string, sms ...scalar.Mapper) float64 { 18163 return d.FieldScalarF64BE(name, sms...).ActualF() 18164} 18165 18166// Reader FP 18167 18168// TryFP tries to read nBits fixed-point number in current endian 18169func (d *D) TryFP(nBits int, fBits int) (float64, error) { return d.tryFPE(nBits, fBits, d.Endian) } 18170 18171// FP reads nBits fixed-point number in current endian 18172func (d *D) FP(nBits int, fBits int) float64 { 18173 v, err := d.tryFPE(nBits, fBits, d.Endian) 18174 if err != nil { 18175 panic(IOError{Err: err, Op: "FP", Pos: d.Pos()}) 18176 } 18177 return v 18178} 18179 18180// TryFieldScalarFP tries to add a field and read nBits fixed-point number in current endian 18181func (d *D) TryFieldScalarFP(name string, nBits int, fBits int, sms ...scalar.Mapper) (*scalar.S, error) { 18182 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 18183 v, err := d.tryFPE(nBits, fBits, d.Endian) 18184 s.Actual = v 18185 return s, err 18186 }, sms...) 18187 if err != nil { 18188 return nil, err 18189 } 18190 return s, err 18191} 18192 18193// FieldScalarFP adds a field and reads nBits fixed-point number in current endian 18194func (d *D) FieldScalarFP(name string, nBits int, fBits int, sms ...scalar.Mapper) *scalar.S { 18195 s, err := d.TryFieldScalarFP(name, nBits, fBits, sms...) 18196 if err != nil { 18197 panic(IOError{Err: err, Name: name, Op: "FP", Pos: d.Pos()}) 18198 } 18199 return s 18200} 18201 18202// TryFieldFP tries to add a field and read nBits fixed-point number in current endian 18203func (d *D) TryFieldFP(name string, nBits int, fBits int, sms ...scalar.Mapper) (float64, error) { 18204 s, err := d.TryFieldScalarFP(name, nBits, fBits, sms...) 18205 return s.ActualF(), err 18206} 18207 18208// FieldFP adds a field and reads nBits fixed-point number in current endian 18209func (d *D) FieldFP(name string, nBits int, fBits int, sms ...scalar.Mapper) float64 { 18210 return d.FieldScalarFP(name, nBits, fBits, sms...).ActualF() 18211} 18212 18213// Reader FPE 18214 18215// TryFPE tries to read nBits fixed-point number in specified endian 18216func (d *D) TryFPE(nBits int, fBits int, endian Endian) (float64, error) { 18217 return d.tryFPE(nBits, fBits, endian) 18218} 18219 18220// FPE reads nBits fixed-point number in specified endian 18221func (d *D) FPE(nBits int, fBits int, endian Endian) float64 { 18222 v, err := d.tryFPE(nBits, fBits, endian) 18223 if err != nil { 18224 panic(IOError{Err: err, Op: "FPE", Pos: d.Pos()}) 18225 } 18226 return v 18227} 18228 18229// TryFieldScalarFPE tries to add a field and read nBits fixed-point number in specified endian 18230func (d *D) TryFieldScalarFPE(name string, nBits int, fBits int, endian Endian, sms ...scalar.Mapper) (*scalar.S, error) { 18231 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 18232 v, err := d.tryFPE(nBits, fBits, endian) 18233 s.Actual = v 18234 return s, err 18235 }, sms...) 18236 if err != nil { 18237 return nil, err 18238 } 18239 return s, err 18240} 18241 18242// FieldScalarFPE adds a field and reads nBits fixed-point number in specified endian 18243func (d *D) FieldScalarFPE(name string, nBits int, fBits int, endian Endian, sms ...scalar.Mapper) *scalar.S { 18244 s, err := d.TryFieldScalarFPE(name, nBits, fBits, endian, sms...) 18245 if err != nil { 18246 panic(IOError{Err: err, Name: name, Op: "FPE", Pos: d.Pos()}) 18247 } 18248 return s 18249} 18250 18251// TryFieldFPE tries to add a field and read nBits fixed-point number in specified endian 18252func (d *D) TryFieldFPE(name string, nBits int, fBits int, endian Endian, sms ...scalar.Mapper) (float64, error) { 18253 s, err := d.TryFieldScalarFPE(name, nBits, fBits, endian, sms...) 18254 return s.ActualF(), err 18255} 18256 18257// FieldFPE adds a field and reads nBits fixed-point number in specified endian 18258func (d *D) FieldFPE(name string, nBits int, fBits int, endian Endian, sms ...scalar.Mapper) float64 { 18259 return d.FieldScalarFPE(name, nBits, fBits, endian, sms...).ActualF() 18260} 18261 18262// Reader FP16 18263 18264// TryFP16 tries to read 16 bit fixed-point number in current endian 18265func (d *D) TryFP16() (float64, error) { return d.tryFPE(16, 8, d.Endian) } 18266 18267// FP16 reads 16 bit fixed-point number in current endian 18268func (d *D) FP16() float64 { 18269 v, err := d.tryFPE(16, 8, d.Endian) 18270 if err != nil { 18271 panic(IOError{Err: err, Op: "FP16", Pos: d.Pos()}) 18272 } 18273 return v 18274} 18275 18276// TryFieldScalarFP16 tries to add a field and read 16 bit fixed-point number in current endian 18277func (d *D) TryFieldScalarFP16(name string, sms ...scalar.Mapper) (*scalar.S, error) { 18278 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 18279 v, err := d.tryFPE(16, 8, d.Endian) 18280 s.Actual = v 18281 return s, err 18282 }, sms...) 18283 if err != nil { 18284 return nil, err 18285 } 18286 return s, err 18287} 18288 18289// FieldScalarFP16 adds a field and reads 16 bit fixed-point number in current endian 18290func (d *D) FieldScalarFP16(name string, sms ...scalar.Mapper) *scalar.S { 18291 s, err := d.TryFieldScalarFP16(name, sms...) 18292 if err != nil { 18293 panic(IOError{Err: err, Name: name, Op: "FP16", Pos: d.Pos()}) 18294 } 18295 return s 18296} 18297 18298// TryFieldFP16 tries to add a field and read 16 bit fixed-point number in current endian 18299func (d *D) TryFieldFP16(name string, sms ...scalar.Mapper) (float64, error) { 18300 s, err := d.TryFieldScalarFP16(name, sms...) 18301 return s.ActualF(), err 18302} 18303 18304// FieldFP16 adds a field and reads 16 bit fixed-point number in current endian 18305func (d *D) FieldFP16(name string, sms ...scalar.Mapper) float64 { 18306 return d.FieldScalarFP16(name, sms...).ActualF() 18307} 18308 18309// Reader FP32 18310 18311// TryFP32 tries to read 32 bit fixed-point number in current endian 18312func (d *D) TryFP32() (float64, error) { return d.tryFPE(32, 16, d.Endian) } 18313 18314// FP32 reads 32 bit fixed-point number in current endian 18315func (d *D) FP32() float64 { 18316 v, err := d.tryFPE(32, 16, d.Endian) 18317 if err != nil { 18318 panic(IOError{Err: err, Op: "FP32", Pos: d.Pos()}) 18319 } 18320 return v 18321} 18322 18323// TryFieldScalarFP32 tries to add a field and read 32 bit fixed-point number in current endian 18324func (d *D) TryFieldScalarFP32(name string, sms ...scalar.Mapper) (*scalar.S, error) { 18325 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 18326 v, err := d.tryFPE(32, 16, d.Endian) 18327 s.Actual = v 18328 return s, err 18329 }, sms...) 18330 if err != nil { 18331 return nil, err 18332 } 18333 return s, err 18334} 18335 18336// FieldScalarFP32 adds a field and reads 32 bit fixed-point number in current endian 18337func (d *D) FieldScalarFP32(name string, sms ...scalar.Mapper) *scalar.S { 18338 s, err := d.TryFieldScalarFP32(name, sms...) 18339 if err != nil { 18340 panic(IOError{Err: err, Name: name, Op: "FP32", Pos: d.Pos()}) 18341 } 18342 return s 18343} 18344 18345// TryFieldFP32 tries to add a field and read 32 bit fixed-point number in current endian 18346func (d *D) TryFieldFP32(name string, sms ...scalar.Mapper) (float64, error) { 18347 s, err := d.TryFieldScalarFP32(name, sms...) 18348 return s.ActualF(), err 18349} 18350 18351// FieldFP32 adds a field and reads 32 bit fixed-point number in current endian 18352func (d *D) FieldFP32(name string, sms ...scalar.Mapper) float64 { 18353 return d.FieldScalarFP32(name, sms...).ActualF() 18354} 18355 18356// Reader FP64 18357 18358// TryFP64 tries to read 64 bit fixed-point number in current endian 18359func (d *D) TryFP64() (float64, error) { return d.tryFPE(64, 32, d.Endian) } 18360 18361// FP64 reads 64 bit fixed-point number in current endian 18362func (d *D) FP64() float64 { 18363 v, err := d.tryFPE(64, 32, d.Endian) 18364 if err != nil { 18365 panic(IOError{Err: err, Op: "FP64", Pos: d.Pos()}) 18366 } 18367 return v 18368} 18369 18370// TryFieldScalarFP64 tries to add a field and read 64 bit fixed-point number in current endian 18371func (d *D) TryFieldScalarFP64(name string, sms ...scalar.Mapper) (*scalar.S, error) { 18372 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 18373 v, err := d.tryFPE(64, 32, d.Endian) 18374 s.Actual = v 18375 return s, err 18376 }, sms...) 18377 if err != nil { 18378 return nil, err 18379 } 18380 return s, err 18381} 18382 18383// FieldScalarFP64 adds a field and reads 64 bit fixed-point number in current endian 18384func (d *D) FieldScalarFP64(name string, sms ...scalar.Mapper) *scalar.S { 18385 s, err := d.TryFieldScalarFP64(name, sms...) 18386 if err != nil { 18387 panic(IOError{Err: err, Name: name, Op: "FP64", Pos: d.Pos()}) 18388 } 18389 return s 18390} 18391 18392// TryFieldFP64 tries to add a field and read 64 bit fixed-point number in current endian 18393func (d *D) TryFieldFP64(name string, sms ...scalar.Mapper) (float64, error) { 18394 s, err := d.TryFieldScalarFP64(name, sms...) 18395 return s.ActualF(), err 18396} 18397 18398// FieldFP64 adds a field and reads 64 bit fixed-point number in current endian 18399func (d *D) FieldFP64(name string, sms ...scalar.Mapper) float64 { 18400 return d.FieldScalarFP64(name, sms...).ActualF() 18401} 18402 18403// Reader FP16LE 18404 18405// TryFP16LE tries to read 16 bit fixed-point number in little-endian 18406func (d *D) TryFP16LE() (float64, error) { return d.tryFPE(16, 8, LittleEndian) } 18407 18408// FP16LE reads 16 bit fixed-point number in little-endian 18409func (d *D) FP16LE() float64 { 18410 v, err := d.tryFPE(16, 8, LittleEndian) 18411 if err != nil { 18412 panic(IOError{Err: err, Op: "FP16LE", Pos: d.Pos()}) 18413 } 18414 return v 18415} 18416 18417// TryFieldScalarFP16LE tries to add a field and read 16 bit fixed-point number in little-endian 18418func (d *D) TryFieldScalarFP16LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 18419 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 18420 v, err := d.tryFPE(16, 8, LittleEndian) 18421 s.Actual = v 18422 return s, err 18423 }, sms...) 18424 if err != nil { 18425 return nil, err 18426 } 18427 return s, err 18428} 18429 18430// FieldScalarFP16LE adds a field and reads 16 bit fixed-point number in little-endian 18431func (d *D) FieldScalarFP16LE(name string, sms ...scalar.Mapper) *scalar.S { 18432 s, err := d.TryFieldScalarFP16LE(name, sms...) 18433 if err != nil { 18434 panic(IOError{Err: err, Name: name, Op: "FP16LE", Pos: d.Pos()}) 18435 } 18436 return s 18437} 18438 18439// TryFieldFP16LE tries to add a field and read 16 bit fixed-point number in little-endian 18440func (d *D) TryFieldFP16LE(name string, sms ...scalar.Mapper) (float64, error) { 18441 s, err := d.TryFieldScalarFP16LE(name, sms...) 18442 return s.ActualF(), err 18443} 18444 18445// FieldFP16LE adds a field and reads 16 bit fixed-point number in little-endian 18446func (d *D) FieldFP16LE(name string, sms ...scalar.Mapper) float64 { 18447 return d.FieldScalarFP16LE(name, sms...).ActualF() 18448} 18449 18450// Reader FP32LE 18451 18452// TryFP32LE tries to read 32 bit fixed-point number in little-endian 18453func (d *D) TryFP32LE() (float64, error) { return d.tryFPE(32, 16, LittleEndian) } 18454 18455// FP32LE reads 32 bit fixed-point number in little-endian 18456func (d *D) FP32LE() float64 { 18457 v, err := d.tryFPE(32, 16, LittleEndian) 18458 if err != nil { 18459 panic(IOError{Err: err, Op: "FP32LE", Pos: d.Pos()}) 18460 } 18461 return v 18462} 18463 18464// TryFieldScalarFP32LE tries to add a field and read 32 bit fixed-point number in little-endian 18465func (d *D) TryFieldScalarFP32LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 18466 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 18467 v, err := d.tryFPE(32, 16, LittleEndian) 18468 s.Actual = v 18469 return s, err 18470 }, sms...) 18471 if err != nil { 18472 return nil, err 18473 } 18474 return s, err 18475} 18476 18477// FieldScalarFP32LE adds a field and reads 32 bit fixed-point number in little-endian 18478func (d *D) FieldScalarFP32LE(name string, sms ...scalar.Mapper) *scalar.S { 18479 s, err := d.TryFieldScalarFP32LE(name, sms...) 18480 if err != nil { 18481 panic(IOError{Err: err, Name: name, Op: "FP32LE", Pos: d.Pos()}) 18482 } 18483 return s 18484} 18485 18486// TryFieldFP32LE tries to add a field and read 32 bit fixed-point number in little-endian 18487func (d *D) TryFieldFP32LE(name string, sms ...scalar.Mapper) (float64, error) { 18488 s, err := d.TryFieldScalarFP32LE(name, sms...) 18489 return s.ActualF(), err 18490} 18491 18492// FieldFP32LE adds a field and reads 32 bit fixed-point number in little-endian 18493func (d *D) FieldFP32LE(name string, sms ...scalar.Mapper) float64 { 18494 return d.FieldScalarFP32LE(name, sms...).ActualF() 18495} 18496 18497// Reader FP64LE 18498 18499// TryFP64LE tries to read 64 bit fixed-point number in little-endian 18500func (d *D) TryFP64LE() (float64, error) { return d.tryFPE(64, 32, LittleEndian) } 18501 18502// FP64LE reads 64 bit fixed-point number in little-endian 18503func (d *D) FP64LE() float64 { 18504 v, err := d.tryFPE(64, 32, LittleEndian) 18505 if err != nil { 18506 panic(IOError{Err: err, Op: "FP64LE", Pos: d.Pos()}) 18507 } 18508 return v 18509} 18510 18511// TryFieldScalarFP64LE tries to add a field and read 64 bit fixed-point number in little-endian 18512func (d *D) TryFieldScalarFP64LE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 18513 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 18514 v, err := d.tryFPE(64, 32, LittleEndian) 18515 s.Actual = v 18516 return s, err 18517 }, sms...) 18518 if err != nil { 18519 return nil, err 18520 } 18521 return s, err 18522} 18523 18524// FieldScalarFP64LE adds a field and reads 64 bit fixed-point number in little-endian 18525func (d *D) FieldScalarFP64LE(name string, sms ...scalar.Mapper) *scalar.S { 18526 s, err := d.TryFieldScalarFP64LE(name, sms...) 18527 if err != nil { 18528 panic(IOError{Err: err, Name: name, Op: "FP64LE", Pos: d.Pos()}) 18529 } 18530 return s 18531} 18532 18533// TryFieldFP64LE tries to add a field and read 64 bit fixed-point number in little-endian 18534func (d *D) TryFieldFP64LE(name string, sms ...scalar.Mapper) (float64, error) { 18535 s, err := d.TryFieldScalarFP64LE(name, sms...) 18536 return s.ActualF(), err 18537} 18538 18539// FieldFP64LE adds a field and reads 64 bit fixed-point number in little-endian 18540func (d *D) FieldFP64LE(name string, sms ...scalar.Mapper) float64 { 18541 return d.FieldScalarFP64LE(name, sms...).ActualF() 18542} 18543 18544// Reader FP16BE 18545 18546// TryFP16BE tries to read 16 bit fixed-point number in big-endian 18547func (d *D) TryFP16BE() (float64, error) { return d.tryFPE(16, 8, BigEndian) } 18548 18549// FP16BE reads 16 bit fixed-point number in big-endian 18550func (d *D) FP16BE() float64 { 18551 v, err := d.tryFPE(16, 8, BigEndian) 18552 if err != nil { 18553 panic(IOError{Err: err, Op: "FP16BE", Pos: d.Pos()}) 18554 } 18555 return v 18556} 18557 18558// TryFieldScalarFP16BE tries to add a field and read 16 bit fixed-point number in big-endian 18559func (d *D) TryFieldScalarFP16BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 18560 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 18561 v, err := d.tryFPE(16, 8, BigEndian) 18562 s.Actual = v 18563 return s, err 18564 }, sms...) 18565 if err != nil { 18566 return nil, err 18567 } 18568 return s, err 18569} 18570 18571// FieldScalarFP16BE adds a field and reads 16 bit fixed-point number in big-endian 18572func (d *D) FieldScalarFP16BE(name string, sms ...scalar.Mapper) *scalar.S { 18573 s, err := d.TryFieldScalarFP16BE(name, sms...) 18574 if err != nil { 18575 panic(IOError{Err: err, Name: name, Op: "FP16BE", Pos: d.Pos()}) 18576 } 18577 return s 18578} 18579 18580// TryFieldFP16BE tries to add a field and read 16 bit fixed-point number in big-endian 18581func (d *D) TryFieldFP16BE(name string, sms ...scalar.Mapper) (float64, error) { 18582 s, err := d.TryFieldScalarFP16BE(name, sms...) 18583 return s.ActualF(), err 18584} 18585 18586// FieldFP16BE adds a field and reads 16 bit fixed-point number in big-endian 18587func (d *D) FieldFP16BE(name string, sms ...scalar.Mapper) float64 { 18588 return d.FieldScalarFP16BE(name, sms...).ActualF() 18589} 18590 18591// Reader FP32BE 18592 18593// TryFP32BE tries to read 32 bit fixed-point number in big-endian 18594func (d *D) TryFP32BE() (float64, error) { return d.tryFPE(32, 16, BigEndian) } 18595 18596// FP32BE reads 32 bit fixed-point number in big-endian 18597func (d *D) FP32BE() float64 { 18598 v, err := d.tryFPE(32, 16, BigEndian) 18599 if err != nil { 18600 panic(IOError{Err: err, Op: "FP32BE", Pos: d.Pos()}) 18601 } 18602 return v 18603} 18604 18605// TryFieldScalarFP32BE tries to add a field and read 32 bit fixed-point number in big-endian 18606func (d *D) TryFieldScalarFP32BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 18607 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 18608 v, err := d.tryFPE(32, 16, BigEndian) 18609 s.Actual = v 18610 return s, err 18611 }, sms...) 18612 if err != nil { 18613 return nil, err 18614 } 18615 return s, err 18616} 18617 18618// FieldScalarFP32BE adds a field and reads 32 bit fixed-point number in big-endian 18619func (d *D) FieldScalarFP32BE(name string, sms ...scalar.Mapper) *scalar.S { 18620 s, err := d.TryFieldScalarFP32BE(name, sms...) 18621 if err != nil { 18622 panic(IOError{Err: err, Name: name, Op: "FP32BE", Pos: d.Pos()}) 18623 } 18624 return s 18625} 18626 18627// TryFieldFP32BE tries to add a field and read 32 bit fixed-point number in big-endian 18628func (d *D) TryFieldFP32BE(name string, sms ...scalar.Mapper) (float64, error) { 18629 s, err := d.TryFieldScalarFP32BE(name, sms...) 18630 return s.ActualF(), err 18631} 18632 18633// FieldFP32BE adds a field and reads 32 bit fixed-point number in big-endian 18634func (d *D) FieldFP32BE(name string, sms ...scalar.Mapper) float64 { 18635 return d.FieldScalarFP32BE(name, sms...).ActualF() 18636} 18637 18638// Reader FP64BE 18639 18640// TryFP64BE tries to read 64 bit fixed-point number in big-endian 18641func (d *D) TryFP64BE() (float64, error) { return d.tryFPE(64, 32, BigEndian) } 18642 18643// FP64BE reads 64 bit fixed-point number in big-endian 18644func (d *D) FP64BE() float64 { 18645 v, err := d.tryFPE(64, 32, BigEndian) 18646 if err != nil { 18647 panic(IOError{Err: err, Op: "FP64BE", Pos: d.Pos()}) 18648 } 18649 return v 18650} 18651 18652// TryFieldScalarFP64BE tries to add a field and read 64 bit fixed-point number in big-endian 18653func (d *D) TryFieldScalarFP64BE(name string, sms ...scalar.Mapper) (*scalar.S, error) { 18654 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 18655 v, err := d.tryFPE(64, 32, BigEndian) 18656 s.Actual = v 18657 return s, err 18658 }, sms...) 18659 if err != nil { 18660 return nil, err 18661 } 18662 return s, err 18663} 18664 18665// FieldScalarFP64BE adds a field and reads 64 bit fixed-point number in big-endian 18666func (d *D) FieldScalarFP64BE(name string, sms ...scalar.Mapper) *scalar.S { 18667 s, err := d.TryFieldScalarFP64BE(name, sms...) 18668 if err != nil { 18669 panic(IOError{Err: err, Name: name, Op: "FP64BE", Pos: d.Pos()}) 18670 } 18671 return s 18672} 18673 18674// TryFieldFP64BE tries to add a field and read 64 bit fixed-point number in big-endian 18675func (d *D) TryFieldFP64BE(name string, sms ...scalar.Mapper) (float64, error) { 18676 s, err := d.TryFieldScalarFP64BE(name, sms...) 18677 return s.ActualF(), err 18678} 18679 18680// FieldFP64BE adds a field and reads 64 bit fixed-point number in big-endian 18681func (d *D) FieldFP64BE(name string, sms ...scalar.Mapper) float64 { 18682 return d.FieldScalarFP64BE(name, sms...).ActualF() 18683} 18684 18685// Reader Unary 18686 18687// TryUnary tries to read unary integer using ov as "one" value 18688func (d *D) TryUnary(ov uint64) (uint64, error) { return d.tryUnary(ov) } 18689 18690// Unary reads unary integer using ov as "one" value 18691func (d *D) Unary(ov uint64) uint64 { 18692 v, err := d.tryUnary(ov) 18693 if err != nil { 18694 panic(IOError{Err: err, Op: "Unary", Pos: d.Pos()}) 18695 } 18696 return v 18697} 18698 18699// TryFieldScalarUnary tries to add a field and read unary integer using ov as "one" value 18700func (d *D) TryFieldScalarUnary(name string, ov uint64, sms ...scalar.Mapper) (*scalar.S, error) { 18701 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 18702 v, err := d.tryUnary(ov) 18703 s.Actual = v 18704 return s, err 18705 }, sms...) 18706 if err != nil { 18707 return nil, err 18708 } 18709 return s, err 18710} 18711 18712// FieldScalarUnary adds a field and reads unary integer using ov as "one" value 18713func (d *D) FieldScalarUnary(name string, ov uint64, sms ...scalar.Mapper) *scalar.S { 18714 s, err := d.TryFieldScalarUnary(name, ov, sms...) 18715 if err != nil { 18716 panic(IOError{Err: err, Name: name, Op: "Unary", Pos: d.Pos()}) 18717 } 18718 return s 18719} 18720 18721// TryFieldUnary tries to add a field and read unary integer using ov as "one" value 18722func (d *D) TryFieldUnary(name string, ov uint64, sms ...scalar.Mapper) (uint64, error) { 18723 s, err := d.TryFieldScalarUnary(name, ov, sms...) 18724 return s.ActualU(), err 18725} 18726 18727// FieldUnary adds a field and reads unary integer using ov as "one" value 18728func (d *D) FieldUnary(name string, ov uint64, sms ...scalar.Mapper) uint64 { 18729 return d.FieldScalarUnary(name, ov, sms...).ActualU() 18730} 18731 18732// Reader UTF8 18733 18734// TryUTF8 tries to read nBytes bytes UTF8 string 18735func (d *D) TryUTF8(nBytes int) (string, error) { return d.tryText(nBytes, UTF8BOM) } 18736 18737// UTF8 reads nBytes bytes UTF8 string 18738func (d *D) UTF8(nBytes int) string { 18739 v, err := d.tryText(nBytes, UTF8BOM) 18740 if err != nil { 18741 panic(IOError{Err: err, Op: "UTF8", Pos: d.Pos()}) 18742 } 18743 return v 18744} 18745 18746// TryFieldScalarUTF8 tries to add a field and read nBytes bytes UTF8 string 18747func (d *D) TryFieldScalarUTF8(name string, nBytes int, sms ...scalar.Mapper) (*scalar.S, error) { 18748 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 18749 v, err := d.tryText(nBytes, UTF8BOM) 18750 s.Actual = v 18751 return s, err 18752 }, sms...) 18753 if err != nil { 18754 return nil, err 18755 } 18756 return s, err 18757} 18758 18759// FieldScalarUTF8 adds a field and reads nBytes bytes UTF8 string 18760func (d *D) FieldScalarUTF8(name string, nBytes int, sms ...scalar.Mapper) *scalar.S { 18761 s, err := d.TryFieldScalarUTF8(name, nBytes, sms...) 18762 if err != nil { 18763 panic(IOError{Err: err, Name: name, Op: "UTF8", Pos: d.Pos()}) 18764 } 18765 return s 18766} 18767 18768// TryFieldUTF8 tries to add a field and read nBytes bytes UTF8 string 18769func (d *D) TryFieldUTF8(name string, nBytes int, sms ...scalar.Mapper) (string, error) { 18770 s, err := d.TryFieldScalarUTF8(name, nBytes, sms...) 18771 return s.ActualStr(), err 18772} 18773 18774// FieldUTF8 adds a field and reads nBytes bytes UTF8 string 18775func (d *D) FieldUTF8(name string, nBytes int, sms ...scalar.Mapper) string { 18776 return d.FieldScalarUTF8(name, nBytes, sms...).ActualStr() 18777} 18778 18779// Reader UTF16 18780 18781// TryUTF16 tries to read nBytes bytes UTF16 string, default big-endian and accepts BOM 18782func (d *D) TryUTF16(nBytes int) (string, error) { return d.tryText(nBytes, UTF16BOM) } 18783 18784// UTF16 reads nBytes bytes UTF16 string, default big-endian and accepts BOM 18785func (d *D) UTF16(nBytes int) string { 18786 v, err := d.tryText(nBytes, UTF16BOM) 18787 if err != nil { 18788 panic(IOError{Err: err, Op: "UTF16", Pos: d.Pos()}) 18789 } 18790 return v 18791} 18792 18793// TryFieldScalarUTF16 tries to add a field and read nBytes bytes UTF16 string, default big-endian and accepts BOM 18794func (d *D) TryFieldScalarUTF16(name string, nBytes int, sms ...scalar.Mapper) (*scalar.S, error) { 18795 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 18796 v, err := d.tryText(nBytes, UTF16BOM) 18797 s.Actual = v 18798 return s, err 18799 }, sms...) 18800 if err != nil { 18801 return nil, err 18802 } 18803 return s, err 18804} 18805 18806// FieldScalarUTF16 adds a field and reads nBytes bytes UTF16 string, default big-endian and accepts BOM 18807func (d *D) FieldScalarUTF16(name string, nBytes int, sms ...scalar.Mapper) *scalar.S { 18808 s, err := d.TryFieldScalarUTF16(name, nBytes, sms...) 18809 if err != nil { 18810 panic(IOError{Err: err, Name: name, Op: "UTF16", Pos: d.Pos()}) 18811 } 18812 return s 18813} 18814 18815// TryFieldUTF16 tries to add a field and read nBytes bytes UTF16 string, default big-endian and accepts BOM 18816func (d *D) TryFieldUTF16(name string, nBytes int, sms ...scalar.Mapper) (string, error) { 18817 s, err := d.TryFieldScalarUTF16(name, nBytes, sms...) 18818 return s.ActualStr(), err 18819} 18820 18821// FieldUTF16 adds a field and reads nBytes bytes UTF16 string, default big-endian and accepts BOM 18822func (d *D) FieldUTF16(name string, nBytes int, sms ...scalar.Mapper) string { 18823 return d.FieldScalarUTF16(name, nBytes, sms...).ActualStr() 18824} 18825 18826// Reader UTF16LE 18827 18828// TryUTF16LE tries to read nBytes bytes UTF16 little-endian string 18829func (d *D) TryUTF16LE(nBytes int) (string, error) { return d.tryText(nBytes, UTF16LE) } 18830 18831// UTF16LE reads nBytes bytes UTF16 little-endian string 18832func (d *D) UTF16LE(nBytes int) string { 18833 v, err := d.tryText(nBytes, UTF16LE) 18834 if err != nil { 18835 panic(IOError{Err: err, Op: "UTF16LE", Pos: d.Pos()}) 18836 } 18837 return v 18838} 18839 18840// TryFieldScalarUTF16LE tries to add a field and read nBytes bytes UTF16 little-endian string 18841func (d *D) TryFieldScalarUTF16LE(name string, nBytes int, sms ...scalar.Mapper) (*scalar.S, error) { 18842 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 18843 v, err := d.tryText(nBytes, UTF16LE) 18844 s.Actual = v 18845 return s, err 18846 }, sms...) 18847 if err != nil { 18848 return nil, err 18849 } 18850 return s, err 18851} 18852 18853// FieldScalarUTF16LE adds a field and reads nBytes bytes UTF16 little-endian string 18854func (d *D) FieldScalarUTF16LE(name string, nBytes int, sms ...scalar.Mapper) *scalar.S { 18855 s, err := d.TryFieldScalarUTF16LE(name, nBytes, sms...) 18856 if err != nil { 18857 panic(IOError{Err: err, Name: name, Op: "UTF16LE", Pos: d.Pos()}) 18858 } 18859 return s 18860} 18861 18862// TryFieldUTF16LE tries to add a field and read nBytes bytes UTF16 little-endian string 18863func (d *D) TryFieldUTF16LE(name string, nBytes int, sms ...scalar.Mapper) (string, error) { 18864 s, err := d.TryFieldScalarUTF16LE(name, nBytes, sms...) 18865 return s.ActualStr(), err 18866} 18867 18868// FieldUTF16LE adds a field and reads nBytes bytes UTF16 little-endian string 18869func (d *D) FieldUTF16LE(name string, nBytes int, sms ...scalar.Mapper) string { 18870 return d.FieldScalarUTF16LE(name, nBytes, sms...).ActualStr() 18871} 18872 18873// Reader UTF16BE 18874 18875// TryUTF16BE tries to read nBytes bytes UTF16 big-endian string 18876func (d *D) TryUTF16BE(nBytes int) (string, error) { return d.tryText(nBytes, UTF16BE) } 18877 18878// UTF16BE reads nBytes bytes UTF16 big-endian string 18879func (d *D) UTF16BE(nBytes int) string { 18880 v, err := d.tryText(nBytes, UTF16BE) 18881 if err != nil { 18882 panic(IOError{Err: err, Op: "UTF16BE", Pos: d.Pos()}) 18883 } 18884 return v 18885} 18886 18887// TryFieldScalarUTF16BE tries to add a field and read nBytes bytes UTF16 big-endian string 18888func (d *D) TryFieldScalarUTF16BE(name string, nBytes int, sms ...scalar.Mapper) (*scalar.S, error) { 18889 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 18890 v, err := d.tryText(nBytes, UTF16BE) 18891 s.Actual = v 18892 return s, err 18893 }, sms...) 18894 if err != nil { 18895 return nil, err 18896 } 18897 return s, err 18898} 18899 18900// FieldScalarUTF16BE adds a field and reads nBytes bytes UTF16 big-endian string 18901func (d *D) FieldScalarUTF16BE(name string, nBytes int, sms ...scalar.Mapper) *scalar.S { 18902 s, err := d.TryFieldScalarUTF16BE(name, nBytes, sms...) 18903 if err != nil { 18904 panic(IOError{Err: err, Name: name, Op: "UTF16BE", Pos: d.Pos()}) 18905 } 18906 return s 18907} 18908 18909// TryFieldUTF16BE tries to add a field and read nBytes bytes UTF16 big-endian string 18910func (d *D) TryFieldUTF16BE(name string, nBytes int, sms ...scalar.Mapper) (string, error) { 18911 s, err := d.TryFieldScalarUTF16BE(name, nBytes, sms...) 18912 return s.ActualStr(), err 18913} 18914 18915// FieldUTF16BE adds a field and reads nBytes bytes UTF16 big-endian string 18916func (d *D) FieldUTF16BE(name string, nBytes int, sms ...scalar.Mapper) string { 18917 return d.FieldScalarUTF16BE(name, nBytes, sms...).ActualStr() 18918} 18919 18920// Reader UTF8ShortString 18921 18922// TryUTF8ShortString tries to read one byte length fixed UTF8 string 18923func (d *D) TryUTF8ShortString() (string, error) { return d.tryTextLenPrefixed(8, -1, UTF8BOM) } 18924 18925// UTF8ShortString reads one byte length fixed UTF8 string 18926func (d *D) UTF8ShortString() string { 18927 v, err := d.tryTextLenPrefixed(8, -1, UTF8BOM) 18928 if err != nil { 18929 panic(IOError{Err: err, Op: "UTF8ShortString", Pos: d.Pos()}) 18930 } 18931 return v 18932} 18933 18934// TryFieldScalarUTF8ShortString tries to add a field and read one byte length fixed UTF8 string 18935func (d *D) TryFieldScalarUTF8ShortString(name string, sms ...scalar.Mapper) (*scalar.S, error) { 18936 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 18937 v, err := d.tryTextLenPrefixed(8, -1, UTF8BOM) 18938 s.Actual = v 18939 return s, err 18940 }, sms...) 18941 if err != nil { 18942 return nil, err 18943 } 18944 return s, err 18945} 18946 18947// FieldScalarUTF8ShortString adds a field and reads one byte length fixed UTF8 string 18948func (d *D) FieldScalarUTF8ShortString(name string, sms ...scalar.Mapper) *scalar.S { 18949 s, err := d.TryFieldScalarUTF8ShortString(name, sms...) 18950 if err != nil { 18951 panic(IOError{Err: err, Name: name, Op: "UTF8ShortString", Pos: d.Pos()}) 18952 } 18953 return s 18954} 18955 18956// TryFieldUTF8ShortString tries to add a field and read one byte length fixed UTF8 string 18957func (d *D) TryFieldUTF8ShortString(name string, sms ...scalar.Mapper) (string, error) { 18958 s, err := d.TryFieldScalarUTF8ShortString(name, sms...) 18959 return s.ActualStr(), err 18960} 18961 18962// FieldUTF8ShortString adds a field and reads one byte length fixed UTF8 string 18963func (d *D) FieldUTF8ShortString(name string, sms ...scalar.Mapper) string { 18964 return d.FieldScalarUTF8ShortString(name, sms...).ActualStr() 18965} 18966 18967// Reader UTF8ShortStringFixedLen 18968 18969// TryUTF8ShortStringFixedLen tries to read fixedBytes bytes long one byte length prefixed UTF8 string 18970func (d *D) TryUTF8ShortStringFixedLen(fixedBytes int) (string, error) { 18971 return d.tryTextLenPrefixed(8, fixedBytes, UTF8BOM) 18972} 18973 18974// UTF8ShortStringFixedLen reads fixedBytes bytes long one byte length prefixed UTF8 string 18975func (d *D) UTF8ShortStringFixedLen(fixedBytes int) string { 18976 v, err := d.tryTextLenPrefixed(8, fixedBytes, UTF8BOM) 18977 if err != nil { 18978 panic(IOError{Err: err, Op: "UTF8ShortStringFixedLen", Pos: d.Pos()}) 18979 } 18980 return v 18981} 18982 18983// TryFieldScalarUTF8ShortStringFixedLen tries to add a field and read fixedBytes bytes long one byte length prefixed UTF8 string 18984func (d *D) TryFieldScalarUTF8ShortStringFixedLen(name string, fixedBytes int, sms ...scalar.Mapper) (*scalar.S, error) { 18985 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 18986 v, err := d.tryTextLenPrefixed(8, fixedBytes, UTF8BOM) 18987 s.Actual = v 18988 return s, err 18989 }, sms...) 18990 if err != nil { 18991 return nil, err 18992 } 18993 return s, err 18994} 18995 18996// FieldScalarUTF8ShortStringFixedLen adds a field and reads fixedBytes bytes long one byte length prefixed UTF8 string 18997func (d *D) FieldScalarUTF8ShortStringFixedLen(name string, fixedBytes int, sms ...scalar.Mapper) *scalar.S { 18998 s, err := d.TryFieldScalarUTF8ShortStringFixedLen(name, fixedBytes, sms...) 18999 if err != nil { 19000 panic(IOError{Err: err, Name: name, Op: "UTF8ShortStringFixedLen", Pos: d.Pos()}) 19001 } 19002 return s 19003} 19004 19005// TryFieldUTF8ShortStringFixedLen tries to add a field and read fixedBytes bytes long one byte length prefixed UTF8 string 19006func (d *D) TryFieldUTF8ShortStringFixedLen(name string, fixedBytes int, sms ...scalar.Mapper) (string, error) { 19007 s, err := d.TryFieldScalarUTF8ShortStringFixedLen(name, fixedBytes, sms...) 19008 return s.ActualStr(), err 19009} 19010 19011// FieldUTF8ShortStringFixedLen adds a field and reads fixedBytes bytes long one byte length prefixed UTF8 string 19012func (d *D) FieldUTF8ShortStringFixedLen(name string, fixedBytes int, sms ...scalar.Mapper) string { 19013 return d.FieldScalarUTF8ShortStringFixedLen(name, fixedBytes, sms...).ActualStr() 19014} 19015 19016// Reader UTF8Null 19017 19018// TryUTF8Null tries to read null terminated UTF8 string 19019func (d *D) TryUTF8Null() (string, error) { return d.tryTextNull(1, UTF8BOM) } 19020 19021// UTF8Null reads null terminated UTF8 string 19022func (d *D) UTF8Null() string { 19023 v, err := d.tryTextNull(1, UTF8BOM) 19024 if err != nil { 19025 panic(IOError{Err: err, Op: "UTF8Null", Pos: d.Pos()}) 19026 } 19027 return v 19028} 19029 19030// TryFieldScalarUTF8Null tries to add a field and read null terminated UTF8 string 19031func (d *D) TryFieldScalarUTF8Null(name string, sms ...scalar.Mapper) (*scalar.S, error) { 19032 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 19033 v, err := d.tryTextNull(1, UTF8BOM) 19034 s.Actual = v 19035 return s, err 19036 }, sms...) 19037 if err != nil { 19038 return nil, err 19039 } 19040 return s, err 19041} 19042 19043// FieldScalarUTF8Null adds a field and reads null terminated UTF8 string 19044func (d *D) FieldScalarUTF8Null(name string, sms ...scalar.Mapper) *scalar.S { 19045 s, err := d.TryFieldScalarUTF8Null(name, sms...) 19046 if err != nil { 19047 panic(IOError{Err: err, Name: name, Op: "UTF8Null", Pos: d.Pos()}) 19048 } 19049 return s 19050} 19051 19052// TryFieldUTF8Null tries to add a field and read null terminated UTF8 string 19053func (d *D) TryFieldUTF8Null(name string, sms ...scalar.Mapper) (string, error) { 19054 s, err := d.TryFieldScalarUTF8Null(name, sms...) 19055 return s.ActualStr(), err 19056} 19057 19058// FieldUTF8Null adds a field and reads null terminated UTF8 string 19059func (d *D) FieldUTF8Null(name string, sms ...scalar.Mapper) string { 19060 return d.FieldScalarUTF8Null(name, sms...).ActualStr() 19061} 19062 19063// Reader UTF8NullFixedLen 19064 19065// TryUTF8NullFixedLen tries to read fixedBytes bytes long null terminated UTF8 string 19066func (d *D) TryUTF8NullFixedLen(fixedBytes int) (string, error) { 19067 return d.tryTextNullLen(fixedBytes, UTF8BOM) 19068} 19069 19070// UTF8NullFixedLen reads fixedBytes bytes long null terminated UTF8 string 19071func (d *D) UTF8NullFixedLen(fixedBytes int) string { 19072 v, err := d.tryTextNullLen(fixedBytes, UTF8BOM) 19073 if err != nil { 19074 panic(IOError{Err: err, Op: "UTF8NullFixedLen", Pos: d.Pos()}) 19075 } 19076 return v 19077} 19078 19079// TryFieldScalarUTF8NullFixedLen tries to add a field and read fixedBytes bytes long null terminated UTF8 string 19080func (d *D) TryFieldScalarUTF8NullFixedLen(name string, fixedBytes int, sms ...scalar.Mapper) (*scalar.S, error) { 19081 s, err := d.TryFieldScalarFn(name, func(s scalar.S) (scalar.S, error) { 19082 v, err := d.tryTextNullLen(fixedBytes, UTF8BOM) 19083 s.Actual = v 19084 return s, err 19085 }, sms...) 19086 if err != nil { 19087 return nil, err 19088 } 19089 return s, err 19090} 19091 19092// FieldScalarUTF8NullFixedLen adds a field and reads fixedBytes bytes long null terminated UTF8 string 19093func (d *D) FieldScalarUTF8NullFixedLen(name string, fixedBytes int, sms ...scalar.Mapper) *scalar.S { 19094 s, err := d.TryFieldScalarUTF8NullFixedLen(name, fixedBytes, sms...) 19095 if err != nil { 19096 panic(IOError{Err: err, Name: name, Op: "UTF8NullFixedLen", Pos: d.Pos()}) 19097 } 19098 return s 19099} 19100 19101// TryFieldUTF8NullFixedLen tries to add a field and read fixedBytes bytes long null terminated UTF8 string 19102func (d *D) TryFieldUTF8NullFixedLen(name string, fixedBytes int, sms ...scalar.Mapper) (string, error) { 19103 s, err := d.TryFieldScalarUTF8NullFixedLen(name, fixedBytes, sms...) 19104 return s.ActualStr(), err 19105} 19106 19107// FieldUTF8NullFixedLen adds a field and reads fixedBytes bytes long null terminated UTF8 string 19108func (d *D) FieldUTF8NullFixedLen(name string, fixedBytes int, sms ...scalar.Mapper) string { 19109 return d.FieldScalarUTF8NullFixedLen(name, fixedBytes, sms...).ActualStr() 19110} 19111