1// Take a look at the license at the top of the repository in the LICENSE file.
2
3use crate::ffi;
4use glib::{prelude::*, translate::*};
5use std::fmt;
6use std::ops;
7
8#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
9#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
10#[doc(alias = "GstRank")]
11pub struct Rank(i32);
12
13impl Rank {
14 #[doc(alias = "GST_RANK_NONE")]
15 pub const NONE: Rank = Self(ffi::GST_RANK_NONE);
16 #[doc(alias = "GST_RANK_MARGINAL")]
17 pub const MARGINAL: Rank = Self(ffi::GST_RANK_MARGINAL);
18 #[doc(alias = "GST_RANK_SECONDARY")]
19 pub const SECONDARY: Rank = Self(ffi::GST_RANK_SECONDARY);
20 #[doc(alias = "GST_RANK_PRIMARY")]
21 pub const PRIMARY: Rank = Self(ffi::GST_RANK_PRIMARY);
22}
23
24impl IntoGlib for Rank {
25 type GlibType = i32;
26
27 #[inline]
28 fn into_glib(self) -> i32 {
29 self.0
30 }
31}
32
33#[doc(hidden)]
34impl FromGlib<i32> for Rank {
35 #[inline]
36 unsafe fn from_glib(value: i32) -> Self {
37 Rank(value)
38 }
39}
40
41impl StaticType for Rank {
42 #[inline]
43 fn static_type() -> glib::Type {
44 unsafe { from_glib(val:ffi::gst_rank_get_type()) }
45 }
46}
47
48impl HasParamSpec for Rank {
49 type ParamSpec = glib::ParamSpecEnum;
50 type SetValue = Self;
51 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
52
53 fn param_spec_builder() -> Self::BuilderFn {
54 Self::ParamSpec::builder_with_default
55 }
56}
57
58impl glib::value::ValueType for Rank {
59 type Type = Self;
60}
61
62unsafe impl<'a> glib::value::FromValue<'a> for Rank {
63 type Checker = glib::value::GenericValueTypeChecker<Self>;
64
65 #[inline]
66 unsafe fn from_value(value: &'a glib::Value) -> Self {
67 skip_assert_initialized!();
68 from_glib(val:glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
69 }
70}
71
72impl ToValue for Rank {
73 #[inline]
74 fn to_value(&self) -> glib::Value {
75 let mut value: Value = glib::Value::for_value_type::<Self>();
76 unsafe {
77 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
78 }
79 value
80 }
81
82 #[inline]
83 fn value_type(&self) -> glib::Type {
84 Self::static_type()
85 }
86}
87
88impl From<Rank> for glib::Value {
89 #[inline]
90 fn from(v: Rank) -> Self {
91 skip_assert_initialized!();
92 ToValue::to_value(&v)
93 }
94}
95
96impl From<i32> for Rank {
97 #[inline]
98 fn from(v: i32) -> Self {
99 skip_assert_initialized!();
100 Rank(v)
101 }
102}
103
104impl From<Rank> for i32 {
105 #[inline]
106 fn from(v: Rank) -> Self {
107 skip_assert_initialized!();
108 v.0
109 }
110}
111
112impl ops::Add<i32> for Rank {
113 type Output = Rank;
114
115 #[inline]
116 fn add(self, rhs: i32) -> Rank {
117 Rank(self.0 + rhs)
118 }
119}
120
121impl ops::Add<Rank> for i32 {
122 type Output = Rank;
123
124 #[inline]
125 fn add(self, rhs: Rank) -> Rank {
126 Rank(self + rhs.0)
127 }
128}
129
130impl ops::AddAssign<i32> for Rank {
131 #[inline]
132 fn add_assign(&mut self, rhs: i32) {
133 self.0 += rhs;
134 }
135}
136
137impl ops::Sub<i32> for Rank {
138 type Output = Rank;
139
140 #[inline]
141 fn sub(self, rhs: i32) -> Rank {
142 Rank(self.0 - rhs)
143 }
144}
145
146impl ops::Sub<Rank> for i32 {
147 type Output = Rank;
148
149 #[inline]
150 fn sub(self, rhs: Rank) -> Rank {
151 Rank(self - rhs.0)
152 }
153}
154
155impl ops::SubAssign<i32> for Rank {
156 #[inline]
157 fn sub_assign(&mut self, rhs: i32) {
158 self.0 -= rhs
159 }
160}
161
162impl std::cmp::PartialEq<i32> for Rank {
163 #[inline]
164 fn eq(&self, rhs: &i32) -> bool {
165 self.0 == *rhs
166 }
167}
168
169impl std::cmp::PartialEq<Rank> for i32 {
170 #[inline]
171 fn eq(&self, rhs: &Rank) -> bool {
172 *self == rhs.0
173 }
174}
175
176impl fmt::Display for Rank {
177 #[inline]
178 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
179 let rank: i32 = self.into_glib();
180 let names: [&str; 4] = ["none", "marginal", "secondary", "primary"];
181 let ranks: [Rank; 4] = [Rank::NONE, Rank::MARGINAL, Rank::SECONDARY, Rank::PRIMARY];
182
183 let mut best_i: usize = 0;
184 for i: usize in 0..4 {
185 if rank == ranks[i].into_glib() {
186 return f.write_str(data:names[i]);
187 }
188 if (rank - ranks[i]).into_glib().abs() < (rank - ranks[best_i]).into_glib().abs() {
189 best_i = i;
190 }
191 }
192
193 let diff: i32 = (rank - ranks[best_i]).into_glib();
194 let op_str: char = if diff > 0 { '+' } else { '-' };
195
196 write!(f, "{} {} {}", names[best_i], op_str, diff.abs())
197 }
198}
199