mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer-rs.git
synced 2024-05-20 01:08:26 +00:00
149 lines
3.1 KiB
Rust
149 lines
3.1 KiB
Rust
// Take a look at the license at the top of the repository in the LICENSE file.
|
|
|
|
use std::ops::{Deref, DerefMut};
|
|
|
|
use glib::translate::TryFromGlib;
|
|
|
|
use super::{
|
|
FormattedValue, FormattedValueError, FormattedValueFullRange, FormattedValueIntrinsic,
|
|
GenericFormattedValue, Signed,
|
|
};
|
|
use crate::Format;
|
|
|
|
#[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy, Debug, Default)]
|
|
pub struct Undefined(i64);
|
|
|
|
impl Undefined {
|
|
pub const ONE: Undefined = Undefined(1);
|
|
}
|
|
|
|
// FIXME `functions in traits cannot be const` (rustc 1.64.0)
|
|
// rustdoc-stripper-ignore-next
|
|
/// `Undefined` formatted value constructor trait.
|
|
pub trait UndefinedFormatConstructor {
|
|
// rustdoc-stripper-ignore-next
|
|
/// Builds an `Undefined` formatted value from `self`.
|
|
fn undefined_format(self) -> Undefined;
|
|
}
|
|
|
|
impl UndefinedFormatConstructor for i64 {
|
|
#[track_caller]
|
|
#[inline]
|
|
fn undefined_format(self) -> Undefined {
|
|
Undefined(self)
|
|
}
|
|
}
|
|
|
|
impl FormattedValue for Undefined {
|
|
type FullRange = Undefined;
|
|
|
|
#[inline]
|
|
fn default_format() -> Format {
|
|
Format::Undefined
|
|
}
|
|
|
|
#[inline]
|
|
fn format(&self) -> Format {
|
|
Format::Undefined
|
|
}
|
|
|
|
#[inline]
|
|
fn is_some(&self) -> bool {
|
|
true
|
|
}
|
|
|
|
#[inline]
|
|
unsafe fn into_raw_value(self) -> i64 {
|
|
self.0
|
|
}
|
|
}
|
|
|
|
impl FormattedValueFullRange for Undefined {
|
|
#[inline]
|
|
unsafe fn from_raw(format: Format, value: i64) -> Self {
|
|
debug_assert_eq!(format, Format::Undefined);
|
|
Undefined(value)
|
|
}
|
|
}
|
|
|
|
impl From<Undefined> for GenericFormattedValue {
|
|
#[inline]
|
|
fn from(v: Undefined) -> Self {
|
|
skip_assert_initialized!();
|
|
GenericFormattedValue::Undefined(v)
|
|
}
|
|
}
|
|
|
|
impl TryFrom<GenericFormattedValue> for Undefined {
|
|
type Error = FormattedValueError;
|
|
|
|
#[inline]
|
|
fn try_from(v: GenericFormattedValue) -> Result<Undefined, Self::Error> {
|
|
skip_assert_initialized!();
|
|
if let GenericFormattedValue::Undefined(v) = v {
|
|
Ok(v)
|
|
} else {
|
|
Err(FormattedValueError(v.format()))
|
|
}
|
|
}
|
|
}
|
|
|
|
impl FormattedValueIntrinsic for Undefined {}
|
|
|
|
impl TryFromGlib<i64> for Undefined {
|
|
type Error = std::convert::Infallible;
|
|
#[inline]
|
|
unsafe fn try_from_glib(v: i64) -> Result<Self, Self::Error> {
|
|
skip_assert_initialized!();
|
|
Ok(Undefined(v))
|
|
}
|
|
}
|
|
|
|
impl From<i64> for Undefined {
|
|
#[inline]
|
|
fn from(v: i64) -> Self {
|
|
skip_assert_initialized!();
|
|
Undefined(v)
|
|
}
|
|
}
|
|
|
|
impl Deref for Undefined {
|
|
type Target = i64;
|
|
|
|
#[inline]
|
|
fn deref(&self) -> &i64 {
|
|
&self.0
|
|
}
|
|
}
|
|
|
|
impl DerefMut for Undefined {
|
|
#[inline]
|
|
fn deref_mut(&mut self) -> &mut i64 {
|
|
&mut self.0
|
|
}
|
|
}
|
|
|
|
impl AsRef<i64> for Undefined {
|
|
#[inline]
|
|
fn as_ref(&self) -> &i64 {
|
|
&self.0
|
|
}
|
|
}
|
|
|
|
impl AsMut<i64> for Undefined {
|
|
#[inline]
|
|
fn as_mut(&mut self) -> &mut i64 {
|
|
&mut self.0
|
|
}
|
|
}
|
|
|
|
impl From<Undefined> for Signed<u64> {
|
|
#[inline]
|
|
fn from(val: Undefined) -> Signed<u64> {
|
|
skip_assert_initialized!();
|
|
val.0.into()
|
|
}
|
|
}
|
|
|
|
glib_newtype_display!(Undefined, Format::Undefined);
|