use std::cmp;
use std::error::Error;
use std::fmt;
use ClockReturn;
use FlowReturn;
use PadLinkReturn;
use StateChangeReturn;
use glib::translate::ToGlib;
impl StateChangeReturn {
pub fn into_result(self) -> Result<StateChangeSuccess, StateChangeError> {
match self {
StateChangeReturn::Success => Ok(StateChangeSuccess::Success),
StateChangeReturn::Async => Ok(StateChangeSuccess::Async),
StateChangeReturn::NoPreroll => Ok(StateChangeSuccess::NoPreroll),
StateChangeReturn::Failure => Err(StateChangeError),
_ => Err(StateChangeError),
}
}
pub fn from_error(_: StateChangeError) -> Self {
StateChangeReturn::Failure
}
pub fn from_ok(v: StateChangeSuccess) -> Self {
match v {
StateChangeSuccess::Success => StateChangeReturn::Success,
StateChangeSuccess::Async => StateChangeReturn::Async,
StateChangeSuccess::NoPreroll => StateChangeReturn::NoPreroll,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum StateChangeSuccess {
Success,
Async,
NoPreroll,
}
impl From<StateChangeSuccess> for StateChangeReturn {
fn from(value: StateChangeSuccess) -> Self {
StateChangeReturn::from_ok(value)
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
#[must_use]
pub struct StateChangeError;
impl fmt::Display for StateChangeError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "State-change error")
}
}
impl From<StateChangeError> for StateChangeReturn {
fn from(value: StateChangeError) -> Self {
StateChangeReturn::from_error(value)
}
}
impl Error for StateChangeError {
fn description(&self) -> &str {
"Element failed to change its state"
}
}
impl From<Result<StateChangeSuccess, StateChangeError>> for StateChangeReturn {
fn from(res: Result<StateChangeSuccess, StateChangeError>) -> Self {
match res {
Ok(success) => StateChangeReturn::from_ok(success),
Err(error) => StateChangeReturn::from_error(error),
}
}
}
impl FlowReturn {
pub fn into_result(self) -> Result<FlowSuccess, FlowError> {
match self {
FlowReturn::CustomSuccess2 => Ok(FlowSuccess::CustomSuccess2),
FlowReturn::CustomSuccess1 => Ok(FlowSuccess::CustomSuccess1),
FlowReturn::CustomSuccess => Ok(FlowSuccess::CustomSuccess),
FlowReturn::Ok => Ok(FlowSuccess::Ok),
FlowReturn::NotLinked => Err(FlowError::NotLinked),
FlowReturn::Flushing => Err(FlowError::Flushing),
FlowReturn::Eos => Err(FlowError::Eos),
FlowReturn::NotNegotiated => Err(FlowError::NotNegotiated),
FlowReturn::Error => Err(FlowError::Error),
FlowReturn::NotSupported => Err(FlowError::NotSupported),
FlowReturn::CustomError => Err(FlowError::CustomError),
FlowReturn::CustomError1 => Err(FlowError::CustomError1),
FlowReturn::CustomError2 => Err(FlowError::CustomError2),
_ => Err(FlowError::Error),
}
}
pub fn into_result_value<T, F: FnOnce() -> T>(self, func: F) -> Result<T, FlowError> {
match self.into_result() {
Ok(_) => Ok(func()),
Err(err) => Err(err),
}
}
pub fn from_error(v: FlowError) -> Self {
match v {
FlowError::NotLinked => FlowReturn::NotLinked,
FlowError::Flushing => FlowReturn::Flushing,
FlowError::Eos => FlowReturn::Eos,
FlowError::NotNegotiated => FlowReturn::NotNegotiated,
FlowError::Error => FlowReturn::Error,
FlowError::NotSupported => FlowReturn::NotSupported,
FlowError::CustomError => FlowReturn::CustomError,
FlowError::CustomError1 => FlowReturn::CustomError1,
FlowError::CustomError2 => FlowReturn::CustomError2,
}
}
pub fn from_ok(v: FlowSuccess) -> Self {
match v {
FlowSuccess::CustomSuccess2 => FlowReturn::CustomSuccess2,
FlowSuccess::CustomSuccess1 => FlowReturn::CustomSuccess1,
FlowSuccess::CustomSuccess => FlowReturn::CustomSuccess,
FlowSuccess::Ok => FlowReturn::Ok,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum FlowSuccess {
CustomSuccess2,
CustomSuccess1,
CustomSuccess,
Ok,
}
impl From<FlowSuccess> for FlowReturn {
fn from(value: FlowSuccess) -> Self {
FlowReturn::from_ok(value)
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
#[must_use]
pub enum FlowError {
NotLinked,
Flushing,
Eos,
NotNegotiated,
Error,
NotSupported,
CustomError,
CustomError1,
CustomError2,
}
impl fmt::Display for FlowError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "Flow error: {}", self.description())
}
}
impl From<FlowError> for FlowReturn {
fn from(value: FlowError) -> Self {
FlowReturn::from_error(value)
}
}
impl Error for FlowError {
fn description(&self) -> &str {
match *self {
FlowError::NotLinked => "Pad is not linked",
FlowError::Flushing => "Pad is flushing",
FlowError::Eos => "Pad is EOS",
FlowError::NotNegotiated => "Pad is not negotiated",
FlowError::Error => {
"Some (fatal) error occurred. Element generating this error should post an error message with more details"
}
FlowError::NotSupported => "This operation is not supported",
FlowError::CustomError => {
"Elements can use values starting from this (and lower) to define custom error codes"
}
FlowError::CustomError1 => "Pre-defined custom error code",
FlowError::CustomError2 => "Pre-defined custom error code",
}
}
}
impl From<Result<FlowSuccess, FlowError>> for FlowReturn {
fn from(res: Result<FlowSuccess, FlowError>) -> Self {
match res {
Ok(success) => FlowReturn::from_ok(success),
Err(error) => FlowReturn::from_error(error),
}
}
}
impl PadLinkReturn {
pub fn into_result(self) -> Result<PadLinkSuccess, PadLinkError> {
match self {
PadLinkReturn::Ok => Ok(PadLinkSuccess),
PadLinkReturn::WrongHierarchy => Err(PadLinkError::WrongHierarchy),
PadLinkReturn::WasLinked => Err(PadLinkError::WasLinked),
PadLinkReturn::WrongDirection => Err(PadLinkError::WrongDirection),
PadLinkReturn::Noformat => Err(PadLinkError::Noformat),
PadLinkReturn::Nosched => Err(PadLinkError::Nosched),
PadLinkReturn::Refused => Err(PadLinkError::Refused),
_ => Err(PadLinkError::Refused),
}
}
pub fn from_error(v: PadLinkError) -> Self {
match v {
PadLinkError::WrongHierarchy => PadLinkReturn::WrongHierarchy,
PadLinkError::WasLinked => PadLinkReturn::WasLinked,
PadLinkError::WrongDirection => PadLinkReturn::WrongDirection,
PadLinkError::Noformat => PadLinkReturn::Noformat,
PadLinkError::Nosched => PadLinkReturn::Nosched,
PadLinkError::Refused => PadLinkReturn::Refused,
}
}
pub fn from_ok(_: PadLinkSuccess) -> Self {
PadLinkReturn::Ok
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub struct PadLinkSuccess;
impl From<PadLinkSuccess> for PadLinkReturn {
fn from(value: PadLinkSuccess) -> Self {
PadLinkReturn::from_ok(value)
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
#[must_use]
pub enum PadLinkError {
WrongHierarchy,
WasLinked,
WrongDirection,
Noformat,
Nosched,
Refused,
}
impl fmt::Display for PadLinkError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "Pad failed to link: {}", self.description())
}
}
impl From<PadLinkError> for PadLinkReturn {
fn from(value: PadLinkError) -> Self {
PadLinkReturn::from_error(value)
}
}
impl Error for PadLinkError {
fn description(&self) -> &str {
match *self {
PadLinkError::WrongHierarchy => "Pads have no common grandparent",
PadLinkError::WasLinked => "Pad was already linked",
PadLinkError::WrongDirection => "Pads have wrong direction",
PadLinkError::Noformat => "Pads do not have common format",
PadLinkError::Nosched => "Pads cannot cooperate in scheduling",
PadLinkError::Refused => "Refused for some other reason",
}
}
}
impl From<Result<PadLinkSuccess, PadLinkError>> for PadLinkReturn {
fn from(res: Result<PadLinkSuccess, PadLinkError>) -> Self {
match res {
Ok(success) => PadLinkReturn::from_ok(success),
Err(error) => PadLinkReturn::from_error(error),
}
}
}
impl ClockReturn {
pub fn into_result(self) -> Result<ClockSuccess, ClockError> {
match self {
ClockReturn::Ok => Ok(ClockSuccess::Ok),
ClockReturn::Done => Ok(ClockSuccess::Done),
ClockReturn::Early => Err(ClockError::Early),
ClockReturn::Unscheduled => Err(ClockError::Unscheduled),
ClockReturn::Busy => Err(ClockError::Busy),
ClockReturn::Badtime => Err(ClockError::Badtime),
ClockReturn::Error => Err(ClockError::Error),
ClockReturn::Unsupported => Err(ClockError::Unsupported),
_ => Err(ClockError::Error),
}
}
pub fn from_error(v: ClockError) -> Self {
match v {
ClockError::Early => ClockReturn::Early,
ClockError::Unscheduled => ClockReturn::Unscheduled,
ClockError::Busy => ClockReturn::Busy,
ClockError::Badtime => ClockReturn::Badtime,
ClockError::Error => ClockReturn::Error,
ClockError::Unsupported => ClockReturn::Unsupported,
}
}
pub fn from_ok(v: ClockSuccess) -> Self {
match v {
ClockSuccess::Ok => ClockReturn::Ok,
ClockSuccess::Done => ClockReturn::Done,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum ClockSuccess {
Ok,
Done,
}
impl From<ClockSuccess> for ClockReturn {
fn from(value: ClockSuccess) -> Self {
ClockReturn::from_ok(value)
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
#[must_use]
pub enum ClockError {
Early,
Unscheduled,
Busy,
Badtime,
Error,
Unsupported,
}
impl fmt::Display for ClockError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "Clock error: {}", self.description())
}
}
impl From<ClockError> for ClockReturn {
fn from(value: ClockError) -> Self {
ClockReturn::from_error(value)
}
}
impl Error for ClockError {
fn description(&self) -> &str {
match *self {
ClockError::Early => "The operation was scheduled too late",
ClockError::Unscheduled => "The clockID was unscheduled",
ClockError::Busy => "The ClockID is busy",
ClockError::Badtime => "A bad time was provided to a function",
ClockError::Error => "An error occurred",
ClockError::Unsupported => "Operation is not supported",
}
}
}
impl From<Result<ClockSuccess, ClockError>> for ClockReturn {
fn from(res: Result<ClockSuccess, ClockError>) -> Self {
match res {
Ok(success) => ClockReturn::from_ok(success),
Err(error) => ClockReturn::from_error(error),
}
}
}
impl PartialOrd for ::TypeFindProbability {
fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
self.to_glib().partial_cmp(&other.to_glib())
}
}
impl Ord for ::TypeFindProbability {
fn cmp(&self, other: &Self) -> cmp::Ordering {
self.to_glib().cmp(&other.to_glib())
}
}
impl PartialOrd for ::Rank {
fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
self.to_glib().partial_cmp(&other.to_glib())
}
}
impl Ord for ::Rank {
fn cmp(&self, other: &Self) -> cmp::Ordering {
self.to_glib().cmp(&other.to_glib())
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
#[must_use]
pub enum TagError {
TypeMismatch,
}
impl fmt::Display for TagError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "Tag error: {}", self.description())
}
}
impl Error for TagError {
fn description(&self) -> &str {
match *self {
TagError::TypeMismatch => "The value type doesn't match with the specified Tag",
}
}
}