Grcov report - format.rs

1

use std::fmt::Display;

2

3

use byteorder::{BigEndian, LittleEndian, ReadBytesExt, WriteBytesExt};

4

use half::f16;

5

6

pub(crate) const INITIAL_VERSION: u8 = 0;

7

pub(crate) const V4_VERSION: u8 = 1;

8

pub(crate) const CURRENT_VERSION: u8 = V4_VERSION;

9

10

use crate::reader::{BufferedBytes, Reader};

11

use crate::Error;

12

/// Writes an atom header into `writer`.

13

#[allow(clippy::cast_possible_truncation)]

14

#[inline]

15

1659908

fn write_tiny_atom_header<W: WriteBytesExt>(

16

1659908

    mut writer: W,

17

1659908

    kind: Kind,

18

1659908

    arg: u8,

19

1659908

) -> std::io::Result<usize> {

20

1659908

    // Kind is the 3 bits.

21

1659908

    let mut first_byte = (kind as u8) << 5;

22

1659908

    if arg > 0 {

23

1588995

        debug_assert!(arg < 0x10);

24

1588995

        first_byte |= arg & 0b1111;

25

70913

26

27

1659908

    writer.write_all(&[first_byte])?;

28

1659908

    Ok(1)

29

1659908

30

31

/// Writes an atom header into `writer`.

32

#[allow(clippy::cast_possible_truncation)]

33

#[inline]

34

1963514

pub fn write_atom_header<W: WriteBytesExt>(

35

1963514

    mut writer: W,

36

1963514

    kind: Kind,

37

1963514

    mut arg: u64,

38

1963514

) -> std::io::Result<usize> {

39

1963514

    if arg < 0x10 {

40

1379637

        write_tiny_atom_header(writer, kind, arg as u8)

41

    } else {

42

        // Kind is the 3 bits.

43

583877

        let mut first_byte = (kind as u8) << 5;

44

583877

        // The last 4 bits are the first 4 bits of the arg. We also know

45

583877

        // that we're longer than one byte, due to the original match.

46

583877

        first_byte |= arg as u8 & 0b1111;

47

583877

        arg >>= 4;

48

583877

        first_byte |= 0b10000;

49

583877

50

583877

        let mut second = arg as u8 & 0x7F;

51

583877

        arg >>= 7;

52

583877

        if arg == 0 {

53

583819

            writer.write_all(&[first_byte, second])?;

54

583819

            return Ok(2);

55

58

56

58

57

58

        second |= 0b1000_0000;

58

        let mut third = arg as u8 & 0x7F;

59

58

        arg >>= 7;

60

58

        if arg == 0 {

61

11

            writer.write_all(&[first_byte, second, third])?;

62

11

            return Ok(3);

63

47

64

47

65

47

        third |= 0b1000_0000;

66

47

        let mut fourth = arg as u8 & 0x7F;

67

47

        arg >>= 7;

68

47

        if arg == 0 {

69

7

            writer.write_all(&[first_byte, second, third, fourth])?;

70

7

            return Ok(4);

71

40

72

40

73

40

        fourth |= 0b1000_0000;

74

40

        let mut fifth = arg as u8 & 0x7F;

75

40

        arg >>= 7;

76

40

        if arg == 0 {

77

7

            writer.write_all(&[first_byte, second, third, fourth, fifth])?;

78

7

            return Ok(5);

79

33

80

33

81

33

        fifth |= 0b1000_0000;

82

33

        let mut sixth = arg as u8 & 0x7F;

83

33

        arg >>= 7;

84

33

        if arg == 0 {

85

7

            writer.write_all(&[first_byte, second, third, fourth, fifth, sixth])?;

86

7

            return Ok(6);

87

26

88

26

        sixth |= 0b1000_0000;

89

26

        let mut seventh = arg as u8 & 0x7F;

90

26

        arg >>= 7;

91

26

        if arg == 0 {

92

7

            writer.write_all(&[first_byte, second, third, fourth, fifth, sixth, seventh])?;

93

7

            return Ok(7);

94

19

95

19

        seventh |= 0b1000_0000;

96

19

        let mut eighth = arg as u8 & 0x7F;

97

19

        arg >>= 7;

98

19

        if arg == 0 {

99

7

            writer.write_all(&[

100

7

                first_byte, second, third, fourth, fifth, sixth, seventh, eighth,

101

7

            ])?;

102

7

            return Ok(8);

103

12

104

12

105

12

        eighth |= 0b1000_0000;

106

12

        let mut ninth = arg as u8 & 0x7F;

107

12

        arg >>= 7;

108

12

        if arg == 0 {

109

7

            writer.write_all(&[

110

7

                first_byte, second, third, fourth, fifth, sixth, seventh, eighth, ninth,

111

7

            ])?;

112

7

            return Ok(9);

113

5

114

5

115

5

        ninth |= 0b1000_0000;

116

5

        debug_assert!(arg <= 255);

117

5

        writer.write_all(&[

118

5

            first_byte, second, third, fourth, fifth, sixth, seventh, eighth, ninth, arg as u8,

119

5

        ])?;

120

5

        Ok(10)

121

122

1963514

123

124

/// Reads an atom header (kind and argument).

125

#[inline]

126

160854

pub fn read_atom_header<R: ReadBytesExt>(reader: &mut R) -> Result<(Kind, u64), Error> {

127

160854

    let first_byte = reader.read_u8()?;

128

160854

    let kind = Kind::from_u8(first_byte >> 5)?;

129

160854

    let mut arg = u64::from(first_byte & 0b1111);

130

160854

    if first_byte & 0b10000 != 0 {

131

42121

        let mut bytes_remaining = 9;

132

42121

        let mut offset = 4;

133

        loop {

134

42358

            let byte = reader.read_u8()?;

135

42358

            let data = byte & 0x7f;

136

42358

            arg |= u64::from(data) << offset;

137

42358

            offset += 7;

138

42358

            bytes_remaining -= 1;

139

42358

            if data == byte || bytes_remaining == 0 {

140

42121

                break;

141

237

142

143

118733

144

145

160854

    Ok((kind, arg))

146

160854

147

148

/// The type of an atom.

149

#[derive(Clone, Copy, Eq, PartialEq, Debug)]

150

pub enum Kind {

151

    /// A value with a special meaning.

152

    Special = 0,

153

    /// A signed integer. Argument is the byte length, minus one. The following

154

    /// bytes are the value, stored in little endian.

155

    Int = 1,

156

    /// An unsigned integer. Argument is the byte length, minus one. The

157

    /// following bytes are the value, stored in little endian.

158

    UInt = 2,

159

    /// A floating point value. Argument is the byte length, minus one. Must be

160

    /// either 2, 4 or 8 bytes. The following bytes are the value, stored in

161

    /// little endian. The two-byte representation follows the IEEE 754-2008

162

    /// standard, implemented by the [`half`] crate.

163

    Float = 3,

164

    /// A list of atoms. Argument is the count of atoms in the sequence.

165

    Sequence = 4,

166

    /// A list of key-value pairs. Argument is the count of entries in the map.

167

    /// There will be twice as many total atoms, since each entry is a key/value

168

    /// pair.

169

    Map = 5,

170

    /// A symbol. If the least-significant bit of the arg is 0, this is a new

171

    /// symbol. The remaining bits of the arg contain the length in bytes. The

172

    /// following bytes will contain the symbol bytes (UTF-8). It should be

173

    /// stored and given a unique symbol id, starting at 0.

174

///

175

    /// If the least-significant bit of the arg is 1, the remaining bits are the

176

    /// symbol id of a previously emitted symbol.

177

    Symbol = 6,

178

    /// A series of bytes. The argument is the length. The bytes follow.

179

    Bytes = 7,

180

181

182

impl Kind {

183

    /// Converts from a u8. Returns an error if `kind` is an invalid value.

184

    #[inline]

185

160870

    pub const fn from_u8(kind: u8) -> Result<Self, Error> {

186

160870

        match kind {

187

15082

            0 => Ok(Self::Special),

188

138

            1 => Ok(Self::Int),

189

20179

            2 => Ok(Self::UInt),

190

46

            3 => Ok(Self::Float),

191

21

            4 => Ok(Self::Sequence),

192

10098

            5 => Ok(Self::Map),

193

80259

            6 => Ok(Self::Symbol),

194

35039

            7 => Ok(Self::Bytes),

195

8

            other => Err(Error::InvalidKind(other)),

196

197

160870

198

199

200

/// A special value type.

201

#[derive(Debug)]

202

pub enum Special {

203

    /// A None value.

204

    None = 0,

205

    /// A Unit value.

206

    Unit = 1,

207

    /// The `false` boolean literal.

208

    False = 2,

209

    /// The `true` boolean literal.

210

    True = 3,

211

    /// A named value. A symbol followed by another value.

212

    Named = 4,

213

    /// A sequence of key-value pairs with an unknown length.

214

    DynamicMap = 5,

215

    /// A terminal value for a [`Self::DynamicMap`].

216

    DynamicEnd = 6,

217

218

219

#[cfg(test)]

220

pub(crate) const SPECIAL_COUNT: u64 = Special::Named as u64 + 1;

221

222

impl TryFrom<u64> for Special {

223

    type Error = UnknownSpecial;

224

225

    #[inline]

226

15082

    fn try_from(value: u64) -> Result<Self, Self::Error> {

227

15082

        match value {

228

5034

            0 => Ok(Self::None),

229

20

            1 => Ok(Self::Unit),

230

1

            2 => Ok(Self::False),

231

3

            3 => Ok(Self::True),

232

10018

            4 => Ok(Self::Named),

233

3

            5 => Ok(Self::DynamicMap),

234

2

            6 => Ok(Self::DynamicEnd),

235

1

            _ => Err(UnknownSpecial(value)),

236

237

15082

238

239

240

#[test]

241

1

fn unknown_special() {

242

1

    let err = Special::try_from(u64::MAX).unwrap_err();

243

1

    assert_eq!(err, UnknownSpecial(u64::MAX));

244

1

    assert!(err.to_string().contains("unknown special"));

245

1

246

247

/// An unknown [`Special`] was encountered.

248

#[derive(Debug, Clone, Copy, Eq, PartialEq)]

249

pub struct UnknownSpecial(pub u64);

250

251

impl Display for UnknownSpecial {

252

1

    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

253

1

        write!(f, "unknown special id: {}", self.0)

254

1

255

256

257

/// Writes the Pot header. A u32 written in big endian. The first three bytes

258

/// are 'Pot' (`0x506F74`), and the fourth byte is the version. The first

259

/// version of Pot is 0.

260

#[inline]

261

1178

pub fn write_header<W: WriteBytesExt>(mut writer: W, version: u8) -> std::io::Result<usize> {

262

1178

    writer.write_u32::<BigEndian>(0x506F_7400 | u32::from(version))?;

263

1178

    Ok(4)

264

1178

265

266

/// Reads a Pot header. See [`write_header`] for more information. Returns the version number contained within.

267

#[allow(clippy::similar_names, clippy::cast_possible_truncation)]

268

#[inline]

269

232

pub fn read_header<R: ReadBytesExt>(reader: &mut R) -> Result<u8, Error> {

270

232

    let header = reader.read_u32::<BigEndian>()?;

271

232

    if header & 0x506F_7400 == 0x506F_7400 {

272

231

        let version = (header & 0xFF) as u8;

273

231

        Ok(version)

274

    } else {

275

1

        Err(Error::IncompatibleVersion)

276

277

232

278

/// Writes a [`Kind::Special`] atom.

279

#[inline]

280

210191

pub fn write_special<W: WriteBytesExt>(writer: W, special: Special) -> std::io::Result<usize> {

281

210191

    write_atom_header(writer, Kind::Special, special as u64)

282

210191

283

284

/// Writes a [`Kind::Special`] atom with [`Special::None`].

285

#[inline]

286

70158

pub fn write_none<W: WriteBytesExt>(writer: W) -> std::io::Result<usize> {

287

70158

    write_special(writer, Special::None)

288

70158

289

290

/// Writes a [`Kind::Special`] atom with [`Special::Unit`].

291

#[inline]

292

7

pub fn write_unit<W: WriteBytesExt>(writer: W) -> std::io::Result<usize> {

293

7

    write_special(writer, Special::Unit)

294

7

295

296

/// Writes a [`Kind::Special`] atom with [`Special::Named`].

297

#[inline]

298

140018

pub fn write_named<W: WriteBytesExt>(writer: W) -> std::io::Result<usize> {

299

140018

    write_special(writer, Special::Named)

300

140018

301

302

/// Writes a [`Kind::Special`] atom with either [`Special::True`] or [`Special::False`].

303

#[inline]

304

4

pub fn write_bool<W: WriteBytesExt>(writer: W, boolean: bool) -> std::io::Result<usize> {

305

4

    write_special(

306

4

        writer,

307

4

        if boolean {

308

3

            Special::True

309

        } else {

310

1

            Special::False

311

},

312

313

4

314

315

/// Writes an [`Kind::Int`] atom with the given value. Will encode in a smaller format if possible.

316

#[inline]

317

67

pub fn write_i8<W: WriteBytesExt>(mut writer: W, value: i8) -> std::io::Result<usize> {

318

67

    let header_len =

319

67

        write_atom_header(&mut writer, Kind::Int, std::mem::size_of::<i8>() as u64 - 1)?;

320

67

    writer

321

67

        .write_i8(value)

322

67

        .map(|_| std::mem::size_of::<i8>() + header_len)

323

67

324

325

/// Writes an [`Kind::Int`] atom with the given value. Will encode in a smaller format if possible.

326

#[inline]

327

64

pub fn write_i16<W: WriteBytesExt>(mut writer: W, value: i16) -> std::io::Result<usize> {

328

64

    if let Ok(value) = i8::try_from(value) {

329

50

        write_i8(writer, value)

330

    } else {

331

14

        let header_len = write_tiny_atom_header(&mut writer, Kind::Int, 2 - 1)?;

332

14

        writer

333

14

            .write_i16::<LittleEndian>(value)

334

14

            .map(|_| 2 + header_len)

335

336

64

337

338

/// Writes an [`Kind::Int`] atom with the given value. Will encode in a smaller format if possible.

339

#[inline]

340

56

pub fn write_i24<W: WriteBytesExt>(mut writer: W, value: i32) -> std::io::Result<usize> {

341

56

    if let Ok(value) = i16::try_from(value) {

342

48

        write_i16(writer, value)

343

    } else {

344

8

        let header_len = write_tiny_atom_header(&mut writer, Kind::Int, 3 - 1)?;

345

8

        writer

346

8

            .write_i24::<LittleEndian>(value)

347

8

            .map(|_| 3 + header_len)

348

349

56

350

351

/// Writes an [`Kind::Int`] atom with the given value. Will encode in a smaller format if possible.

352

#[inline]

353

70

pub fn write_i32<W: WriteBytesExt>(mut writer: W, value: i32) -> std::io::Result<usize> {

354

70

    if value >= -(2_i32.pow(23)) && value < 2_i32.pow(23) {

355

56

        write_i24(writer, value)

356

    } else {

357

14

        let header_len = write_tiny_atom_header(&mut writer, Kind::Int, 4 - 1)?;

358

14

        writer

359

14

            .write_i32::<LittleEndian>(value)

360

14

            .map(|_| 4 + header_len)

361

362

70

363

364

/// Writes an [`Kind::Int`] atom with the given value. Will encode in a smaller format if possible.

365

#[inline]

366

58

pub fn write_i48<W: WriteBytesExt>(mut writer: W, value: i64) -> std::io::Result<usize> {

367

58

    if let Ok(value) = i32::try_from(value) {

368

50

        write_i32(writer, value)

369

    } else {

370

8

        let header_len = write_tiny_atom_header(&mut writer, Kind::Int, 6 - 1)?;

371

8

        writer

372

8

            .write_i48::<LittleEndian>(value)

373

8

            .map(|_| 6 + header_len)

374

375

58

376

377

/// Writes an [`Kind::Int`] atom with the given value. Will encode in a smaller format if possible.

378

#[inline]

379

70

pub fn write_i64<W: WriteBytesExt>(mut writer: W, value: i64) -> std::io::Result<usize> {

380

70

    if value >= -(2_i64.pow(47)) && value < 2_i64.pow(47) {

381

58

        write_i48(writer, value)

382

    } else {

383

12

        let header_len = write_tiny_atom_header(&mut writer, Kind::Int, 8 - 1)?;

384

12

        writer

385

12

            .write_i64::<LittleEndian>(value)

386

12

            .map(|_| 8 + header_len)

387

388

70

389

390

/// Writes an [`Kind::Int`] atom with the given value. Will encode in a smaller format if possible.

391

#[inline]

392

62

pub fn write_i128<W: WriteBytesExt>(mut writer: W, value: i128) -> std::io::Result<usize> {

393

62

    if let Ok(value) = i64::try_from(value) {

394

54

        write_i64(writer, value)

395

    } else {

396

8

        let header_len = write_tiny_atom_header(&mut writer, Kind::Int, 16 - 1)?;

397

8

        writer

398

8

            .write_i128::<LittleEndian>(value)

399

8

            .map(|_| 16 + header_len)

400

401

62

402

403

/// Writes an [`Kind::UInt`] atom with the given value.

404

#[inline]

405

687

pub fn write_u8<W: WriteBytesExt>(mut writer: W, value: u8) -> std::io::Result<usize> {

406

687

    let header_len = write_tiny_atom_header(&mut writer, Kind::UInt, 0)?;

407

687

    writer

408

687

        .write_u8(value)

409

687

        .map(|_| std::mem::size_of::<u8>() + header_len)

410

687

411

412

/// Writes an [`Kind::Int`] atom with the given value. Will encode in a smaller format if possible.

413

#[inline]

414

140095

pub fn write_u16<W: WriteBytesExt>(mut writer: W, value: u16) -> std::io::Result<usize> {

415

140095

    if let Ok(value) = u8::try_from(value) {

416

659

        write_u8(writer, value)

417

    } else {

418

139436

        let header_len = write_tiny_atom_header(&mut writer, Kind::UInt, 1)?;

419

139436

        writer

420

139436

            .write_u16::<LittleEndian>(value)

421

139436

            .map(|_| std::mem::size_of::<u16>() + header_len)

422

423

140095

424

425

/// Writes an [`Kind::Int`] atom with the given value. Will encode in a smaller format if possible.

426

#[inline]

427

85

pub fn write_u24<W: WriteBytesExt>(mut writer: W, value: u32) -> std::io::Result<usize> {

428

85

    if let Ok(value) = u16::try_from(value) {

429

77

        write_u16(writer, value)

430

    } else {

431

8

        let header_len = write_tiny_atom_header(&mut writer, Kind::UInt, 2)?;

432

8

        writer

433

8

            .write_u24::<LittleEndian>(value)

434

8

            .map(|_| 3 + header_len)

435

436

85

437

438

/// Writes an [`Kind::Int`] atom with the given value. Will encode in a smaller format if possible.

439

#[inline]

440

94

pub fn write_u32<W: WriteBytesExt>(mut writer: W, value: u32) -> std::io::Result<usize> {

441

94

    if value < 2_u32.pow(24) {

442

85

        write_u24(writer, value)

443

    } else {

444

9

        let header_len = write_tiny_atom_header(&mut writer, Kind::UInt, 3)?;

445

9

        writer

446

9

            .write_u32::<LittleEndian>(value)

447

9

            .map(|_| std::mem::size_of::<u32>() + header_len)

448

449

94

450

451

/// Writes an [`Kind::Int`] atom with the given value. Will encode in a smaller format if possible.

452

#[inline]

453

70

pub fn write_u48<W: WriteBytesExt>(mut writer: W, value: u64) -> std::io::Result<usize> {

454

70

    if let Ok(value) = u32::try_from(value) {

455

63

        write_u32(writer, value)

456

    } else {

457

7

        let header_len = write_tiny_atom_header(&mut writer, Kind::UInt, 5)?;

458

7

        writer

459

7

            .write_u48::<LittleEndian>(value)

460

7

            .map(|_| 6 + header_len)

461

462

70

463

464

/// Writes an [`Kind::Int`] atom with the given value. Will encode in a smaller format if possible.

465

#[inline]

466

140081

pub fn write_u64<W: WriteBytesExt>(mut writer: W, value: u64) -> std::io::Result<usize> {

467

140081

    if value < 2_u64.pow(48) {

468

70

        write_u48(writer, value)

469

    } else {

470

140011

        let header_len = write_tiny_atom_header(&mut writer, Kind::UInt, 7)?;

471

140011

        writer

472

140011

            .write_u64::<LittleEndian>(value)

473

140011

            .map(|_| std::mem::size_of::<u64>() + header_len)

474

475

140081

476

477

/// Writes an [`Kind::Int`] atom with the given value. Will encode in a smaller format if possible.

478

#[inline]

479

41

pub fn write_u128<W: WriteBytesExt>(mut writer: W, value: u128) -> std::io::Result<usize> {

480

41

    if let Ok(value) = u64::try_from(value) {

481

34

        write_u64(writer, value)

482

    } else {

483

7

        let header_len = write_tiny_atom_header(&mut writer, Kind::UInt, 15)?;

484

7

        writer

485

7

            .write_u128::<LittleEndian>(value)

486

7

            .map(|_| std::mem::size_of::<u128>() + header_len)

487

488

41

489

490

/// Writes an [`Kind::Float`] atom with the given value.

491

#[inline]

492

#[allow(clippy::cast_possible_truncation, clippy::float_cmp)]

493

38

pub fn write_f32<W: WriteBytesExt>(mut writer: W, value: f32) -> std::io::Result<usize> {

494

38

    let as_f16 = f16::from_f32(value);

495

38

    if as_f16.to_f32() == value {

496

34

        let header_len = write_tiny_atom_header(

497

34

            &mut writer,

498

34

            Kind::Float,

499

34

            std::mem::size_of::<u16>() as u8 - 1,

500

34

)?;

501

34

        writer

502

34

            .write_u16::<LittleEndian>(as_f16.to_bits())

503

34

            .map(|_| std::mem::size_of::<u16>() + header_len)

504

    } else {

505

4

        let header_len = write_tiny_atom_header(

506

4

            &mut writer,

507

4

            Kind::Float,

508

4

            std::mem::size_of::<f32>() as u8 - 1,

509

4

)?;

510

4

        writer

511

4

            .write_f32::<LittleEndian>(value)

512

4

            .map(|_| std::mem::size_of::<f32>() + header_len)

513

514

38

515

516

34

fn read_f16<R: ReadBytesExt>(reader: &mut R) -> std::io::Result<f32> {

517

34

    let value = f16::from_bits(reader.read_u16::<LittleEndian>()?);

518

34

    Ok(value.to_f32())

519

34

520

521

/// Writes an [`Kind::Float`] atom with the given value.

522

#[allow(clippy::cast_possible_truncation, clippy::float_cmp)]

523

#[inline]

524

25

pub fn write_f64<W: WriteBytesExt>(mut writer: W, value: f64) -> std::io::Result<usize> {

525

25

    let as_f32 = value as f32;

526

25

    if f64::from(as_f32) == value {

527

21

        write_f32(writer, as_f32)

528

    } else {

529

4

        let header_len = write_tiny_atom_header(&mut writer, Kind::Float, 7)?;

530

4

        writer

531

4

            .write_f64::<LittleEndian>(value)

532

4

            .map(|_| std::mem::size_of::<f64>() + header_len)

533

534

25

535

536

/// Writes an [`Kind::Bytes`] atom with the bytes of the string.

537

#[inline]

538

489879

pub fn write_str<W: WriteBytesExt>(writer: W, value: &str) -> std::io::Result<usize> {

539

489879

    write_bytes(writer, value.as_bytes())

540

489879

541

542

/// Writes an [`Kind::Bytes`] atom with the given value.

543

#[inline]

544

489891

pub fn write_bytes<W: WriteBytesExt>(mut writer: W, value: &[u8]) -> std::io::Result<usize> {

545

489891

    let header_len = write_atom_header(&mut writer, Kind::Bytes, value.len() as u64)?;

546

489891

    writer.write_all(value)?;

547

489891

    Ok(value.len() + header_len)

548

489891

549

550

/// An integer type that can safely convert between other number types using compile-time evaluation.

551

#[derive(Clone, Copy, Debug, Eq, PartialEq)]

552

pub struct Integer(pub(crate) InnerInteger);

553

554

#[derive(Clone, Copy, Debug, Eq, PartialEq)]

555

pub(crate) enum InnerInteger {

556

    /// An i8 value.

557

    I8(i8),

558

    /// An i16 value.

559

    I16(i16),

560

    /// An i32 value.

561

    I32(i32),

562

    /// An i64 value.

563

    I64(i64),

564

    /// An i128 value.

565

    I128(i128),

566

    /// An u8 value.

567

    U8(u8),

568

    /// An u16 value.

569

    U16(u16),

570

    /// An u32 value.

571

    U32(u32),

572

    /// An u64 value.

573

    U64(u64),

574

    /// An u128 value.

575

    U128(u128),

576

577

578

impl Display for Integer {

579

27

    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

580

27

        match &self.0 {

581

6

            InnerInteger::I8(value) => Display::fmt(value, f),

582

1

            InnerInteger::I16(value) => Display::fmt(value, f),

583

1

            InnerInteger::I32(value) => Display::fmt(value, f),

584

1

            InnerInteger::I64(value) => Display::fmt(value, f),

585

1

            InnerInteger::I128(value) => Display::fmt(value, f),

586

13

            InnerInteger::U8(value) => Display::fmt(value, f),

587

1

            InnerInteger::U16(value) => Display::fmt(value, f),

588

1

            InnerInteger::U32(value) => Display::fmt(value, f),

589

1

            InnerInteger::U64(value) => Display::fmt(value, f),

590

1

            InnerInteger::U128(value) => Display::fmt(value, f),

591

592

27

593

594

595

impl Integer {

596

    /// Returns true if the value contained is zero.

597

    #[must_use]

598

    #[inline]

599

14

    pub const fn is_zero(&self) -> bool {

600

14

        match &self.0 {

601

4

            InnerInteger::I8(value) => *value == 0,

602

1

            InnerInteger::I16(value) => *value == 0,

603

1

            InnerInteger::I32(value) => *value == 0,

604

1

            InnerInteger::I64(value) => *value == 0,

605

1

            InnerInteger::I128(value) => *value == 0,

606

2

            InnerInteger::U8(value) => *value == 0,

607

1

            InnerInteger::U16(value) => *value == 0,

608

1

            InnerInteger::U32(value) => *value == 0,

609

1

            InnerInteger::U64(value) => *value == 0,

610

1

            InnerInteger::U128(value) => *value == 0,

611

612

14

613

614

    /// Returns the contained value as an i8, or an error if the value is unable to fit.

615

    // clippy::checked_conversions: try_from isn't const, and it would demote this from a const fn.

616

    #[allow(clippy::cast_possible_wrap)]

617

    #[allow(clippy::checked_conversions)]

618

    #[inline]

619

41

    pub const fn as_i8(&self) -> Result<i8, Error> {

620

41

        match &self.0 {

621

21

            InnerInteger::I8(value) => Ok(*value),

622

4

            InnerInteger::U8(value) => {

623

4

                if *value <= i8::MAX as u8 {

624

1

                    Ok(*value as i8)

625

                } else {

626

3

                    Err(Error::ImpreciseCastWouldLoseData)

627

628

629

16

            _ => Err(Error::ImpreciseCastWouldLoseData),

630

631

41

632

633

    /// Returns the contained value as an u8, or an error if the value is unable to fit.

634

    #[allow(clippy::cast_sign_loss)]

635

    #[inline]

636

61

    pub const fn as_u8(&self) -> Result<u8, Error> {

637

61

        match &self.0 {

638

45

            InnerInteger::U8(value) => Ok(*value),

639

4

            InnerInteger::I8(value) => {

640

4

                if *value >= 0 {

641

3

                    Ok(*value as u8)

642

                } else {

643

1

                    Err(Error::ImpreciseCastWouldLoseData)

644

645

646

12

            _ => Err(Error::ImpreciseCastWouldLoseData),

647

648

61

649

650

    /// Returns the contained value as an i16, or an error if the value is unable to fit.

651

    #[allow(clippy::cast_possible_wrap)]

652

    #[allow(clippy::checked_conversions)]

653

    #[inline]

654

41

    pub const fn as_i16(&self) -> Result<i16, Error> {

655

41

        match &self.0 {

656

12

            InnerInteger::I8(value) => Ok(*value as i16),

657

2

            InnerInteger::U8(value) => Ok(*value as i16),

658

11

            InnerInteger::I16(value) => Ok(*value),

659

4

            InnerInteger::U16(value) => {

660

4

                if *value <= i16::MAX as u16 {

661

1

                    Ok(*value as i16)

662

                } else {

663

3

                    Err(Error::ImpreciseCastWouldLoseData)

664

665

666

            InnerInteger::U32(_)

667

            | InnerInteger::I32(_)

668

            | InnerInteger::U64(_)

669

            | InnerInteger::I64(_)

670

            | InnerInteger::U128(_)

671

12

            | InnerInteger::I128(_) => Err(Error::ImpreciseCastWouldLoseData),

672

673

41

674

675

    /// Returns the contained value as an u16, or an error if the value is unable to fit.

676

    #[allow(clippy::cast_sign_loss)]

677

    #[inline]

678

10037

    pub const fn as_u16(&self) -> Result<u16, Error> {

679

10037

        match &self.0 {

680

2

            InnerInteger::I8(value) => {

681

2

                if *value >= 0 {

682

1

                    Ok(*value as u16)

683

                } else {

684

1

                    Err(Error::ImpreciseCastWouldLoseData)

685

686

687

48

            InnerInteger::U8(value) => Ok(*value as u16),

688

9974

            InnerInteger::U16(value) => Ok(*value),

689

4

            InnerInteger::I16(value) => {

690

4

                if *value >= 0 {

691

3

                    Ok(*value as u16)

692

                } else {

693

1

                    Err(Error::ImpreciseCastWouldLoseData)

694

695

696

            InnerInteger::U32(_)

697

            | InnerInteger::I32(_)

698

            | InnerInteger::U64(_)

699

            | InnerInteger::I64(_)

700

            | InnerInteger::U128(_)

701

9

            | InnerInteger::I128(_) => Err(Error::ImpreciseCastWouldLoseData),

702

703

10037

704

705

    /// Returns the contained value as an i32, or an error if the value is unable to fit.

706

    #[allow(clippy::cast_possible_wrap)]

707

    #[allow(clippy::checked_conversions)]

708

    #[inline]

709

55

    pub const fn as_i32(&self) -> Result<i32, Error> {

710

55

        match &self.0 {

711

19

            InnerInteger::I8(value) => Ok(*value as i32),

712

3

            InnerInteger::U8(value) => Ok(*value as i32),

713

2

            InnerInteger::I16(value) => Ok(*value as i32),

714

2

            InnerInteger::U16(value) => Ok(*value as i32),

715

15

            InnerInteger::I32(value) => Ok(*value),

716

6

            InnerInteger::U32(value) => {

717

6

                if *value <= i32::MAX as u32 {

718

1

                    Ok(*value as i32)

719

                } else {

720

5

                    Err(Error::ImpreciseCastWouldLoseData)

721

722

723

            InnerInteger::U64(_)

724

            | InnerInteger::I64(_)

725

            | InnerInteger::U128(_)

726

8

            | InnerInteger::I128(_) => Err(Error::ImpreciseCastWouldLoseData),

727

728

55

729

730

    /// Returns the contained value as an u32, or an error if the value is unable to fit.

731

    #[allow(clippy::cast_sign_loss)]

732

    #[inline]

733

53

    pub const fn as_u32(&self) -> Result<u32, Error> {

734

53

        match &self.0 {

735

2

            InnerInteger::I8(value) => {

736

2

                if *value >= 0 {

737

1

                    Ok(*value as u32)

738

                } else {

739

1

                    Err(Error::ImpreciseCastWouldLoseData)

740

741

742

24

            InnerInteger::U8(value) => Ok(*value as u32),

743

2

            InnerInteger::I16(value) => {

744

2

                if *value >= 0 {

745

1

                    Ok(*value as u32)

746

                } else {

747

1

                    Err(Error::ImpreciseCastWouldLoseData)

748

749

750

1

            InnerInteger::U16(value) => Ok(*value as u32),

751

14

            InnerInteger::U32(value) => Ok(*value),

752

4

            InnerInteger::I32(value) => {

753

4

                if *value >= 0 {

754

3

                    Ok(*value as u32)

755

                } else {

756

1

                    Err(Error::ImpreciseCastWouldLoseData)

757

758

759

            InnerInteger::U64(_)

760

            | InnerInteger::I64(_)

761

            | InnerInteger::U128(_)

762

6

            | InnerInteger::I128(_) => Err(Error::ImpreciseCastWouldLoseData),

763

764

53

765

766

    /// Returns the contained value as an i64, or an error if the value is unable to fit.

767

    #[allow(clippy::cast_possible_wrap)]

768

    #[allow(clippy::checked_conversions)]

769

    #[inline]

770

41

    pub const fn as_i64(&self) -> Result<i64, Error> {

771

41

        match &self.0 {

772

12

            InnerInteger::I8(value) => Ok(*value as i64),

773

2

            InnerInteger::U8(value) => Ok(*value as i64),

774

2

            InnerInteger::I16(value) => Ok(*value as i64),

775

2

            InnerInteger::U16(value) => Ok(*value as i64),

776

2

            InnerInteger::I32(value) => Ok(*value as i64),

777

4

            InnerInteger::U32(value) => Ok(*value as i64),

778

11

            InnerInteger::I64(value) => Ok(*value),

779

2

            InnerInteger::U64(value) => {

780

2

                if *value <= i64::MAX as u64 {

781

1

                    Ok(*value as i64)

782

                } else {

783

1

                    Err(Error::ImpreciseCastWouldLoseData)

784

785

786

4

            InnerInteger::U128(_) | InnerInteger::I128(_) => Err(Error::ImpreciseCastWouldLoseData),

787

788

41

789

790

    /// Returns the contained value as an i64, or an error if the value is unable to fit.

791

    #[allow(clippy::cast_possible_wrap)]

792

    #[inline]

793

81

    pub const fn as_i128(&self) -> Result<i128, Error> {

794

81

        match &self.0 {

795

18

            InnerInteger::I8(value) => Ok(*value as i128),

796

2

            InnerInteger::U8(value) => Ok(*value as i128),

797

10

            InnerInteger::I16(value) => Ok(*value as i128),

798

2

            InnerInteger::U16(value) => Ok(*value as i128),

799

18

            InnerInteger::I32(value) => Ok(*value as i128),

800

2

            InnerInteger::U32(value) => Ok(*value as i128),

801

16

            InnerInteger::I64(value) => Ok(*value as i128),

802

2

            InnerInteger::U64(value) => Ok(*value as i128),

803

9

            InnerInteger::I128(value) => Ok(*value),

804

2

            InnerInteger::U128(value) => {

805

2

                if *value <= i128::MAX as u128 {

806

1

                    Ok(*value as i128)

807

                } else {

808

1

                    Err(Error::ImpreciseCastWouldLoseData)

809

810

811

812

81

813

814

    /// Returns the contained value as an u64, or an error if the value is unable to fit.

815

    #[allow(clippy::cast_sign_loss)]

816

    #[inline]

817

10062

    pub const fn as_u64(&self) -> Result<u64, Error> {

818

10062

        match &self.0 {

819

2

            InnerInteger::I8(value) => {

820

2

                if *value >= 0 {

821

1

                    Ok(*value as u64)

822

                } else {

823

1

                    Err(Error::ImpreciseCastWouldLoseData)

824

825

826

37

            InnerInteger::U8(value) => Ok(*value as u64),

827

2

            InnerInteger::I16(value) => {

828

2

                if *value >= 0 {

829

1

                    Ok(*value as u64)

830

                } else {

831

1

                    Err(Error::ImpreciseCastWouldLoseData)

832

833

834

1

            InnerInteger::U16(value) => Ok(*value as u64),

835

1

            InnerInteger::U32(value) => Ok(*value as u64),

836

2

            InnerInteger::I32(value) => {

837

2

                if *value >= 0 {

838

1

                    Ok(*value as u64)

839

                } else {

840

1

                    Err(Error::ImpreciseCastWouldLoseData)

841

842

843

10012

            InnerInteger::U64(value) => Ok(*value),

844

2

            InnerInteger::I64(value) => {

845

2

                if *value >= 0 {

846

1

                    Ok(*value as u64)

847

                } else {

848

1

                    Err(Error::ImpreciseCastWouldLoseData)

849

850

851

3

            InnerInteger::U128(_) | InnerInteger::I128(_) => Err(Error::ImpreciseCastWouldLoseData),

852

853

10062

854

855

    /// Returns the contained value as an u64, or an error if the value is unable to fit.

856

    #[allow(clippy::cast_sign_loss)]

857

    #[inline]

858

56

    pub const fn as_u128(&self) -> Result<u128, Error> {

859

56

        match &self.0 {

860

2

            InnerInteger::I8(value) => {

861

2

                if *value >= 0 {

862

1

                    Ok(*value as u128)

863

                } else {

864

1

                    Err(Error::ImpreciseCastWouldLoseData)

865

866

867

15

            InnerInteger::U8(value) => Ok(*value as u128),

868

2

            InnerInteger::I16(value) => {

869

2

                if *value >= 0 {

870

1

                    Ok(*value as u128)

871

                } else {

872

1

                    Err(Error::ImpreciseCastWouldLoseData)

873

874

875

5

            InnerInteger::U16(value) => Ok(*value as u128),

876

9

            InnerInteger::U32(value) => Ok(*value as u128),

877

2

            InnerInteger::I32(value) => {

878

2

                if *value >= 0 {

879

1

                    Ok(*value as u128)

880

                } else {

881

1

                    Err(Error::ImpreciseCastWouldLoseData)

882

883

884

9

            InnerInteger::U64(value) => Ok(*value as u128),

885

2

            InnerInteger::I64(value) => {

886

2

                if *value >= 0 {

887

1

                    Ok(*value as u128)

888

                } else {

889

1

                    Err(Error::ImpreciseCastWouldLoseData)

890

891

892

8

            InnerInteger::U128(value) => Ok(*value),

893

2

            InnerInteger::I128(value) => {

894

2

                if *value >= 0 {

895

1

                    Ok(*value as u128)

896

                } else {

897

1

                    Err(Error::ImpreciseCastWouldLoseData)

898

899

900

901

56

902

903

    /// Writes this value using the smallest form possible.

904

    #[inline]

905

17

    pub fn write_to<W: WriteBytesExt>(&self, writer: W) -> std::io::Result<usize> {

906

17

        match self.0 {

907

3

            InnerInteger::I8(value) => write_i8(writer, value),

908

2

            InnerInteger::I16(value) => write_i16(writer, value),

909

2

            InnerInteger::I32(value) => write_i32(writer, value),

910

2

            InnerInteger::I64(value) => write_i64(writer, value),

911

2

            InnerInteger::I128(value) => write_i128(writer, value),

912

2

            InnerInteger::U8(value) => write_u8(writer, value),

913

1

            InnerInteger::U16(value) => write_u16(writer, value),

914

1

            InnerInteger::U32(value) => write_u32(writer, value),

915

1

            InnerInteger::U64(value) => write_u64(writer, value),

916

1

            InnerInteger::U128(value) => write_u128(writer, value),

917

918

17

919

920

    /// Reads an integer based on the atom header (`kind` and `byte_len`).

921

    /// `byte_len` should be the argument from the atom header directly.

922

    #[inline]

923

20316

    pub fn read_from<R: ReadBytesExt>(

924

20316

        kind: Kind,

925

20316

        byte_len: usize,

926

20316

        reader: &mut R,

927

20316

    ) -> Result<Self, Error> {

928

20316

        match kind {

929

137

            Kind::Int => match byte_len {

930

68

                1 => Ok(InnerInteger::I8(reader.read_i8()?)),

931

15

                2 => Ok(InnerInteger::I16(reader.read_i16::<LittleEndian>()?)),

932

8

                3 => Ok(InnerInteger::I32(reader.read_i24::<LittleEndian>()?)),

933

15

                4 => Ok(InnerInteger::I32(reader.read_i32::<LittleEndian>()?)),

934

8

                6 => Ok(InnerInteger::I64(reader.read_i48::<LittleEndian>()?)),

935

13

                8 => Ok(InnerInteger::I64(reader.read_i64::<LittleEndian>()?)),

936

9

                16 => Ok(InnerInteger::I128(reader.read_i128::<LittleEndian>()?)),

937

1

                count => Err(Error::UnsupportedByteCount(kind, count)),

938

},

939

20178

            Kind::UInt => match byte_len {

940

154

                1 => Ok(InnerInteger::U8(reader.read_u8()?)),

941

9976

                2 => Ok(InnerInteger::U16(reader.read_u16::<LittleEndian>()?)),

942

9

                3 => Ok(InnerInteger::U32(reader.read_u24::<LittleEndian>()?)),

943

10

                4 => Ok(InnerInteger::U32(reader.read_u32::<LittleEndian>()?)),

944

4

                6 => Ok(InnerInteger::U64(reader.read_u48::<LittleEndian>()?)),

945

10016

                8 => Ok(InnerInteger::U64(reader.read_u64::<LittleEndian>()?)),

946

8

                16 => Ok(InnerInteger::U128(reader.read_u128::<LittleEndian>()?)),

947

1

                count => Err(Error::UnsupportedByteCount(kind, count)),

948

},

949

1

            _ => Err(Error::UnexpectedKind(kind, Kind::Int)),

950

951

20316

        .map(Integer)

952

20316

953

954

    /// Converts this integer to an f32, but only if it can be done without losing precision.

955

    #[allow(clippy::cast_precision_loss)]

956

    #[inline]

957

8

    pub fn as_f32(&self) -> Result<f32, Error> {

958

8

        let int = self.as_i32()?;

959

6

        if int < -(2_i32.pow(f32::MANTISSA_DIGITS)) || int >= 2_i32.pow(f32::MANTISSA_DIGITS) {

960

2

            Err(Error::ImpreciseCastWouldLoseData)

961

        } else {

962

4

            Ok(int as f32)

963

964

8

965

966

    /// Converts this integer to an f64, but only if it can be done without losing precision.

967

    #[allow(clippy::cast_precision_loss)]

968

    #[inline]

969

6

    pub fn as_f64(&self) -> Result<f64, Error> {

970

6

        let int = self.as_i64()?;

971

6

        if int < -(2_i64.pow(f64::MANTISSA_DIGITS)) || int >= 2_i64.pow(f64::MANTISSA_DIGITS) {

972

2

            Err(Error::ImpreciseCastWouldLoseData)

973

        } else {

974

4

            Ok(int as f64)

975

976

6

977

978

    /// Converts this integer to an f64, but only if it can be done without losing precision.

979

    #[allow(clippy::cast_precision_loss)]

980

    #[inline]

981

4

    pub fn as_float(&self) -> Result<Float, Error> {

982

4

        self.as_f32()

983

4

            .map(Float::from)

984

4

            .or_else(|_| self.as_f64().map(Float::from))

985

4

986

987

988

impl From<u8> for Integer {

989

    #[inline]

990

56

    fn from(value: u8) -> Self {

991

56

        Self(InnerInteger::U8(value))

992

56

993

994

995

macro_rules! impl_from_unsigned_integer {

996

    ($primitive:ty, $smaller_primitive:ty, $variant:ident) => {

997

        impl From<$primitive> for Integer {

998

            #[inline]

999

136

            fn from(value: $primitive) -> Self {

1000

136

                if let Ok(value) = <$smaller_primitive>::try_from(value) {

1001

37

                    Self::from(value as $smaller_primitive)

1002

                } else {

1003

99

                    Integer(InnerInteger::$variant(value))

1004

1005

136

1006

1007

};

1008

1009

1010

impl_from_unsigned_integer!(u16, u8, U16);

1011

impl_from_unsigned_integer!(u32, u16, U32);

1012

impl_from_unsigned_integer!(u64, u32, U64);

1013

impl_from_unsigned_integer!(u128, u64, U128);

1014

1015

impl From<i8> for Integer {

1016

    #[inline]

1017

59

    fn from(value: i8) -> Self {

1018

59

        Self(InnerInteger::I8(value))

1019

59

1020

1021

1022

macro_rules! impl_from_unsigned_integer {

1023

    ($primitive:ty, $smaller_primitive:ty, $smaller_unsigned_primitive:ty, $variant:ident) => {

1024

        impl From<$primitive> for Integer {

1025

            #[inline]

1026

218

            fn from(value: $primitive) -> Self {

1027

218

                if let Ok(value) = <$smaller_primitive>::try_from(value) {

1028

80

                    Self::from(value as $smaller_primitive)

1029

138

                } else if let Ok(value) = <$smaller_unsigned_primitive>::try_from(value) {

1030

6

                    Self::from(value as $smaller_unsigned_primitive)

1031

                } else {

1032

132

                    Integer(InnerInteger::$variant(value))

1033

1034

218

1035

1036

};

1037

1038

1039

impl_from_unsigned_integer!(i16, i8, u8, I16);

1040

impl_from_unsigned_integer!(i32, i16, u16, I32);

1041

impl_from_unsigned_integer!(i64, i32, u32, I64);

1042

impl_from_unsigned_integer!(i128, i64, u64, I128);

1043

1044

/// Reads an atom.

1045

#[allow(clippy::cast_possible_truncation)]

1046

#[inline]

1047

160771

pub fn read_atom<'de, R: Reader<'de>>(

1048

160771

    reader: &mut R,

1049

160771

    remaining_budget: &mut usize,

1050

160771

    scratch: &mut Vec<u8>,

1051

160771

) -> Result<Atom<'de>, Error> {

1052

160771

    let (kind, arg) = read_atom_header(reader)?;

1053

160771

    Ok(match kind {

1054

90311

        Kind::Sequence | Kind::Map | Kind::Symbol => Atom {

1055

90311

            kind,

1056

90311

            arg,

1057

90311

            nucleus: None,

1058

90311

},

1059

        Kind::Special => Atom {

1060

15081

            kind,

1061

15081

            arg,

1062

15081

            nucleus: match Special::try_from(arg)? {

1063

5034

                Special::None => None,

1064

20

                Special::Unit => Some(Nucleus::Unit),

1065

1

                Special::False => Some(Nucleus::Boolean(false)),

1066

3

                Special::True => Some(Nucleus::Boolean(true)),

1067

10018

                Special::Named => Some(Nucleus::Named),

1068

3

                Special::DynamicMap => Some(Nucleus::DynamicMap),

1069

2

                Special::DynamicEnd => Some(Nucleus::DynamicEnd),

1070

},

1071

},

1072

        Kind::Int | Kind::UInt => {

1073

20298

            let bytes = arg as usize + 1;

1074

20298

            update_budget(remaining_budget, in_memory_int_size(bytes))?;

1075

            Atom {

1076

20298

                kind,

1077

20298

                arg,

1078

20298

                nucleus: Some(Nucleus::Integer(Integer::read_from(kind, bytes, reader)?)),

1079

1080

1081

        Kind::Float => {

1082

43

            let bytes = arg as usize + 1;

1083

43

            update_budget(remaining_budget, in_memory_int_size(bytes))?;

1084

            Atom {

1085

42

                kind,

1086

42

                arg,

1087

42

                nucleus: Some(Nucleus::Float(Float::read_from(kind, bytes, reader)?)),

1088

1089

1090

        Kind::Bytes => {

1091

35038

            let bytes = arg as usize;

1092

35038

            update_budget(remaining_budget, bytes)?;

1093

35036

            let bytes = reader.buffered_read_bytes(bytes, scratch)?;

1094

35035

            Atom {

1095

35035

                kind,

1096

35035

                arg,

1097

35035

                nucleus: Some(Nucleus::Bytes(bytes)),

1098

35035

1099

1100

})

1101

160771

1102

1103

#[inline]

1104

20341

pub(crate) const fn in_memory_int_size(encoded_length: usize) -> usize {

1105

20341

    // Some integers are stored more compact than we can represent them in memory

1106

20341

    match encoded_length {

1107

17

        3 => 4,

1108

12

        6 => 8,

1109

20312

        other => other,

1110

1111

20341

1112

1113

#[inline]

1114

55379

pub(crate) fn update_budget(budget: &mut usize, read_amount: usize) -> Result<(), Error> {

1115

55379

    if let Some(remaining) = budget.checked_sub(read_amount) {

1116

55376

        *budget = remaining;

1117

55376

        Ok(())

1118

    } else {

1119

3

        Err(Error::TooManyBytesRead)

1120

1121

55379

1122

1123

/// An encoded [`Kind`], argument, and optional contained value.

1124

#[derive(Debug)]

1125

pub struct Atom<'de> {

1126

    /// The type of atom.

1127

    pub kind: Kind,

1128

    /// The argument contained in the atom header.

1129

    pub arg: u64,

1130

    /// The contained value, if any.

1131

    pub nucleus: Option<Nucleus<'de>>,

1132

1133

1134

/// A floating point number that can safely convert between other number types using compile-time evaluation when possible.

1135

#[derive(Debug, Copy, Clone, PartialEq)]

1136

pub struct Float(pub(crate) InnerFloat);

1137

1138

#[derive(Debug, Copy, Clone)]

1139

pub(crate) enum InnerFloat {

1140

    /// An f64 value.

1141

    F64(f64),

1142

    /// An f32 value.

1143

    F32(f32),

1144

1145

1146

impl From<f32> for Float {

1147

    #[inline]

1148

71

    fn from(value: f32) -> Self {

1149

71

        Self(InnerFloat::F32(value))

1150

71

1151

1152

1153

impl From<f64> for Float {

1154

    #[inline]

1155

24

    fn from(value: f64) -> Self {

1156

24

        Self(InnerFloat::F64(value))

1157

24

1158

1159

1160

impl PartialEq for InnerFloat {

1161

    #[inline]

1162

11

    fn eq(&self, other: &Self) -> bool {

1163

11

        match (self, other) {

1164

1

            (InnerFloat::F64(left), InnerFloat::F64(right)) => left == right,

1165

8

            (InnerFloat::F32(left), InnerFloat::F32(right)) => left == right,

1166

1

            (InnerFloat::F64(left), InnerFloat::F32(right)) => *left == f64::from(*right),

1167

1

            (InnerFloat::F32(left), InnerFloat::F64(right)) => f64::from(*left) == *right,

1168

1169

11

1170

1171

1172

impl Display for Float {

1173

2

    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

1174

2

        match &self.0 {

1175

1

            InnerFloat::F32(value) => Display::fmt(value, f),

1176

1

            InnerFloat::F64(value) => Display::fmt(value, f),

1177

1178

2

1179

1180

1181

impl Float {

1182

    /// Returns true if the value contained is zero.

1183

    #[must_use]

1184

    #[inline]

1185

6

    pub fn is_zero(&self) -> bool {

1186

6

        match self.0 {

1187

4

            InnerFloat::F32(value) => value.abs() <= f32::EPSILON,

1188

2

            InnerFloat::F64(value) => value.abs() <= f64::EPSILON,

1189

1190

6

1191

1192

    /// Returns this number as an f32, if it can be done without losing precision.

1193

    #[allow(clippy::float_cmp, clippy::cast_possible_truncation)]

1194

    #[inline]

1195

22

    pub fn as_f32(&self) -> Result<f32, Error> {

1196

22

        match self.0 {

1197

20

            InnerFloat::F32(value) => Ok(value),

1198

2

            InnerFloat::F64(value) => {

1199

2

                let converted = value as f32;

1200

2

                if f64::from(converted) == value {

1201

1

                    Ok(converted)

1202

                } else {

1203

1

                    Err(Error::ImpreciseCastWouldLoseData)

1204

1205

1206

1207

22

1208

1209

    /// Returns this number as an f64.

1210

    #[must_use]

1211

    #[inline]

1212

25

    pub const fn as_f64(&self) -> f64 {

1213

25

        match self.0 {

1214

5

            InnerFloat::F64(value) => value,

1215

20

            InnerFloat::F32(value) => value as f64,

1216

1217

25

1218

1219

    /// Returns this number as an [`Integer`], if the stored value has no fractional part.

1220

    #[allow(clippy::cast_possible_truncation)]

1221

    #[inline]

1222

20

    pub fn as_integer(&self) -> Result<Integer, Error> {

1223

20

        match self.0 {

1224

7

            InnerFloat::F64(value) => {

1225

7

                if value.fract().abs() < f64::EPSILON {

1226

                    // no fraction, safe to convert

1227

6

                    Ok(Integer::from(value as i64))

1228

                } else {

1229

1

                    Err(Error::ImpreciseCastWouldLoseData)

1230

1231

1232

13

            InnerFloat::F32(value) => {

1233

13

                if value.fract().abs() < f32::EPSILON {

1234

12

                    Ok(Integer::from(value as i32))

1235

                } else {

1236

1

                    Err(Error::ImpreciseCastWouldLoseData)

1237

1238

1239

1240

20

1241

1242

    /// Writes this value using the smallest form possible.

1243

    #[inline]

1244

2

    pub fn write_to<W: WriteBytesExt>(&self, writer: W) -> std::io::Result<usize> {

1245

2

        match self.0 {

1246

1

            InnerFloat::F64(float) => write_f64(writer, float),

1247

1

            InnerFloat::F32(float) => write_f32(writer, float),

1248

1249

2

1250

1251

    /// Reads a floating point number given the atom `kind` and `byte_len`.

1252

    /// `byte_len` should be the exact argument from the atom header.

1253

    #[inline]

1254

45

    pub fn read_from<R: ReadBytesExt>(

1255

45

        kind: Kind,

1256

45

        byte_len: usize,

1257

45

        reader: &mut R,

1258

45

    ) -> Result<Self, Error> {

1259

45

        if Kind::Float == kind {

1260

44

            match byte_len {

1261

34

                2 => Ok(Self::from(read_f16(reader)?)),

1262

5

                4 => Ok(Self::from(reader.read_f32::<LittleEndian>()?)),

1263

4

                8 => Ok(Self::from(reader.read_f64::<LittleEndian>()?)),

1264

1

                count => Err(Error::UnsupportedByteCount(Kind::Float, count)),

1265

1266

        } else {

1267

1

            Err(Error::UnexpectedKind(kind, Kind::Float))

1268

1269

45

1270

1271

1272

/// A value contained within an [`Atom`].

1273

#[derive(Debug)]

1274

pub enum Nucleus<'de> {

1275

    /// A boolean value.

1276

    Boolean(bool),

1277

    /// An integer value.

1278

    Integer(Integer),

1279

    /// A floating point value.

1280

    Float(Float),

1281

    /// A buffer of bytes.

1282

    Bytes(BufferedBytes<'de>),

1283

    /// A unit.

1284

    Unit,

1285

    /// A named value.

1286

    Named,

1287

    /// A marker denoting a map with unknown length is next in the file.

1288

    DynamicMap,

1289

    /// A marker denoting the end of a map with unknown length.

1290

    DynamicEnd,

1291

1292

1293

#[cfg(test)]

1294

mod tests {

1295

    use super::*;

1296

1297

    #[allow(clippy::cast_possible_truncation)]

1298

17

    fn test_roundtrip_integer(input: Integer, expected: Integer, expected_size: usize) {

1299

17

        let mut out = Vec::new();

1300

17

        assert_eq!(input.write_to(&mut out).unwrap(), expected_size);

1301

1302

17

            let mut reader = out.as_slice();

1303

17

            let (kind, bytes) = read_atom_header(&mut reader).unwrap();

1304

17

            assert_eq!(

1305

17

                Integer::read_from(kind, bytes as usize + 1, &mut reader).unwrap(),

1306

17

                expected

1307

17

);

1308

1309

17

1310

1311

    #[allow(clippy::cast_possible_truncation)]

1312

2

    fn test_roundtrip_float(input: Float, expected: Float, expected_size: usize) {

1313

2

        let mut out = Vec::new();

1314

2

        assert_eq!(input.write_to(&mut out).unwrap(), expected_size);

1315

1316

2

            let mut reader = out.as_slice();

1317

2

            let (kind, bytes) = read_atom_header(&mut reader).unwrap();

1318

2

            assert_eq!(

1319

2

                Float::read_from(kind, bytes as usize + 1, &mut reader).unwrap(),

1320

2

                expected

1321

2

);

1322

1323

2

1324

1325

    #[test]

1326

1

    fn header() {

1327

1

        let mut out = Vec::new();

1328

1

        write_header(&mut out, 1).unwrap();

1329

1

        let version = read_header(&mut out.as_slice()).unwrap();

1330

1

        assert_eq!(version, 1);

1331

1332

1

        out[0] = 0;

1333

1

        assert!(read_header(&mut out.as_slice()).is_err());

1334

1

1335

1336

    #[test]

1337

1

    fn atom_header_args() {

1338

1

        let mut out = Vec::new();

1339

65

        for arg in 1..=64 {

1340

64

            let arg = 2_u64.saturating_pow(arg);

1341

64

            write_atom_header(&mut out, Kind::Map, arg).unwrap();

1342

64

            println!("header: {out:?}");

1343

64

            let (kind, read_arg) = read_atom_header(&mut out.as_slice()).unwrap();

1344

64

            assert_eq!(kind, Kind::Map);

1345

64

            assert_eq!(read_arg, arg);

1346

64

            out.clear();

1347

1348

1

1349

1350

    #[test]

1351

1

    fn atom_kinds() {

1352

1

        assert_eq!(Kind::Special, Kind::from_u8(Kind::Special as u8).unwrap());

1353

1

        assert_eq!(Kind::Int, Kind::from_u8(Kind::Int as u8).unwrap());

1354

1

        assert_eq!(Kind::UInt, Kind::from_u8(Kind::UInt as u8).unwrap());

1355

1

        assert_eq!(Kind::Float, Kind::from_u8(Kind::Float as u8).unwrap());

1356

1

        assert_eq!(Kind::Sequence, Kind::from_u8(Kind::Sequence as u8).unwrap());

1357

1

        assert_eq!(Kind::Map, Kind::from_u8(Kind::Map as u8).unwrap());

1358

1

        assert_eq!(Kind::Symbol, Kind::from_u8(Kind::Symbol as u8).unwrap());

1359

1

        assert_eq!(Kind::Bytes, Kind::from_u8(Kind::Bytes as u8).unwrap());

1360

9

        for i in 8_u8..=15 {

1361

8

            assert!(Kind::from_u8(i).is_err());

1362

1363

1

1364

1365

    #[test]

1366

1

    fn zero() {

1367

1

        test_roundtrip_integer(Integer::from(0_u64), Integer(InnerInteger::U8(0)), 2);

1368

1

        test_roundtrip_integer(Integer::from(0_i64), Integer(InnerInteger::I8(0)), 2);

1369

1

        test_roundtrip_float(Float::from(0_f32), Float(InnerFloat::F32(0.)), 3);

1370

1

        test_roundtrip_float(Float::from(0_f64), Float(InnerFloat::F32(0.)), 3);

1371

1

1372

1373

    #[test]

1374

1

    fn u8_max() {

1375

1

        test_roundtrip_integer(

1376

1

            Integer::from(u64::from(u8::MAX)),

1377

1

            Integer(InnerInteger::U8(u8::MAX)),

1378

1

2,

1379

1

);

1380

1

1381

1382

    #[test]

1383

1

    fn i8_max() {

1384

1

        test_roundtrip_integer(

1385

1

            Integer::from(i64::from(i8::MAX)),

1386

1

            Integer(InnerInteger::I8(i8::MAX)),

1387

1

2,

1388

1

);

1389

1

1390

1391

    #[test]

1392

1

    fn i8_min() {

1393

1

        test_roundtrip_integer(

1394

1

            Integer::from(i64::from(i8::MIN)),

1395

1

            Integer(InnerInteger::I8(i8::MIN)),

1396

1

2,

1397

1

);

1398

1

1399

1400

    #[test]

1401

1

    fn u16_max() {

1402

1

        test_roundtrip_integer(

1403

1

            Integer::from(u64::from(u16::MAX)),

1404

1

            Integer(InnerInteger::U16(u16::MAX)),

1405

1

3,

1406

1

);

1407

1

1408

1409

    #[test]

1410

1

    fn i16_max() {

1411

1

        test_roundtrip_integer(

1412

1

            Integer::from(i64::from(i16::MAX)),

1413

1

            Integer(InnerInteger::I16(i16::MAX)),

1414

1

3,

1415

1

);

1416

1

1417

1418

    #[test]

1419

1

    fn i16_min() {

1420

1

        test_roundtrip_integer(

1421

1

            Integer::from(i64::from(i16::MIN)),

1422

1

            Integer(InnerInteger::I16(i16::MIN)),

1423

1

3,

1424

1

);

1425

1

1426

1427

    #[test]

1428

1

    fn u32_max() {

1429

1

        test_roundtrip_integer(

1430

1

            Integer::from(u64::from(u32::MAX)),

1431

1

            Integer(InnerInteger::U32(u32::MAX)),

1432

1

5,

1433

1

);

1434

1

1435

1436

    #[test]

1437

1

    fn i32_max() {

1438

1

        test_roundtrip_integer(

1439

1

            Integer::from(i64::from(i32::MAX)),

1440

1

            Integer(InnerInteger::I32(i32::MAX)),

1441

1

5,

1442

1

);

1443

1

1444

1445

    #[test]

1446

1

    fn i32_min() {

1447

1

        test_roundtrip_integer(

1448

1

            Integer::from(i64::from(i32::MIN)),

1449

1

            Integer(InnerInteger::I32(i32::MIN)),

1450

1

5,

1451

1

);

1452

1

1453

1454

    #[test]

1455

1

    fn u64_max() {

1456

1

        test_roundtrip_integer(

1457

1

            Integer::from(u64::MAX),

1458

1

            Integer(InnerInteger::U64(u64::MAX)),

1459

1

9,

1460

1

);

1461

1

1462

1463

    #[test]

1464

1

    fn i64_max() {

1465

1

        test_roundtrip_integer(

1466

1

            Integer::from(i64::MAX),

1467

1

            Integer(InnerInteger::I64(i64::MAX)),

1468

1

9,

1469

1

);

1470

1

1471

1472

    #[test]

1473

1

    fn i64_min() {

1474

1

        test_roundtrip_integer(

1475

1

            Integer::from(i64::MIN),

1476

1

            Integer(InnerInteger::I64(i64::MIN)),

1477

1

9,

1478

1

);

1479

1

1480

1481

    #[test]

1482

1

    fn u128_max() {

1483

1

        test_roundtrip_integer(

1484

1

            Integer::from(u128::MAX),

1485

1

            Integer(InnerInteger::U128(u128::MAX)),

1486

1

17,

1487

1

);

1488

1

1489

1490

    #[test]

1491

1

    fn i128_max() {

1492

1

        test_roundtrip_integer(

1493

1

            Integer::from(i128::MAX),

1494

1

            Integer(InnerInteger::I128(i128::MAX)),

1495

1

17,

1496

1

);

1497

1

1498

1499

    #[test]

1500

1

    fn i128_min() {

1501

1

        test_roundtrip_integer(

1502

1

            Integer::from(i128::MIN),

1503

1

            Integer(InnerInteger::I128(i128::MIN)),

1504

1

17,

1505

1

);

1506

1

1507

1508

    #[test]

1509

1

    fn integer_is_zero() {

1510

1

        assert!(Integer::from(0_i128).is_zero());

1511

1

        assert!(!Integer::from(i8::MAX).is_zero());

1512

1

        assert!(!Integer::from(i16::MAX).is_zero());

1513

1

        assert!(!Integer::from(i32::MAX).is_zero());

1514

1

        assert!(!Integer::from(i64::MAX).is_zero());

1515

1

        assert!(!Integer::from(i128::MAX).is_zero());

1516

1517

1

        assert!(Integer::from(0_u128).is_zero());

1518

1

        assert!(!Integer::from(u8::MAX).is_zero());

1519

1

        assert!(!Integer::from(u16::MAX).is_zero());

1520

1

        assert!(!Integer::from(u32::MAX).is_zero());

1521

1

        assert!(!Integer::from(u64::MAX).is_zero());

1522

1

        assert!(!Integer::from(u128::MAX).is_zero());

1523

1

1524

1525

    macro_rules! test_conversion_succeeds {

1526

        ($host:ty, $value:expr, $method:ident) => {{

1527

            assert!(<$host>::from($value).$method().is_ok())

1528

}};

1529

1530

    macro_rules! test_conversion_fails {

1531

        ($host:ty, $value:expr, $method:ident) => {{

1532

            assert!(matches!(

1533

                <$host>::from($value).$method(),

1534

                Err(Error::ImpreciseCastWouldLoseData)

1535

))

1536

}};

1537

1538

1539

    #[test]

1540

    #[allow(clippy::cognitive_complexity, clippy::too_many_lines)]

1541

1

    fn integer_casts() {

1542

1

        macro_rules! test_negative_fails {

1543

1

            ($method:ident) => {{

1544

1

                test_conversion_fails!(Integer, i8::MIN, $method);

1545

1

                test_conversion_fails!(Integer, i16::MIN, $method);

1546

1

                test_conversion_fails!(Integer, i32::MIN, $method);

1547

1

                test_conversion_fails!(Integer, i64::MIN, $method);

1548

1

                test_conversion_fails!(Integer, i128::MIN, $method);

1549

1

}};

1550

1

1551

1

1552

1

        // ### i8 ###

1553

1

        // unsigned max -> i8

1554

1

        test_conversion_fails!(Integer, u8::MAX, as_i8);

1555

1

        test_conversion_fails!(Integer, u16::MAX, as_i8);

1556

1

        test_conversion_fails!(Integer, u32::MAX, as_i8);

1557

1

        test_conversion_fails!(Integer, u64::MAX, as_i8);

1558

1

        test_conversion_fails!(Integer, u128::MAX, as_i8);

1559

1560

        // signed max -> i8

1561

1

        test_conversion_succeeds!(Integer, i8::MAX, as_i8);

1562

1

        test_conversion_fails!(Integer, i16::MAX, as_i8);

1563

1

        test_conversion_fails!(Integer, i32::MAX, as_i8);

1564

1

        test_conversion_fails!(Integer, i64::MAX, as_i8);

1565

1

        test_conversion_fails!(Integer, i128::MAX, as_i8);

1566

1567

        // signed max as unsigned -> i8

1568

1

        test_conversion_succeeds!(Integer, i8::MAX as u8, as_i8);

1569

1

        test_conversion_fails!(Integer, i16::MAX as u16, as_i8);

1570

1

        test_conversion_fails!(Integer, i32::MAX as u32, as_i8);

1571

1

        test_conversion_fails!(Integer, i64::MAX as u64, as_i8);

1572

1

        test_conversion_fails!(Integer, i128::MAX as u128, as_i8);

1573

1574

        // signed min -> i8

1575

1

        test_conversion_succeeds!(Integer, i8::MIN, as_i8);

1576

1

        test_conversion_fails!(Integer, i16::MIN, as_i8);

1577

1

        test_conversion_fails!(Integer, i32::MIN, as_i8);

1578

1

        test_conversion_fails!(Integer, i64::MIN, as_i8);

1579

1

        test_conversion_fails!(Integer, i128::MIN, as_i8);

1580

1581

        // ### i16 ###

1582

        // unsigned max -> i16

1583

1

        test_conversion_succeeds!(Integer, u8::MAX, as_i16);

1584

1

        test_conversion_fails!(Integer, u16::MAX, as_i16);

1585

1

        test_conversion_fails!(Integer, u32::MAX, as_i16);

1586

1

        test_conversion_fails!(Integer, u64::MAX, as_i16);

1587

1

        test_conversion_fails!(Integer, u128::MAX, as_i16);

1588

1589

        // signed max -> i16

1590

1

        test_conversion_succeeds!(Integer, i8::MAX, as_i16);

1591

1

        test_conversion_succeeds!(Integer, i16::MAX, as_i16);

1592

1

        test_conversion_fails!(Integer, i32::MAX, as_i16);

1593

1

        test_conversion_fails!(Integer, i64::MAX, as_i16);

1594

1

        test_conversion_fails!(Integer, i128::MAX, as_i16);

1595

1596

        // signed max as unsigned -> i16

1597

1

        test_conversion_succeeds!(Integer, i8::MAX as u8, as_i16);

1598

1

        test_conversion_succeeds!(Integer, i16::MAX as u16, as_i16);

1599

1

        test_conversion_fails!(Integer, i32::MAX as u32, as_i16);

1600

1

        test_conversion_fails!(Integer, i64::MAX as u64, as_i16);

1601

1

        test_conversion_fails!(Integer, i128::MAX as u128, as_i16);

1602

1603

        // signed min -> i16

1604

1

        test_conversion_succeeds!(Integer, i8::MIN, as_i16);

1605

1

        test_conversion_succeeds!(Integer, i16::MIN, as_i16);

1606

1

        test_conversion_fails!(Integer, i32::MIN, as_i16);

1607

1

        test_conversion_fails!(Integer, i64::MIN, as_i16);

1608

1

        test_conversion_fails!(Integer, i128::MIN, as_i16);

1609

1610

        // ### i32 ###

1611

        // unsigned max -> i32

1612

1

        test_conversion_succeeds!(Integer, u8::MAX, as_i32);

1613

1

        test_conversion_succeeds!(Integer, u16::MAX, as_i32);

1614

1

        test_conversion_fails!(Integer, u32::MAX, as_i32);

1615

1

        test_conversion_fails!(Integer, u64::MAX, as_i32);

1616

1

        test_conversion_fails!(Integer, u128::MAX, as_i32);

1617

1618

        // signed max -> i32

1619

1

        test_conversion_succeeds!(Integer, i8::MAX, as_i32);

1620

1

        test_conversion_succeeds!(Integer, i16::MAX, as_i32);

1621

1

        test_conversion_succeeds!(Integer, i32::MAX, as_i32);

1622

1

        test_conversion_fails!(Integer, i64::MAX, as_i32);

1623

1

        test_conversion_fails!(Integer, i128::MAX, as_i32);

1624

1625

        // signed max as unsigned -> i32

1626

1

        test_conversion_succeeds!(Integer, i8::MAX as u8, as_i32);

1627

1

        test_conversion_succeeds!(Integer, i16::MAX as u16, as_i32);

1628

1

        test_conversion_succeeds!(Integer, i32::MAX as u32, as_i32);

1629

1

        test_conversion_fails!(Integer, i64::MAX as u64, as_i32);

1630

1

        test_conversion_fails!(Integer, i128::MAX as u128, as_i32);

1631

1632

        // signed min -> i32

1633

1

        test_conversion_succeeds!(Integer, i8::MIN, as_i32);

1634

1

        test_conversion_succeeds!(Integer, i16::MIN, as_i32);

1635

1

        test_conversion_succeeds!(Integer, i32::MIN, as_i32);

1636

1

        test_conversion_fails!(Integer, i64::MIN, as_i32);

1637

1

        test_conversion_fails!(Integer, i128::MIN, as_i32);

1638

1639

        // ### i64 ###

1640

        // unsigned max -> i64

1641

1

        test_conversion_succeeds!(Integer, u8::MAX, as_i64);

1642

1

        test_conversion_succeeds!(Integer, u16::MAX, as_i64);

1643

1

        test_conversion_succeeds!(Integer, u32::MAX, as_i64);

1644

1

        test_conversion_fails!(Integer, u64::MAX, as_i64);

1645

1

        test_conversion_fails!(Integer, u128::MAX, as_i64);

1646

1647

        // signed max -> i64

1648

1

        test_conversion_succeeds!(Integer, i8::MAX, as_i64);

1649

1

        test_conversion_succeeds!(Integer, i16::MAX, as_i64);

1650

1

        test_conversion_succeeds!(Integer, i32::MAX, as_i64);

1651

1

        test_conversion_succeeds!(Integer, i64::MAX, as_i64);

1652

1

        test_conversion_fails!(Integer, i128::MAX, as_i64);

1653

1654

        // signed max as unsigned -> i64

1655

1

        test_conversion_succeeds!(Integer, i8::MAX as u8, as_i64);

1656

1

        test_conversion_succeeds!(Integer, i16::MAX as u16, as_i64);

1657

1

        test_conversion_succeeds!(Integer, i32::MAX as u32, as_i64);

1658

1

        test_conversion_succeeds!(Integer, i64::MAX as u64, as_i64);

1659

1

        test_conversion_fails!(Integer, i128::MAX as u128, as_i64);

1660

1661

        // signed min -> i64

1662

1

        test_conversion_succeeds!(Integer, i8::MIN, as_i64);

1663

1

        test_conversion_succeeds!(Integer, i16::MIN, as_i64);

1664

1

        test_conversion_succeeds!(Integer, i32::MIN, as_i64);

1665

1

        test_conversion_succeeds!(Integer, i64::MIN, as_i64);

1666

1

        test_conversion_fails!(Integer, i128::MIN, as_i64);

1667

1668

        // ### i128 ###

1669

        // unsigned max -> i128

1670

1

        test_conversion_succeeds!(Integer, u8::MAX, as_i128);

1671

1

        test_conversion_succeeds!(Integer, u16::MAX, as_i128);

1672

1

        test_conversion_succeeds!(Integer, u32::MAX, as_i128);

1673

1

        test_conversion_succeeds!(Integer, u64::MAX, as_i128);

1674

1

        test_conversion_fails!(Integer, u128::MAX, as_i128);

1675

1676

        // signed max -> i128

1677

1

        test_conversion_succeeds!(Integer, i8::MAX, as_i128);

1678

1

        test_conversion_succeeds!(Integer, i16::MAX, as_i128);

1679

1

        test_conversion_succeeds!(Integer, i32::MAX, as_i128);

1680

1

        test_conversion_succeeds!(Integer, i64::MAX, as_i128);

1681

1

        test_conversion_succeeds!(Integer, i128::MAX, as_i128);

1682

1683

        // signed max as unsigned -> i128

1684

1

        test_conversion_succeeds!(Integer, i8::MAX as u8, as_i128);

1685

1

        test_conversion_succeeds!(Integer, i16::MAX as u16, as_i128);

1686

1

        test_conversion_succeeds!(Integer, i32::MAX as u32, as_i128);

1687

1

        test_conversion_succeeds!(Integer, i64::MAX as u64, as_i128);

1688

1

        test_conversion_succeeds!(Integer, i128::MAX as u128, as_i128);

1689

1690

        // signed min -> i128

1691

1

        test_conversion_succeeds!(Integer, i8::MIN, as_i128);

1692

1

        test_conversion_succeeds!(Integer, i16::MIN, as_i128);

1693

1

        test_conversion_succeeds!(Integer, i32::MIN, as_i128);

1694

1

        test_conversion_succeeds!(Integer, i64::MIN, as_i128);

1695

1

        test_conversion_succeeds!(Integer, i128::MIN, as_i128);

1696

1697

        // ### u8 ###

1698

        // unsigned max -> u8

1699

1

        test_conversion_succeeds!(Integer, u8::MAX, as_u8);

1700

1

        test_conversion_fails!(Integer, u16::MAX, as_u8);

1701

1

        test_conversion_fails!(Integer, u32::MAX, as_u8);

1702

1

        test_conversion_fails!(Integer, u64::MAX, as_u8);

1703

1

        test_conversion_fails!(Integer, u128::MAX, as_u8);

1704

1705

        // signed max -> u8

1706

1

        test_conversion_succeeds!(Integer, i8::MAX, as_u8);

1707

1

        test_conversion_fails!(Integer, i16::MAX, as_u8);

1708

1

        test_conversion_fails!(Integer, i32::MAX, as_u8);

1709

1

        test_conversion_fails!(Integer, i64::MAX, as_u8);

1710

1

        test_conversion_fails!(Integer, i128::MAX, as_u8);

1711

1712

        // signed min -> u8

1713

1

        test_negative_fails!(as_u8);

1714

1715

        // ### u16 ###

1716

        // unsigned max -> u16

1717

1

        test_conversion_succeeds!(Integer, u8::MAX, as_u16);

1718

1

        test_conversion_succeeds!(Integer, u16::MAX, as_u16);

1719

1

        test_conversion_fails!(Integer, u32::MAX, as_u16);

1720

1

        test_conversion_fails!(Integer, u64::MAX, as_u16);

1721

1

        test_conversion_fails!(Integer, u128::MAX, as_u16);

1722

1723

        // signed max -> u16

1724

1

        test_conversion_succeeds!(Integer, i8::MAX, as_u16);

1725

1

        test_conversion_succeeds!(Integer, i16::MAX, as_u16);

1726

1

        test_conversion_fails!(Integer, i32::MAX, as_u16);

1727

1

        test_conversion_fails!(Integer, i64::MAX, as_u16);

1728

1

        test_conversion_fails!(Integer, i128::MAX, as_u16);

1729

1730

        // signed min -> u16

1731

1

        test_negative_fails!(as_u16);

1732

1733

        // ### u32 ###

1734

        // unsigned max -> u32

1735

1

        test_conversion_succeeds!(Integer, u8::MAX, as_u32);

1736

1

        test_conversion_succeeds!(Integer, u16::MAX, as_u32);

1737

1

        test_conversion_succeeds!(Integer, u32::MAX, as_u32);

1738

1

        test_conversion_fails!(Integer, u64::MAX, as_u32);

1739

1

        test_conversion_fails!(Integer, u128::MAX, as_u32);

1740

1741

        // signed max -> u32

1742

1

        test_conversion_succeeds!(Integer, i8::MAX, as_u32);

1743

1

        test_conversion_succeeds!(Integer, i16::MAX, as_u32);

1744

1

        test_conversion_succeeds!(Integer, i32::MAX, as_u32);

1745

1

        test_conversion_fails!(Integer, i64::MAX, as_u32);

1746

1

        test_conversion_fails!(Integer, i128::MAX, as_u32);

1747

1748

        // signed min -> u32

1749

1

        test_negative_fails!(as_u32);

1750

1751

        // ### u64 ###

1752

        // unsigned max -> u64

1753

1

        test_conversion_succeeds!(Integer, u8::MAX, as_u64);

1754

1

        test_conversion_succeeds!(Integer, u16::MAX, as_u64);

1755

1

        test_conversion_succeeds!(Integer, u32::MAX, as_u64);

1756

1

        test_conversion_succeeds!(Integer, u64::MAX, as_u64);

1757

1

        test_conversion_fails!(Integer, u128::MAX, as_u64);

1758

1759

        // signed max -> u64

1760

1

        test_conversion_succeeds!(Integer, i8::MAX, as_u64);

1761

1

        test_conversion_succeeds!(Integer, i16::MAX, as_u64);

1762

1

        test_conversion_succeeds!(Integer, i32::MAX, as_u64);

1763

1

        test_conversion_succeeds!(Integer, i64::MAX, as_u64);

1764

1

        test_conversion_fails!(Integer, i128::MAX, as_u64);

1765

1766

        // signed min -> u64

1767

1

        test_negative_fails!(as_u64);

1768

1769

        // ### u128 ###

1770

        // unsigned max -> u128

1771

1

        test_conversion_succeeds!(Integer, u8::MAX, as_u128);

1772

1

        test_conversion_succeeds!(Integer, u16::MAX, as_u128);

1773

1

        test_conversion_succeeds!(Integer, u32::MAX, as_u128);

1774

1

        test_conversion_succeeds!(Integer, u64::MAX, as_u128);

1775

1

        test_conversion_succeeds!(Integer, u128::MAX, as_u128);

1776

1777

        // signed max -> u128

1778

1

        test_conversion_succeeds!(Integer, i8::MAX, as_u128);

1779

1

        test_conversion_succeeds!(Integer, i16::MAX, as_u128);

1780

1

        test_conversion_succeeds!(Integer, i32::MAX, as_u128);

1781

1

        test_conversion_succeeds!(Integer, i64::MAX, as_u128);

1782

1

        test_conversion_succeeds!(Integer, i128::MAX, as_u128);

1783

1784

        // signed min -> u128

1785

1

        test_negative_fails!(as_u128);

1786

1

1787

1788

    #[test]

1789

1

    fn float_as_integer() {

1790

1

        test_conversion_succeeds!(Float, 1_f32, as_integer);

1791

1

        test_conversion_succeeds!(Float, 1_f64, as_integer);

1792

1

        test_conversion_fails!(Float, 1.1_f32, as_integer);

1793

1

        test_conversion_fails!(Float, 1.1_f64, as_integer);

1794

1

1795

1796

    #[test]

1797

1

    fn integer_as_float() {

1798

1

        test_conversion_succeeds!(Integer, -(2_i32.pow(f32::MANTISSA_DIGITS)), as_f32);

1799

1

        test_conversion_succeeds!(Integer, 2_i32.pow(f32::MANTISSA_DIGITS) - 1, as_f32);

1800

1

        test_conversion_fails!(Integer, i32::MIN, as_f32);

1801

1

        test_conversion_fails!(Integer, i32::MAX, as_f32);

1802

1

        test_conversion_succeeds!(Integer, -(2_i64.pow(f64::MANTISSA_DIGITS)), as_f64);

1803

1

        test_conversion_succeeds!(Integer, 2_i64.pow(f64::MANTISSA_DIGITS) - 1, as_f64);

1804

1

        test_conversion_fails!(Integer, i64::MIN, as_f64);

1805

1

        test_conversion_fails!(Integer, i64::MAX, as_f64);

1806

1

1807

1808

    #[test]

1809

1

    fn float_partial_eqs() {

1810

1

        assert_eq!(Float::from(0_f32), Float::from(0_f32));

1811

1

        assert_eq!(Float::from(0_f32), Float::from(0_f64));

1812

1

        assert_eq!(Float::from(0_f64), Float::from(0_f32));

1813

1

1814

1815

    #[test]

1816

1

    fn float_is_zero() {

1817

1

        assert!(Float::from(0_f32).is_zero());

1818

1

        assert!(!Float::from(1_f32).is_zero());

1819

1

        assert!(Float::from(0_f64).is_zero());

1820

1

        assert!(!Float::from(1_f64).is_zero());

1821

1

1822

1823

    #[test]

1824

1

    fn integer_display() {

1825

1

        assert_eq!(Integer::from(i8::MAX).to_string(), "127");

1826

1

        assert_eq!(Integer::from(i16::MAX).to_string(), "32767");

1827

1

        assert_eq!(Integer::from(i32::MAX).to_string(), "2147483647");

1828

1

        assert_eq!(Integer::from(i64::MAX).to_string(), "9223372036854775807");

1829

1

        assert_eq!(

1830

1

            Integer::from(i128::MAX).to_string(),

1831

1

            "170141183460469231731687303715884105727"

1832

1

);

1833

1

        assert_eq!(Integer::from(u8::MAX).to_string(), "255");

1834

1

        assert_eq!(Integer::from(u16::MAX).to_string(), "65535");

1835

1

        assert_eq!(Integer::from(u32::MAX).to_string(), "4294967295");

1836

1

        assert_eq!(Integer::from(u64::MAX).to_string(), "18446744073709551615");

1837

1

        assert_eq!(

1838

1

            Integer::from(u128::MAX).to_string(),

1839

1

            "340282366920938463463374607431768211455"

1840

1

);

1841

1

1842