Struct AggressiveMinimize

pub struct AggressiveMinimize;

Encode a given numeric value by aggressively minimising its format.

If the float is finite and its fractional part is zero, it first tries to encode it as an integer. If this conversion fails, it falls back to encoding the value as a float.

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, AggressiveMinimize};

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

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

Floating point without fractional part is encoded as int

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

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

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

f64 is encoded in the same way as f32.

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

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

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

Trait Implementations

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

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>>