gst/format: implement GenericSignedFormattedValue

The `Signed` version for `GenericFormattedValue` was implemented as
`Signed<GenericFormattedValue>`, which failed to represent properly
the `None` variants when applicable and could represent inconsistent
`Signed` variant combined with `GenericFormattedValue` formats which
are internaly represented as signed integers.
This commit is contained in:
François Laignel 2022-10-08 23:27:45 +02:00
parent 04b6710f84
commit 274a5bd020
2 changed files with 208 additions and 17 deletions

View file

@ -72,7 +72,7 @@ impl fmt::Display for GenericFormattedValue {
}
impl Displayable for GenericFormattedValue {
type DisplayImpl = GenericFormattedValue;
type DisplayImpl = Self;
fn display(self) -> Self {
self
}
@ -186,25 +186,37 @@ impl FormattedValueNoneBuilder for GenericFormattedValue {
}
impl UnsignedIntoSigned for GenericFormattedValue {
type Signed = Signed<GenericFormattedValue>;
type Signed = GenericSignedFormattedValue;
#[track_caller]
fn into_positive(self) -> Self::Signed {
use Signed::Positive;
match self {
GenericFormattedValue::Undefined(_) => {
Self::Undefined(_) => {
unimplemented!("`GenericFormattedValue::Undefined` is already signed")
}
unsigned_inner => Signed::Positive(unsigned_inner),
Self::Default(val) => Self::Signed::Default(val.map(Positive)),
Self::Bytes(val) => Self::Signed::Bytes(val.map(Positive)),
Self::Time(val) => Self::Signed::Time(val.map(Positive)),
Self::Buffers(val) => Self::Signed::Buffers(val.map(Positive)),
Self::Percent(val) => Self::Signed::Percent(val.map(Positive)),
Self::Other(format, val) => Self::Signed::Other(format, val.map(Positive)),
}
}
#[track_caller]
fn into_negative(self) -> Self::Signed {
use Signed::Negative;
match self {
GenericFormattedValue::Undefined(_) => {
Self::Undefined(_) => {
unimplemented!("`GenericFormattedValue::Undefined` is already signed")
}
unsigned_inner => Signed::Negative(unsigned_inner),
Self::Default(val) => Self::Signed::Default(val.map(Negative)),
Self::Bytes(val) => Self::Signed::Bytes(val.map(Negative)),
Self::Time(val) => Self::Signed::Time(val.map(Negative)),
Self::Buffers(val) => Self::Signed::Buffers(val.map(Negative)),
Self::Percent(val) => Self::Signed::Percent(val.map(Negative)),
Self::Other(format, val) => Self::Signed::Other(format, val.map(Negative)),
}
}
}
@ -233,6 +245,136 @@ impl CompatibleFormattedValue<GenericFormattedValue> for GenericFormattedValue {
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum GenericSignedFormattedValue {
Default(Option<Signed<Default>>),
Bytes(Option<Signed<Bytes>>),
Time(Option<Signed<ClockTime>>),
Buffers(Option<Signed<Buffers>>),
Percent(Option<Signed<Percent>>),
Other(Format, Option<Signed<Other>>),
}
impl GenericSignedFormattedValue {
#[doc(alias = "get_format")]
pub fn format(&self) -> Format {
match *self {
Self::Default(_) => Format::Default,
Self::Bytes(_) => Format::Bytes,
Self::Time(_) => Format::Time,
Self::Buffers(_) => Format::Buffers,
Self::Percent(_) => Format::Percent,
Self::Other(format, _) => format,
}
}
pub fn abs(self) -> GenericFormattedValue {
use GenericFormattedValue as Unsigned;
match self {
Self::Default(opt_signed) => Unsigned::Default(opt_signed.map(Signed::abs)),
Self::Bytes(opt_signed) => Unsigned::Bytes(opt_signed.map(Signed::abs)),
Self::Time(opt_signed) => Unsigned::Time(opt_signed.map(Signed::abs)),
Self::Buffers(opt_signed) => Unsigned::Buffers(opt_signed.map(Signed::abs)),
Self::Percent(opt_signed) => Unsigned::Percent(opt_signed.map(Signed::abs)),
Self::Other(format, opt_signed) => Unsigned::Other(format, opt_signed.map(Signed::abs)),
}
}
pub fn is_some(&self) -> bool {
match self {
Self::Default(v) => v.is_some(),
Self::Bytes(v) => v.is_some(),
Self::Time(v) => v.is_some(),
Self::Buffers(v) => v.is_some(),
Self::Percent(v) => v.is_some(),
Self::Other(_, v) => v.is_some(),
}
}
pub fn is_none(&self) -> bool {
!self.is_some()
}
#[track_caller]
pub fn none_for_format(format: Format) -> Self {
skip_assert_initialized!();
match format {
Format::Default => Self::Default(None),
Format::Bytes => Self::Bytes(None),
Format::Time => Self::Time(None),
Format::Buffers => Self::Buffers(None),
Format::Percent => Self::Percent(None),
Format::Undefined => {
panic!("`Undefined` is already signed, use `GenericFormattedValue`")
}
other => Self::Other(other, None),
}
}
}
macro_rules! impl_gsfv_fn_opt_ret(
($fn:ident(self) -> Option<$ret_ty:ty>) => {
pub fn $fn(self) -> Option<$ret_ty> {
match self {
Self::Default(opt_signed) => opt_signed.map(|signed| signed.$fn()),
Self::Bytes(opt_signed) => opt_signed.map(|signed| signed.$fn()),
Self::Time(opt_signed) => opt_signed.map(|signed| signed.$fn()),
Self::Buffers(opt_signed) => opt_signed.map(|signed| signed.$fn()),
Self::Percent(opt_signed) => opt_signed.map(|signed| signed.$fn()),
Self::Other(_, opt_signed) => opt_signed.map(|signed| signed.$fn()),
}
}
};
);
impl GenericSignedFormattedValue {
impl_gsfv_fn_opt_ret!(is_positive(self) -> Option<bool>);
impl_gsfv_fn_opt_ret!(is_negative(self) -> Option<bool>);
impl_gsfv_fn_opt_ret!(signum(self) -> Option<i32>);
}
impl std::ops::Neg for GenericSignedFormattedValue {
type Output = Self;
fn neg(self) -> Self {
use std::ops::Neg;
match self {
Self::Default(opt_signed) => Self::Default(opt_signed.map(Neg::neg)),
Self::Bytes(opt_signed) => Self::Bytes(opt_signed.map(Neg::neg)),
Self::Time(opt_signed) => Self::Time(opt_signed.map(Neg::neg)),
Self::Buffers(opt_signed) => Self::Buffers(opt_signed.map(Neg::neg)),
Self::Percent(opt_signed) => Self::Percent(opt_signed.map(Neg::neg)),
Self::Other(format, opt_signed) => Self::Other(format, opt_signed.map(Neg::neg)),
}
}
}
impl fmt::Display for GenericSignedFormattedValue {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
Self::Default(opt_signed) => opt_signed.display().fmt(f),
Self::Bytes(opt_signed) => opt_signed.display().fmt(f),
Self::Time(opt_signed) => opt_signed.display().fmt(f),
Self::Buffers(opt_signed) => opt_signed.display().fmt(f),
Self::Percent(opt_signed) => opt_signed.display().fmt(f),
Self::Other(format, opt_signed) => {
opt_signed.display().fmt(f)?;
fmt::Write::write_char(f, ' ')?;
fmt::Display::fmt(&format, f)
}
}
}
}
impl Displayable for GenericSignedFormattedValue {
type DisplayImpl = Self;
fn display(self) -> Self::DisplayImpl {
self
}
}
#[cfg(test)]
mod tests {
use super::*;
@ -284,4 +426,29 @@ mod tests {
GenericFormattedValue::Other(Format::__Unknown(128), None)
);
}
#[test]
#[allow(clippy::eq_op, clippy::op_ref)]
fn generic_signed_other() {
let gen_other_42: GenericFormattedValue =
GenericFormattedValue::new(Format::__Unknown(128), 42);
let p_gen_other_42 = gen_other_42.into_positive();
assert_eq!(
p_gen_other_42,
GenericSignedFormattedValue::Other(
Format::__Unknown(128),
Some(Signed::Positive(Other(42))),
),
);
let n_gen_other_42 = gen_other_42.into_negative();
assert_eq!(
n_gen_other_42,
GenericSignedFormattedValue::Other(
Format::__Unknown(128),
Some(Signed::Negative(Other(42))),
),
);
}
}

View file

@ -684,7 +684,7 @@ mod tests {
Option::<ClockTime>::none_signed_for_format(Format::Time);
assert!(ct_none.is_none());
let gen_ct_none: Signed<GenericFormattedValue> =
let gen_ct_none: GenericSignedFormattedValue =
GenericFormattedValue::none_signed_for_format(Format::Time);
assert!(gen_ct_none.abs().is_none());
}
@ -775,25 +775,49 @@ mod tests {
assert!(ct_1.is_some());
let signed = ct_1.into_positive();
assert_eq!(signed, Signed::Positive(ct_1));
assert!(signed.is_positive());
assert_eq!(signed.positive(), Some(ct_1));
assert_eq!(
signed,
GenericSignedFormattedValue::Time(Some(Signed::Positive(ClockTime::SECOND))),
);
assert_eq!(signed.is_positive(), Some(true));
assert_eq!(signed.is_negative(), Some(false));
assert_eq!(signed.signum(), Some(1));
let signed = ct_1.into_negative();
assert_eq!(signed, Signed::Negative(ct_1));
assert!(signed.is_negative());
assert_eq!(signed.negative(), Some(ct_1));
assert_eq!(
signed,
GenericSignedFormattedValue::Time(Some(Signed::Negative(ClockTime::SECOND))),
);
assert_eq!(signed.is_negative(), Some(true));
assert_eq!(signed.is_positive(), Some(false));
assert_eq!(signed.signum(), Some(-1));
let ct_none = GenericFormattedValue::Time(ClockTime::NONE);
assert!(ct_none.is_none());
let signed = ct_none.into_positive();
assert_eq!(signed, Signed::Positive(ct_none));
assert!(signed.is_positive());
assert_eq!(signed, GenericSignedFormattedValue::Time(None),);
assert!(signed.is_positive().is_none());
assert!(signed.is_negative().is_none());
assert!(signed.signum().is_none());
let signed = ct_none.into_negative();
assert_eq!(signed, Signed::Negative(ct_none));
assert!(signed.is_negative());
assert_eq!(signed, GenericSignedFormattedValue::Time(None),);
assert!(signed.is_negative().is_none());
assert!(signed.is_positive().is_none());
assert!(signed.signum().is_none());
let ct_zero = GenericFormattedValue::Time(Some(ClockTime::ZERO));
assert!(ct_zero.is_some());
let signed = ct_zero.into_positive();
assert_eq!(
signed,
GenericSignedFormattedValue::Time(Some(Signed::Positive(ClockTime::ZERO))),
);
assert_eq!(signed.is_positive(), Some(true));
assert_eq!(signed.is_negative(), Some(false));
assert_eq!(signed.signum(), Some(0));
}
#[test]