mkv-element 0.4.0

{{ doc }}
#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
pub struct {{ name }}(pub f64);
impl std::ops::Deref for {{ name }} {
    type Target = f64;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl Element for {{ name }} {
    const ID: VInt64 = VInt64::from_encoded({{ id }});
    fn decode_body<B: Buf>(buf: &mut B) -> crate::Result<Self> {
        match buf.remaining() {
{% if has_default %}
            0 => Ok(Self(hexf::hexf64!("{{ default_value }}"))),
{% else %}
            0 => Ok(Self(0.0)),
{% endif %}
            4 => {
                let mut value = [0u8; 4];
                value.copy_from_slice(&buf.chunk()[..4]);
                buf.advance(4);
                Ok(Self(f32::from_be_bytes(value) as f64))
            }
            8 => {
                let mut value = [0u8; 8];
                value.copy_from_slice(&buf.chunk()[..8]);
                buf.advance(8);
                Ok(Self(f64::from_be_bytes(value)))
            }
            _ => Err(crate::Error::UnderDecode(Self::ID)),
        }
    }
    fn encode_body<B: BufMut>(&self, buf: &mut B) -> crate::Result<()> {
        fn can_represent_as_f32(value: f64) -> bool {
            if value.is_infinite() || value.is_nan() {
                return false;
            }
            if value.abs() > f32::MAX as f64 || (value != 0.0 && value.abs() < f32::MIN_POSITIVE as f64) {
                return false;
            }
            let f32_value = value as f32;
            f32_value as f64 == value
        }
        if can_represent_as_f32(self.0) {
            buf.put_slice(&(self.0 as f32).to_be_bytes());
            Ok(())
        } else {
            buf.put_slice(&self.0.to_be_bytes());
            Ok(())
        }
    }
{% if has_default %}
    const HAS_DEFAULT_VALUE: bool = true;
{% endif %}
}
impl Default for {{ name }} {
    fn default() -> Self {
{% if has_default %}
        Self(hexf::hexf64!("{{ default_value }}"))
{% else %}
        Self(0.0)
{% endif %}
    }
}