gstreamer-rs/gstreamer-validate/src/enums.rs

150 lines
4.7 KiB
Rust
Raw Normal View History

use glib::translate::*;
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
#[repr(i32)]
pub enum ActionSuccess {
Ok = ffi::GST_VALIDATE_EXECUTE_ACTION_OK,
Async = ffi::GST_VALIDATE_EXECUTE_ACTION_ASYNC,
NonBlocking = ffi::GST_VALIDATE_EXECUTE_ACTION_NON_BLOCKING,
InProgress = ffi::GST_VALIDATE_EXECUTE_ACTION_IN_PROGRESS,
Done = ffi::GST_VALIDATE_EXECUTE_ACTION_DONE,
}
impl ActionSuccess {
pub fn from_value(value: impl Into<i32>) -> Option<Self> {
skip_assert_initialized!();
Some(match value.into() {
ffi::GST_VALIDATE_EXECUTE_ACTION_OK => ActionSuccess::Ok,
ffi::GST_VALIDATE_EXECUTE_ACTION_ASYNC => ActionSuccess::Async,
ffi::GST_VALIDATE_EXECUTE_ACTION_NON_BLOCKING => ActionSuccess::NonBlocking,
ffi::GST_VALIDATE_EXECUTE_ACTION_IN_PROGRESS => ActionSuccess::InProgress,
ffi::GST_VALIDATE_EXECUTE_ACTION_DONE => ActionSuccess::Done,
_ => return None,
})
}
}
impl IntoGlib for ActionSuccess {
type GlibType = ffi::GstValidateActionReturn;
#[inline]
fn into_glib(self) -> ffi::GstValidateActionReturn {
skip_assert_initialized!();
self as ffi::GstValidateActionReturn
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
#[repr(i32)]
pub enum ActionError {
Error = ffi::GST_VALIDATE_EXECUTE_ACTION_ERROR,
ErrorReported = ffi::GST_VALIDATE_EXECUTE_ACTION_ERROR_REPORTED,
None = ffi::GST_VALIDATE_EXECUTE_ACTION_NONE,
}
impl ActionError {
pub fn from_value(value: impl Into<i32>) -> Self {
skip_assert_initialized!();
match value.into() {
ffi::GST_VALIDATE_EXECUTE_ACTION_ERROR => ActionError::Error,
ffi::GST_VALIDATE_EXECUTE_ACTION_ERROR_REPORTED => ActionError::ErrorReported,
ffi::GST_VALIDATE_EXECUTE_ACTION_NONE => ActionError::None,
_ => ActionError::Error,
}
}
}
impl IntoGlib for ActionError {
type GlibType = ffi::GstValidateActionReturn;
#[inline]
fn into_glib(self) -> ffi::GstValidateActionReturn {
self as ffi::GstValidateActionReturn
}
}
#[must_use]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[doc(alias = "GstValidateActionReturn")]
#[repr(i32)]
pub enum ActionReturn {
#[doc(alias = "GST_VALIDATE_EXECUTE_ACTION_ERROR")]
Error = ffi::GST_VALIDATE_EXECUTE_ACTION_ERROR,
#[doc(alias = "GST_VALIDATE_EXECUTE_ACTION_OK")]
Ok = ffi::GST_VALIDATE_EXECUTE_ACTION_OK,
#[doc(alias = "GST_VALIDATE_EXECUTE_ACTION_ASYNC")]
Async = ffi::GST_VALIDATE_EXECUTE_ACTION_ASYNC,
#[doc(alias = "GST_VALIDATE_EXECUTE_ACTION_NON_BLOCKING")]
NonBlocking = ffi::GST_VALIDATE_EXECUTE_ACTION_NON_BLOCKING,
#[doc(alias = "GST_VALIDATE_EXECUTE_ACTION_ERROR_REPORTED")]
ErrorReported = ffi::GST_VALIDATE_EXECUTE_ACTION_ERROR_REPORTED,
#[doc(alias = "GST_VALIDATE_EXECUTE_ACTION_IN_PROGRESS")]
InProgress = ffi::GST_VALIDATE_EXECUTE_ACTION_IN_PROGRESS,
#[doc(alias = "GST_VALIDATE_EXECUTE_ACTION_NONE")]
None = ffi::GST_VALIDATE_EXECUTE_ACTION_NONE,
#[doc(alias = "GST_VALIDATE_EXECUTE_ACTION_DONE")]
Done = ffi::GST_VALIDATE_EXECUTE_ACTION_DONE,
}
#[doc(hidden)]
impl IntoGlib for ActionReturn {
type GlibType = ffi::GstValidateActionReturn;
#[inline]
fn into_glib(self) -> ffi::GstValidateActionReturn {
self as ffi::GstValidateActionReturn
}
}
#[doc(hidden)]
impl FromGlib<ffi::GstValidateActionReturn> for ActionReturn {
#[inline]
unsafe fn from_glib(value: ffi::GstValidateActionReturn) -> Self {
skip_assert_initialized!();
if !(ffi::GST_VALIDATE_EXECUTE_ACTION_ERROR..=ffi::GST_VALIDATE_EXECUTE_ACTION_DONE)
.contains(&value)
{
ActionReturn::Error
} else {
std::mem::transmute(value)
}
}
}
impl TryFromGlib<ffi::GstValidateActionReturn> for ActionSuccess {
type Error = ActionError;
#[inline]
unsafe fn try_from_glib(
val: ffi::GstValidateActionReturn,
) -> Result<ActionSuccess, ActionError> {
skip_assert_initialized!();
ActionReturn::from_glib(val).into_result()
}
}
impl ActionReturn {
#[inline]
pub fn into_result(self) -> Result<ActionSuccess, ActionError> {
match self {
Self::Error | Self::ErrorReported | Self::None => {
Err(unsafe { std::mem::transmute(self) })
}
_ => Ok(unsafe { std::mem::transmute(self) }),
}
}
#[inline]
pub fn from_error(v: ActionError) -> Self {
skip_assert_initialized!();
unsafe { std::mem::transmute(v) }
}
#[inline]
pub fn from_ok(v: ActionSuccess) -> Self {
skip_assert_initialized!();
unsafe { std::mem::transmute(v) }
}
}