Struct LosslessMinimize

pub struct LosslessMinimize;

Encode a given numeric value in a lossless minimised format without changing its original format.

This encoder minimises the encoded size of a numeric value without any loss of information or change in its inherent type. For integer types, it encodes the value using the smallest integer format that can exactly represent the original value. For floating-point types, it encodes the value using the smallest floating-point format that preserves its precision.

Examples

If there is no loss in a smaller format, it is encoded with that value

use serde::Serialize;
use messagepack_core::SliceWriter;
use messagepack_serde::ser::{Serializer, LosslessMinimize};

let mut buf = [0_u8;1];
let mut writer = SliceWriter::from_slice(&mut buf);
let mut ser = Serializer::new(&mut writer, LosslessMinimize);
1_u16.serialize(&mut ser).unwrap();

let expected = [1_u8]; // 1 encoded in `positive fixint`
assert_eq!(buf,expected);

Floating point is encoded as floating point type

use serde::Serialize;
use messagepack_core::SliceWriter;
use messagepack_serde::ser::{Serializer, LosslessMinimize};

let mut buf = [0_u8;5];
let mut writer = SliceWriter::from_slice(&mut buf);
let mut ser = Serializer::new(&mut writer, LosslessMinimize);
1.0_f32.serialize(&mut ser).unwrap();

let expected = [0xca,0x3f,0x80,0x00,0x00]; // 1.0 encoded in `float 32`
assert_eq!(buf,expected);

If floating point can be encoded without loss, it will be encoded in a smaller format

use serde::Serialize;
use messagepack_core::SliceWriter;
use messagepack_serde::ser::{Serializer, LosslessMinimize};

let mut buf = [0_u8;5];
let mut writer = SliceWriter::from_slice(&mut buf);
let mut ser = Serializer::new(&mut writer, LosslessMinimize);
1.0_f64.serialize(&mut ser).unwrap();

let expected = [0xca,0x3f,0x80,0x00,0x00]; // 1.0 encoded in `float 32`
assert_eq!(buf,expected);

0.1 is encoded as float 64 due to loss when converted to `f32

use serde::Serialize;
use messagepack_core::SliceWriter;
use messagepack_serde::ser::{Serializer, LosslessMinimize};

let mut buf = [0_u8;9];
let mut writer = SliceWriter::from_slice(&mut buf);
let mut ser = Serializer::new(&mut writer, LosslessMinimize);
0.1_f64.serialize(&mut ser).unwrap();

let expected = [0xcb,0x3f,0xb9,0x99,0x99,0x99,0x99,0x99,0x9a]; // 0.1 encoded in `float 64`
assert_eq!(buf,expected);

Trait Implementations

impl<W: IoWrite> NumEncoder<W> for LosslessMinimize

fn encode_i8( v: i8, writer: &mut W, ) -> Result<usize, Error<<W as IoWrite>::Error>>

fn encode_i16( v: i16, writer: &mut W, ) -> Result<usize, Error<<W as IoWrite>::Error>>

fn encode_i32( v: i32, writer: &mut W, ) -> Result<usize, Error<<W as IoWrite>::Error>>

fn encode_i64( v: i64, writer: &mut W, ) -> Result<usize, Error<<W as IoWrite>::Error>>

fn encode_i128( v: i128, writer: &mut W, ) -> Result<usize, Error<<W as IoWrite>::Error>>

fn encode_u8( v: u8, writer: &mut W, ) -> Result<usize, Error<<W as IoWrite>::Error>>

fn encode_u16( v: u16, writer: &mut W, ) -> Result<usize, Error<<W as IoWrite>::Error>>

fn encode_u32( v: u32, writer: &mut W, ) -> Result<usize, Error<<W as IoWrite>::Error>>

fn encode_u64( v: u64, writer: &mut W, ) -> Result<usize, Error<<W as IoWrite>::Error>>

fn encode_u128( v: u128, writer: &mut W, ) -> Result<usize, Error<<W as IoWrite>::Error>>

fn encode_f32( v: f32, writer: &mut W, ) -> Result<usize, Error<<W as IoWrite>::Error>>

fn encode_f64( v: f64, writer: &mut W, ) -> Result<usize, Error<<W as IoWrite>::Error>>