From ddf398e3daf30a9bf0ac9f291fbe286bc26610f9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebastian=20Dr=C3=B6ge?= Date: Sat, 13 Nov 2021 11:01:59 +0200 Subject: [PATCH] gstreamer: Add various missing doc aliases to event/message/query functions This is going to make it easier to find them from the corresponding C function names. --- gstreamer/src/event.rs | 60 +++++++++++++++++++++++++++++++++ gstreamer/src/message.rs | 73 +++++++++++++++++++++++++++++++++++++--- gstreamer/src/query.rs | 40 ++++++++++++++++++++++ 3 files changed, 169 insertions(+), 4 deletions(-) diff --git a/gstreamer/src/event.rs b/gstreamer/src/event.rs index b295c0139..e4e30d290 100644 --- a/gstreamer/src/event.rs +++ b/gstreamer/src/event.rs @@ -81,22 +81,27 @@ impl GroupId { } impl EventType { + #[doc(alias = "GST_EVENT_IS_UPSTREAM")] pub fn is_upstream(self) -> bool { (self.into_glib() as u32) & ffi::GST_EVENT_TYPE_UPSTREAM != 0 } + #[doc(alias = "GST_EVENT_IS_DOWNSTREAM")] pub fn is_downstream(self) -> bool { (self.into_glib() as u32) & ffi::GST_EVENT_TYPE_DOWNSTREAM != 0 } + #[doc(alias = "GST_EVENT_IS_SERIALIZED")] pub fn is_serialized(self) -> bool { (self.into_glib() as u32) & ffi::GST_EVENT_TYPE_SERIALIZED != 0 } + #[doc(alias = "GST_EVENT_IS_STICKY")] pub fn is_sticky(self) -> bool { (self.into_glib() as u32) & ffi::GST_EVENT_TYPE_STICKY != 0 } + #[doc(alias = "GST_EVENT_IS_STICKY_MULTI")] pub fn is_sticky_multi(self) -> bool { (self.into_glib() as u32) & ffi::GST_EVENT_TYPE_STICKY_MULTI != 0 } @@ -173,33 +178,40 @@ impl EventRef { } } + #[doc(alias = "gst_event_writable_structure")] pub fn structure_mut(&mut self) -> &mut StructureRef { unsafe { StructureRef::from_glib_borrow_mut(ffi::gst_event_writable_structure(self.as_mut_ptr())) } } + #[doc(alias = "GST_EVENT_IS_UPSTREAM")] pub fn is_upstream(&self) -> bool { self.type_().is_upstream() } + #[doc(alias = "GST_EVENT_IS_DOWNSTREAM")] pub fn is_downstream(&self) -> bool { self.type_().is_downstream() } + #[doc(alias = "GST_EVENT_IS_SERIALIZED")] pub fn is_serialized(&self) -> bool { self.type_().is_serialized() } + #[doc(alias = "GST_EVENT_IS_STICKY")] pub fn is_sticky(&self) -> bool { self.type_().is_sticky() } + #[doc(alias = "GST_EVENT_IS_STICKY_MULTI")] pub fn is_sticky_multi(&self) -> bool { self.type_().is_sticky_multi() } #[doc(alias = "get_type")] + #[doc(alias = "GST_EVENT_TYPE")] pub fn type_(&self) -> EventType { unsafe { from_glib((*self.as_ptr()).type_) } } @@ -398,6 +410,7 @@ macro_rules! declare_concrete_event { declare_concrete_event!(FlushStart, T); impl FlushStart { + #[doc(alias = "gst_event_new_flush_start")] #[allow(clippy::new_ret_no_self)] pub fn new() -> Event { skip_assert_initialized!(); @@ -412,6 +425,7 @@ impl FlushStart { declare_concrete_event!(FlushStop, T); impl FlushStop { + #[doc(alias = "gst_event_new_flush_stop")] #[allow(clippy::new_ret_no_self)] pub fn new(reset_time: bool) -> Event { skip_assert_initialized!(); @@ -426,6 +440,7 @@ impl FlushStop { impl FlushStop { #[doc(alias = "get_reset_time")] + #[doc(alias = "gst_event_parse_flush_stop")] pub fn resets_time(&self) -> bool { unsafe { let mut reset_time = mem::MaybeUninit::uninit(); @@ -439,6 +454,7 @@ impl FlushStop { declare_concrete_event!(@sticky StreamStart, T); impl StreamStart { + #[doc(alias = "gst_event_new_stream_start")] #[allow(clippy::new_ret_no_self)] pub fn new(stream_id: &str) -> Event { skip_assert_initialized!(); @@ -453,6 +469,7 @@ impl StreamStart { impl StreamStart { #[doc(alias = "get_stream_id")] + #[doc(alias = "gst_event_parse_stream_start")] pub fn stream_id(&self) -> &str { unsafe { let mut stream_id = ptr::null(); @@ -506,6 +523,7 @@ impl StreamStart { declare_concrete_event!(@sticky Caps, T); impl Caps { + #[doc(alias = "gst_event_new_caps")] #[allow(clippy::new_ret_no_self)] pub fn new(caps: &crate::Caps) -> Event { skip_assert_initialized!(); @@ -531,6 +549,7 @@ impl Caps { } #[doc(alias = "get_caps_owned")] + #[doc(alias = "gst_event_parse_caps")] pub fn caps_owned(&self) -> crate::Caps { unsafe { from_glib_none(self.caps().as_ptr()) } } @@ -538,6 +557,7 @@ impl Caps { declare_concrete_event!(@sticky Segment, T); impl Segment { + #[doc(alias = "gst_event_new_segment")] #[allow(clippy::new_ret_no_self)] pub fn new(segment: &crate::FormattedSegment) -> Event { skip_assert_initialized!(); @@ -573,6 +593,7 @@ declare_concrete_event!(@sticky StreamCollection, T); impl StreamCollection { #[cfg(any(feature = "v1_10", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))] + #[doc(alias = "gst_event_new_stream_collection")] #[allow(clippy::new_ret_no_self)] pub fn new(stream_collection: &crate::StreamCollection) -> Event { skip_assert_initialized!(); @@ -606,6 +627,7 @@ impl StreamCollection { declare_concrete_event!(@sticky Tag, T); impl Tag { + #[doc(alias = "gst_event_new_tag")] #[allow(clippy::new_ret_no_self)] pub fn new(tags: crate::TagList) -> Event { skip_assert_initialized!(); @@ -631,6 +653,7 @@ impl Tag { } #[doc(alias = "get_tag_owned")] + #[doc(alias = "gst_event_parse_tag")] pub fn tag_owned(&self) -> crate::TagList { unsafe { from_glib_none(self.tag().as_ptr()) } } @@ -638,6 +661,7 @@ impl Tag { declare_concrete_event!(@sticky Buffersize, T); impl Buffersize { + #[doc(alias = "gst_event_new_buffer_size")] #[allow(clippy::new_ret_no_self)] pub fn new>(minsize: V, maxsize: V, r#async: bool) -> Event { skip_assert_initialized!(); @@ -659,6 +683,7 @@ impl Buffersize { } impl Buffersize { + #[doc(alias = "gst_event_parse_buffer_size")] pub fn get(&self) -> (GenericFormattedValue, GenericFormattedValue, bool) { unsafe { let mut fmt = mem::MaybeUninit::uninit(); @@ -684,6 +709,7 @@ impl Buffersize { declare_concrete_event!(@sticky SinkMessage, T); impl SinkMessage { + #[doc(alias = "gst_event_new_sink_message")] #[allow(clippy::new_ret_no_self)] pub fn new(name: &str, msg: &crate::Message) -> Event { skip_assert_initialized!(); @@ -717,6 +743,7 @@ declare_concrete_event!(@sticky StreamGroupDone, T); impl StreamGroupDone { #[cfg(any(feature = "v1_10", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))] + #[doc(alias = "gst_event_new_stream_group_done")] #[allow(clippy::new_ret_no_self)] pub fn new(group_id: GroupId) -> Event { skip_assert_initialized!(); @@ -737,6 +764,7 @@ impl StreamGroupDone { #[cfg(any(feature = "v1_10", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))] #[doc(alias = "get_group_id")] + #[doc(alias = "gst_event_parse_stream_group_done")] pub fn group_id(&self) -> GroupId { unsafe { let mut group_id = mem::MaybeUninit::uninit(); @@ -752,6 +780,7 @@ impl StreamGroupDone { declare_concrete_event!(@sticky Eos, T); impl Eos { + #[doc(alias = "gst_event_new_eos")] #[allow(clippy::new_ret_no_self)] pub fn new() -> Event { skip_assert_initialized!(); @@ -768,6 +797,7 @@ declare_concrete_event!(@sticky Toc, T); impl Toc { // FIXME could use false for updated as default // Even better: use an enum for updated so that it is more explicit than true / false + #[doc(alias = "gst_event_new_toc")] #[allow(clippy::new_ret_no_self)] pub fn new(toc: &crate::Toc, updated: bool) -> Event { skip_assert_initialized!(); @@ -797,6 +827,7 @@ impl Toc { } #[doc(alias = "get_toc_owned")] + #[doc(alias = "gst_event_parse_toc")] pub fn toc_owned(&self) -> (crate::Toc, bool) { unsafe { let (toc, updated) = self.toc(); @@ -807,6 +838,7 @@ impl Toc { declare_concrete_event!(@sticky Protection, T); impl Protection { + #[doc(alias = "gst_event_new_protection")] #[allow(clippy::new_ret_no_self)] pub fn new(system_id: &str, data: &crate::Buffer) -> Event { skip_assert_initialized!(); @@ -820,6 +852,7 @@ impl Protection { } impl Protection { + #[doc(alias = "gst_event_parse_protection")] pub fn get(&self) -> (&str, &crate::BufferRef, Option<&str>) { unsafe { let mut system_id = ptr::null(); @@ -845,6 +878,7 @@ impl Protection { } } + #[doc(alias = "gst_event_parse_protection")] pub fn get_owned(&self) -> (&str, crate::Buffer, Option<&str>) { unsafe { let (system_id, buffer, origin) = self.get(); @@ -855,6 +889,7 @@ impl Protection { declare_concrete_event!(SegmentDone, T); impl SegmentDone { + #[doc(alias = "gst_event_new_segment_done")] #[allow(clippy::new_ret_no_self)] pub fn new>(position: V) -> Event { skip_assert_initialized!(); @@ -869,6 +904,7 @@ impl SegmentDone { } impl SegmentDone { + #[doc(alias = "gst_event_parse_segment_done")] pub fn get(&self) -> GenericFormattedValue { unsafe { let mut fmt = mem::MaybeUninit::uninit(); @@ -887,6 +923,7 @@ impl SegmentDone { declare_concrete_event!(Gap, T); impl Gap { + #[doc(alias = "gst_event_new_gap")] #[allow(clippy::new_ret_no_self)] pub fn new(timestamp: ClockTime, duration: impl Into>) -> Event { skip_assert_initialized!(); @@ -900,6 +937,7 @@ impl Gap { } impl Gap { + #[doc(alias = "gst_event_parse_gap")] pub fn get(&self) -> (ClockTime, Option) { unsafe { let mut timestamp = mem::MaybeUninit::uninit(); @@ -936,6 +974,7 @@ declare_concrete_event!(@sticky InstantRateChange, T); #[cfg(any(feature = "v1_18", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))] impl InstantRateChange { + #[doc(alias = "gst_event_new_instant_rate_change")] #[allow(clippy::new_ret_no_self)] pub fn new(multiplier: f64, new_flags: crate::SegmentFlags) -> Event { skip_assert_initialized!(); @@ -954,6 +993,7 @@ impl InstantRateChange { #[cfg(any(feature = "v1_18", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))] impl InstantRateChange { + #[doc(alias = "gst_event_parse_instant_rate_change")] pub fn get(&self) -> (f64, crate::SegmentFlags) { unsafe { let mut multiplier = mem::MaybeUninit::uninit(); @@ -972,6 +1012,7 @@ impl InstantRateChange { declare_concrete_event!(Qos, T); impl Qos { + #[doc(alias = "gst_event_new_qos")] #[allow(clippy::new_ret_no_self)] pub fn new( type_: crate::QOSType, @@ -992,6 +1033,7 @@ impl Qos { } impl Qos { + #[doc(alias = "gst_event_parse_qos")] pub fn get(&self) -> (crate::QOSType, f64, i64, Option) { unsafe { let mut type_ = mem::MaybeUninit::uninit(); @@ -1019,6 +1061,7 @@ impl Qos { declare_concrete_event!(Seek, T); impl Seek { + #[doc(alias = "gst_event_new_seek")] #[allow(clippy::new_ret_no_self)] pub fn new>( rate: f64, @@ -1050,6 +1093,7 @@ impl Seek { } impl Seek { + #[doc(alias = "gst_event_parse_seek")] pub fn get( &self, ) -> ( @@ -1111,6 +1155,7 @@ impl Seek { declare_concrete_event!(Navigation, T); impl Navigation { + #[doc(alias = "gst_event_new_navigation")] #[allow(clippy::new_ret_no_self)] pub fn new(structure: crate::Structure) -> Event { skip_assert_initialized!(); @@ -1125,6 +1170,7 @@ impl Navigation { declare_concrete_event!(Latency, T); impl Latency { + #[doc(alias = "gst_event_new_latency")] #[allow(clippy::new_ret_no_self)] pub fn new(latency: ClockTime) -> Event { skip_assert_initialized!(); @@ -1153,6 +1199,7 @@ impl Latency { declare_concrete_event!(Step, T); impl Step { + #[doc(alias = "gst_event_new_step")] #[allow(clippy::new_ret_no_self)] pub fn new>( amount: V, @@ -1176,6 +1223,7 @@ impl Step { } impl Step { + #[doc(alias = "gst_event_parse_step")] pub fn get(&self) -> (GenericFormattedValue, f64, bool, bool) { unsafe { let mut fmt = mem::MaybeUninit::uninit(); @@ -1208,6 +1256,7 @@ impl Step { declare_concrete_event!(Reconfigure, T); impl Reconfigure { + #[doc(alias = "gst_event_new_reconfigure")] #[allow(clippy::new_ret_no_self)] pub fn new() -> Event { skip_assert_initialized!(); @@ -1222,6 +1271,7 @@ impl Reconfigure { declare_concrete_event!(TocSelect, T); impl TocSelect { + #[doc(alias = "gst_event_new_toc_select")] #[allow(clippy::new_ret_no_self)] pub fn new(uid: &str) -> Event { skip_assert_initialized!(); @@ -1255,6 +1305,7 @@ declare_concrete_event!(SelectStreams, T); impl SelectStreams { #[cfg(any(feature = "v1_10", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))] + #[doc(alias = "gst_event_new_select_streams")] #[allow(clippy::new_ret_no_self)] pub fn new(streams: &[&str]) -> Event { skip_assert_initialized!(); @@ -1295,6 +1346,7 @@ declare_concrete_event!(InstantRateSyncTime, T); impl InstantRateSyncTime { #[cfg(any(feature = "v1_18", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))] + #[doc(alias = "gst_event_new_instant_rate_sync_time")] #[allow(clippy::new_ret_no_self)] pub fn new( rate_multiplier: f64, @@ -1348,6 +1400,7 @@ impl InstantRateSyncTime { declare_concrete_event!(CustomUpstream, T); impl CustomUpstream { + #[doc(alias = "gst_event_new_custom")] #[allow(clippy::new_ret_no_self)] pub fn new(structure: crate::Structure) -> Event { skip_assert_initialized!(); @@ -1362,6 +1415,7 @@ impl CustomUpstream { declare_concrete_event!(CustomDownstream, T); impl CustomDownstream { + #[doc(alias = "gst_event_new_custom")] #[allow(clippy::new_ret_no_self)] pub fn new(structure: crate::Structure) -> Event { skip_assert_initialized!(); @@ -1376,6 +1430,7 @@ impl CustomDownstream { declare_concrete_event!(CustomDownstreamOob, T); impl CustomDownstreamOob { + #[doc(alias = "gst_event_new_custom")] #[allow(clippy::new_ret_no_self)] pub fn new(structure: crate::Structure) -> Event { skip_assert_initialized!(); @@ -1390,6 +1445,7 @@ impl CustomDownstreamOob { declare_concrete_event!(@sticky CustomDownstreamSticky, T); impl CustomDownstreamSticky { + #[doc(alias = "gst_event_new_custom")] #[allow(clippy::new_ret_no_self)] pub fn new(structure: crate::Structure) -> Event { skip_assert_initialized!(); @@ -1404,6 +1460,7 @@ impl CustomDownstreamSticky { declare_concrete_event!(CustomBoth, T); impl CustomBoth { + #[doc(alias = "gst_event_new_custom")] #[allow(clippy::new_ret_no_self)] pub fn new(structure: crate::Structure) -> Event { skip_assert_initialized!(); @@ -1418,6 +1475,7 @@ impl CustomBoth { declare_concrete_event!(CustomBothOob, T); impl CustomBothOob { + #[doc(alias = "gst_event_new_custom")] #[allow(clippy::new_ret_no_self)] pub fn new(structure: crate::Structure) -> Event { skip_assert_initialized!(); @@ -1476,6 +1534,7 @@ impl<'a> EventBuilder<'a> { macro_rules! event_builder_generic_impl { ($new_fn:expr) => { + #[doc(alias = "gst_event_set_seqnum")] #[allow(clippy::needless_update)] pub fn seqnum(self, seqnum: Seqnum) -> Self { Self { @@ -1484,6 +1543,7 @@ macro_rules! event_builder_generic_impl { } } + #[doc(alias = "gst_event_set_running_time_offset")] #[allow(clippy::needless_update)] pub fn running_time_offset(self, running_time_offset: i64) -> Self { Self { diff --git a/gstreamer/src/message.rs b/gstreamer/src/message.rs index a4196d397..843782bce 100644 --- a/gstreamer/src/message.rs +++ b/gstreamer/src/message.rs @@ -249,6 +249,7 @@ macro_rules! declare_concrete_message( declare_concrete_message!(Eos); impl<'a> Eos<'a> { + #[doc(alias = "gst_message_new_eos")] #[allow(clippy::new_ret_no_self)] pub fn new() -> Message { skip_assert_initialized!(); @@ -263,6 +264,7 @@ impl<'a> Eos<'a> { declare_concrete_message!(Error); impl<'a> Error<'a> { + #[doc(alias = "gst_message_new_error")] #[allow(clippy::new_ret_no_self)] pub fn new(error: T, message: &str) -> Message { skip_assert_initialized!(); @@ -287,6 +289,7 @@ impl<'a> Error<'a> { } #[doc(alias = "get_debug")] + #[doc(alias = "gst_message_parse_error")] pub fn debug(&self) -> Option { unsafe { let mut debug = ptr::null_mut(); @@ -318,6 +321,7 @@ impl<'a> Error<'a> { declare_concrete_message!(Warning); impl<'a> Warning<'a> { + #[doc(alias = "gst_message_new_warning")] #[allow(clippy::new_ret_no_self)] pub fn new(error: T, message: &str) -> Message { skip_assert_initialized!(); @@ -330,6 +334,7 @@ impl<'a> Warning<'a> { } #[doc(alias = "get_error")] + #[doc(alias = "gst_message_parse_warning")] pub fn error(&self) -> glib::Error { unsafe { let mut error = ptr::null_mut(); @@ -341,6 +346,7 @@ impl<'a> Warning<'a> { } #[doc(alias = "get_debug")] + #[doc(alias = "gst_message_parse_warning")] pub fn debug(&self) -> Option { unsafe { let mut debug = ptr::null_mut(); @@ -354,12 +360,12 @@ impl<'a> Warning<'a> { #[cfg(any(feature = "v1_10", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))] #[doc(alias = "get_details")] - #[doc(alias = "gst_message_parse_error_details")] + #[doc(alias = "gst_message_parse_warning_details")] pub fn details(&self) -> Option<&StructureRef> { unsafe { let mut details = ptr::null(); - ffi::gst_message_parse_error_details(self.as_mut_ptr(), &mut details); + ffi::gst_message_parse_warning_details(self.as_mut_ptr(), &mut details); if details.is_null() { None @@ -372,6 +378,7 @@ impl<'a> Warning<'a> { declare_concrete_message!(Info); impl<'a> Info<'a> { + #[doc(alias = "gst_message_new_info")] #[allow(clippy::new_ret_no_self)] pub fn new(error: T, message: &str) -> Message { skip_assert_initialized!(); @@ -384,6 +391,7 @@ impl<'a> Info<'a> { } #[doc(alias = "get_error")] + #[doc(alias = "gst_message_parse_info")] pub fn error(&self) -> glib::Error { unsafe { let mut error = ptr::null_mut(); @@ -395,6 +403,7 @@ impl<'a> Info<'a> { } #[doc(alias = "get_debug")] + #[doc(alias = "gst_message_parse_info")] pub fn debug(&self) -> Option { unsafe { let mut debug = ptr::null_mut(); @@ -408,12 +417,12 @@ impl<'a> Info<'a> { #[cfg(any(feature = "v1_10", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))] #[doc(alias = "get_details")] - #[doc(alias = "gst_message_parse_error_details")] + #[doc(alias = "gst_message_parse_info_details")] pub fn details(&self) -> Option<&StructureRef> { unsafe { let mut details = ptr::null(); - ffi::gst_message_parse_error_details(self.as_mut_ptr(), &mut details); + ffi::gst_message_parse_info_details(self.as_mut_ptr(), &mut details); if details.is_null() { None @@ -426,6 +435,7 @@ impl<'a> Info<'a> { declare_concrete_message!(Tag); impl<'a> Tag<'a> { + #[doc(alias = "gst_message_new_tag")] #[allow(clippy::new_ret_no_self)] pub fn new(tags: &TagList) -> Message { skip_assert_initialized!(); @@ -438,6 +448,7 @@ impl<'a> Tag<'a> { } #[doc(alias = "get_tags")] + #[doc(alias = "gst_message_parse_tag")] pub fn tags(&self) -> TagList { unsafe { let mut tags = ptr::null_mut(); @@ -449,6 +460,7 @@ impl<'a> Tag<'a> { declare_concrete_message!(Buffering); impl<'a> Buffering<'a> { + #[doc(alias = "gst_message_new_buffering")] #[allow(clippy::new_ret_no_self)] pub fn new(percent: i32) -> Message { skip_assert_initialized!(); @@ -461,6 +473,7 @@ impl<'a> Buffering<'a> { } #[doc(alias = "get_percent")] + #[doc(alias = "gst_message_parse_buffering")] pub fn percent(&self) -> i32 { unsafe { let mut p = mem::MaybeUninit::uninit(); @@ -498,6 +511,7 @@ impl<'a> Buffering<'a> { declare_concrete_message!(StateChanged); impl<'a> StateChanged<'a> { + #[doc(alias = "gst_message_new_state_changed")] #[allow(clippy::new_ret_no_self)] pub fn new(old: crate::State, new: crate::State, pending: crate::State) -> Message { skip_assert_initialized!(); @@ -514,6 +528,7 @@ impl<'a> StateChanged<'a> { } #[doc(alias = "get_old")] + #[doc(alias = "gst_message_parse_state_changed")] pub fn old(&self) -> crate::State { unsafe { let mut state = mem::MaybeUninit::uninit(); @@ -530,6 +545,7 @@ impl<'a> StateChanged<'a> { } #[doc(alias = "get_current")] + #[doc(alias = "gst_message_parse_state_changed")] pub fn current(&self) -> crate::State { unsafe { let mut state = mem::MaybeUninit::uninit(); @@ -546,6 +562,7 @@ impl<'a> StateChanged<'a> { } #[doc(alias = "get_pending")] + #[doc(alias = "gst_message_parse_state_changed")] pub fn pending(&self) -> crate::State { unsafe { let mut state = mem::MaybeUninit::uninit(); @@ -564,6 +581,7 @@ impl<'a> StateChanged<'a> { declare_concrete_message!(StateDirty); impl<'a> StateDirty<'a> { + #[doc(alias = "gst_message_new_state_dirty")] #[allow(clippy::new_ret_no_self)] pub fn new() -> Message { skip_assert_initialized!(); @@ -578,6 +596,7 @@ impl<'a> StateDirty<'a> { declare_concrete_message!(StepDone); impl<'a> StepDone<'a> { + #[doc(alias = "gst_message_new_step_done")] #[allow(clippy::new_ret_no_self)] pub fn new>( amount: V, @@ -618,6 +637,7 @@ impl<'a> StepDone<'a> { ) } + #[doc(alias = "gst_message_parse_step_done")] pub fn get( &self, ) -> ( @@ -668,6 +688,7 @@ impl<'a> StepDone<'a> { declare_concrete_message!(ClockProvide); impl<'a> ClockProvide<'a> { + #[doc(alias = "gst_message_new_clock_provide")] #[allow(clippy::new_ret_no_self)] pub fn new(clock: &crate::Clock, ready: bool) -> Message { skip_assert_initialized!(); @@ -692,6 +713,7 @@ impl<'a> ClockProvide<'a> { } #[doc(alias = "get_ready")] + #[doc(alias = "gst_message_parse_clock_provide")] pub fn is_ready(&self) -> bool { unsafe { let mut ready = mem::MaybeUninit::uninit(); @@ -709,6 +731,7 @@ impl<'a> ClockProvide<'a> { declare_concrete_message!(ClockLost); impl<'a> ClockLost<'a> { + #[doc(alias = "gst_message_new_clock_lost")] #[allow(clippy::new_ret_no_self)] pub fn new(clock: &crate::Clock) -> Message { skip_assert_initialized!(); @@ -735,6 +758,7 @@ impl<'a> ClockLost<'a> { declare_concrete_message!(NewClock); impl<'a> NewClock<'a> { + #[doc(alias = "gst_message_new_new_clock")] #[allow(clippy::new_ret_no_self)] pub fn new(clock: &crate::Clock) -> Message { skip_assert_initialized!(); @@ -761,6 +785,7 @@ impl<'a> NewClock<'a> { declare_concrete_message!(StructureChange); impl<'a> StructureChange<'a> { + #[doc(alias = "gst_message_new_structure_change")] #[allow(clippy::new_ret_no_self)] pub fn new(type_: crate::StructureChangeType, owner: &crate::Element, busy: bool) -> Message { skip_assert_initialized!(); @@ -776,6 +801,7 @@ impl<'a> StructureChange<'a> { StructureChangeBuilder::new(type_, owner, busy) } + #[doc(alias = "gst_message_parse_structure_change")] pub fn get(&self) -> (crate::StructureChangeType, crate::Element, bool) { unsafe { let mut type_ = mem::MaybeUninit::uninit(); @@ -800,6 +826,7 @@ impl<'a> StructureChange<'a> { declare_concrete_message!(StreamStatus); impl<'a> StreamStatus<'a> { + #[doc(alias = "gst_message_new_stream_status")] #[allow(clippy::new_ret_no_self)] pub fn new(type_: crate::StreamStatusType, owner: &crate::Element) -> Message { skip_assert_initialized!(); @@ -811,6 +838,7 @@ impl<'a> StreamStatus<'a> { StreamStatusBuilder::new(type_, owner) } + #[doc(alias = "gst_message_parse_stream_status")] pub fn get(&self) -> (crate::StreamStatusType, crate::Element) { unsafe { let mut type_ = mem::MaybeUninit::uninit(); @@ -835,6 +863,7 @@ impl<'a> StreamStatus<'a> { declare_concrete_message!(Application); impl<'a> Application<'a> { + #[doc(alias = "gst_message_new_application")] #[allow(clippy::new_ret_no_self)] pub fn new(structure: crate::Structure) -> Message { skip_assert_initialized!(); @@ -849,6 +878,7 @@ impl<'a> Application<'a> { declare_concrete_message!(Element); impl<'a> Element<'a> { + #[doc(alias = "gst_message_new_element")] #[allow(clippy::new_ret_no_self)] pub fn new(structure: crate::Structure) -> Message { skip_assert_initialized!(); @@ -863,6 +893,7 @@ impl<'a> Element<'a> { declare_concrete_message!(SegmentStart); impl<'a> SegmentStart<'a> { + #[doc(alias = "gst_message_new_segment_start")] #[allow(clippy::new_ret_no_self)] pub fn new>(position: V) -> Message { skip_assert_initialized!(); @@ -875,6 +906,7 @@ impl<'a> SegmentStart<'a> { SegmentStartBuilder::new(position) } + #[doc(alias = "gst_message_parse_segment_start")] pub fn get(&self) -> GenericFormattedValue { unsafe { let mut format = mem::MaybeUninit::uninit(); @@ -893,6 +925,7 @@ impl<'a> SegmentStart<'a> { declare_concrete_message!(SegmentDone); impl<'a> SegmentDone<'a> { + #[doc(alias = "gst_message_new_segment_done")] #[allow(clippy::new_ret_no_self)] pub fn new>(position: V) -> Message { skip_assert_initialized!(); @@ -905,6 +938,7 @@ impl<'a> SegmentDone<'a> { SegmentDoneBuilder::new(position) } + #[doc(alias = "gst_message_parse_segment_done")] pub fn get(&self) -> GenericFormattedValue { unsafe { let mut format = mem::MaybeUninit::uninit(); @@ -923,6 +957,7 @@ impl<'a> SegmentDone<'a> { declare_concrete_message!(DurationChanged); impl<'a> DurationChanged<'a> { + #[doc(alias = "gst_message_new_duration_changed")] #[allow(clippy::new_ret_no_self)] pub fn new() -> Message { skip_assert_initialized!(); @@ -937,6 +972,7 @@ impl<'a> DurationChanged<'a> { declare_concrete_message!(Latency); impl<'a> Latency<'a> { + #[doc(alias = "gst_message_new_latency")] #[allow(clippy::new_ret_no_self)] pub fn new() -> Message { skip_assert_initialized!(); @@ -951,6 +987,7 @@ impl<'a> Latency<'a> { declare_concrete_message!(AsyncStart); impl<'a> AsyncStart<'a> { + #[doc(alias = "gst_message_new_async_start")] #[allow(clippy::new_ret_no_self)] pub fn new() -> Message { skip_assert_initialized!(); @@ -965,6 +1002,7 @@ impl<'a> AsyncStart<'a> { declare_concrete_message!(AsyncDone); impl<'a> AsyncDone<'a> { + #[doc(alias = "gst_message_new_async_done")] #[allow(clippy::new_ret_no_self)] pub fn new(running_time: impl Into>) -> Message { skip_assert_initialized!(); @@ -977,6 +1015,7 @@ impl<'a> AsyncDone<'a> { } #[doc(alias = "get_running_time")] + #[doc(alias = "gst_message_parse_async_done")] pub fn running_time(&self) -> Option { unsafe { let mut running_time = mem::MaybeUninit::uninit(); @@ -990,6 +1029,7 @@ impl<'a> AsyncDone<'a> { declare_concrete_message!(RequestState); impl<'a> RequestState<'a> { + #[doc(alias = "gst_message_new_request_state")] #[allow(clippy::new_ret_no_self)] pub fn new(state: crate::State) -> Message { skip_assert_initialized!(); @@ -1002,6 +1042,7 @@ impl<'a> RequestState<'a> { } #[doc(alias = "get_requested_state")] + #[doc(alias = "gst_message_parse_request_state")] pub fn requested_state(&self) -> crate::State { unsafe { let mut state = mem::MaybeUninit::uninit(); @@ -1015,6 +1056,7 @@ impl<'a> RequestState<'a> { declare_concrete_message!(StepStart); impl<'a> StepStart<'a> { + #[doc(alias = "gst_message_new_step_start")] #[allow(clippy::new_ret_no_self)] pub fn new>( active: bool, @@ -1038,6 +1080,7 @@ impl<'a> StepStart<'a> { StepStartBuilder::new(active, amount.into(), rate, flush, intermediate) } + #[doc(alias = "gst_message_parse_step_start")] pub fn get(&self) -> (bool, GenericFormattedValue, f64, bool, bool) { unsafe { let mut active = mem::MaybeUninit::uninit(); @@ -1073,6 +1116,7 @@ impl<'a> StepStart<'a> { declare_concrete_message!(Qos); impl<'a> Qos<'a> { + #[doc(alias = "gst_message_new_qos")] #[allow(clippy::new_ret_no_self)] pub fn new( live: bool, @@ -1095,6 +1139,7 @@ impl<'a> Qos<'a> { QosBuilder::new(live) } + #[doc(alias = "gst_message_parse_qos")] pub fn get( &self, ) -> ( @@ -1184,6 +1229,7 @@ impl<'a> Qos<'a> { declare_concrete_message!(Progress); impl<'a> Progress<'a> { + #[doc(alias = "gst_message_new_progress")] #[allow(clippy::new_ret_no_self)] pub fn new(type_: crate::ProgressType, code: &'a str, text: &'a str) -> Message { skip_assert_initialized!(); @@ -1199,6 +1245,7 @@ impl<'a> Progress<'a> { ProgressBuilder::new(type_, code, text) } + #[doc(alias = "gst_message_parse_progress")] pub fn get(&self) -> (crate::ProgressType, &'a str, &'a str) { unsafe { let mut type_ = mem::MaybeUninit::uninit(); @@ -1224,6 +1271,7 @@ declare_concrete_message!(Toc); impl<'a> Toc<'a> { // FIXME could use false for updated as default // Even better: use an enum for updated so that it is more explicit than true / false + #[doc(alias = "gst_message_new_toc")] #[allow(clippy::new_ret_no_self)] pub fn new(toc: &crate::Toc, updated: bool) -> Message { skip_assert_initialized!(); @@ -1249,6 +1297,7 @@ impl<'a> Toc<'a> { declare_concrete_message!(ResetTime); impl<'a> ResetTime<'a> { + #[doc(alias = "gst_message_new_reset_time")] #[allow(clippy::new_ret_no_self)] pub fn new(running_time: crate::ClockTime) -> Message { skip_assert_initialized!(); @@ -1261,6 +1310,7 @@ impl<'a> ResetTime<'a> { } #[doc(alias = "get_running_time")] + #[doc(alias = "gst_message_parse_reset_time")] pub fn running_time(&self) -> crate::ClockTime { unsafe { let mut running_time = mem::MaybeUninit::uninit(); @@ -1274,6 +1324,7 @@ impl<'a> ResetTime<'a> { declare_concrete_message!(StreamStart); impl<'a> StreamStart<'a> { + #[doc(alias = "gst_message_new_stream_start")] #[allow(clippy::new_ret_no_self)] pub fn new() -> Message { skip_assert_initialized!(); @@ -1310,6 +1361,7 @@ impl<'a> StreamStart<'a> { declare_concrete_message!(NeedContext); impl<'a> NeedContext<'a> { + #[doc(alias = "gst_message_new_need_context")] #[allow(clippy::new_ret_no_self)] pub fn new(context_type: &str) -> Message { skip_assert_initialized!(); @@ -1336,6 +1388,7 @@ impl<'a> NeedContext<'a> { declare_concrete_message!(HaveContext); impl<'a> HaveContext<'a> { + #[doc(alias = "gst_message_new_have_context")] #[allow(clippy::new_ret_no_self)] pub fn new(context: crate::Context) -> Message { skip_assert_initialized!(); @@ -1360,6 +1413,7 @@ impl<'a> HaveContext<'a> { declare_concrete_message!(DeviceAdded); impl<'a> DeviceAdded<'a> { + #[doc(alias = "gst_message_new_device_added")] #[allow(clippy::new_ret_no_self)] pub fn new(device: &crate::Device) -> Message { skip_assert_initialized!(); @@ -1386,6 +1440,7 @@ impl<'a> DeviceAdded<'a> { declare_concrete_message!(DeviceRemoved); impl<'a> DeviceRemoved<'a> { + #[doc(alias = "gst_message_new_device_removed")] #[allow(clippy::new_ret_no_self)] pub fn new(device: &crate::Device) -> Message { skip_assert_initialized!(); @@ -1416,6 +1471,7 @@ declare_concrete_message!(PropertyNotify); #[cfg(any(feature = "v1_10", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))] impl<'a> PropertyNotify<'a> { + #[doc(alias = "gst_message_new_property_notify")] #[allow(clippy::new_ret_no_self)] pub fn new(property_name: &str) -> Message { skip_assert_initialized!(); @@ -1427,6 +1483,7 @@ impl<'a> PropertyNotify<'a> { PropertyNotifyBuilder::new(property_name) } + #[doc(alias = "gst_message_parse_property_notify")] pub fn get(&self) -> (Object, &str, Option<&'a glib::Value>) { unsafe { let mut object = ptr::null_mut(); @@ -1459,6 +1516,7 @@ declare_concrete_message!(StreamCollection); #[cfg(any(feature = "v1_10", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))] impl<'a> StreamCollection<'a> { + #[doc(alias = "gst_message_new_stream_collection")] #[allow(clippy::new_ret_no_self)] pub fn new(collection: &crate::StreamCollection) -> Message { skip_assert_initialized!(); @@ -1489,6 +1547,7 @@ declare_concrete_message!(StreamsSelected); #[cfg(any(feature = "v1_10", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))] impl<'a> StreamsSelected<'a> { + #[doc(alias = "gst_message_new_streams_selected")] #[allow(clippy::new_ret_no_self)] pub fn new(collection: &crate::StreamCollection) -> Message { skip_assert_initialized!(); @@ -1501,6 +1560,7 @@ impl<'a> StreamsSelected<'a> { } #[doc(alias = "get_stream_collection")] + #[doc(alias = "gst_message_parse_streams_selected")] pub fn stream_collection(&self) -> crate::StreamCollection { unsafe { let mut collection = ptr::null_mut(); @@ -1536,6 +1596,7 @@ declare_concrete_message!(Redirect); #[cfg(any(feature = "v1_10", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_10")))] impl<'a> Redirect<'a> { + #[doc(alias = "gst_message_new_redirect")] #[allow(clippy::new_ret_no_self)] pub fn new(location: &str) -> Message { skip_assert_initialized!(); @@ -1549,6 +1610,7 @@ impl<'a> Redirect<'a> { #[doc(alias = "get_entries")] #[doc(alias = "gst_message_get_num_redirect_entries")] + #[doc(alias = "gst_message_parse_redirect_entry")] pub fn entries(&self) -> Vec<(&str, Option, Option<&StructureRef>)> { unsafe { let n = ffi::gst_message_get_num_redirect_entries(self.as_mut_ptr()); @@ -1590,6 +1652,7 @@ declare_concrete_message!(DeviceChanged); #[cfg(any(feature = "v1_16", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_16")))] impl<'a> DeviceChanged<'a> { + #[doc(alias = "gst_message_new_device_changed")] #[allow(clippy::new_ret_no_self)] pub fn new(device: &'a crate::Device, changed_device: &'a crate::Device) -> Message { skip_assert_initialized!(); @@ -1628,6 +1691,7 @@ declare_concrete_message!(InstantRateRequest); #[cfg(any(feature = "v1_18", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))] impl<'a> InstantRateRequest<'a> { + #[doc(alias = "gst_message_new_instant_rate_request")] #[allow(clippy::new_ret_no_self)] pub fn new(rate_multiplier: f64) -> Message { skip_assert_initialized!(); @@ -1710,6 +1774,7 @@ macro_rules! message_builder_generic_impl { } } + #[doc(alias = "gst_message_set_seqnum")] #[allow(clippy::needless_update)] pub fn seqnum(self, seqnum: Seqnum) -> Self { Self { diff --git a/gstreamer/src/query.rs b/gstreamer/src/query.rs index 90a6519ef..12b975134 100644 --- a/gstreamer/src/query.rs +++ b/gstreamer/src/query.rs @@ -31,6 +31,7 @@ impl QueryRef { } #[doc(alias = "get_mut_structure")] + #[doc(alias = "gst_query_writable_structure")] pub fn structure_mut(&mut self) -> &mut StructureRef { unsafe { let structure = ffi::gst_query_writable_structure(self.as_mut_ptr()); @@ -38,14 +39,17 @@ impl QueryRef { } } + #[doc(alias = "GST_QUERY_IS_DOWNSTREAM")] pub fn is_downstream(&self) -> bool { unsafe { ((*self.as_ptr()).type_ as u32) & ffi::GST_QUERY_TYPE_DOWNSTREAM != 0 } } + #[doc(alias = "GST_QUERY_IS_UPSTREAM")] pub fn is_upstream(&self) -> bool { unsafe { ((*self.as_ptr()).type_ as u32) & ffi::GST_QUERY_TYPE_UPSTREAM != 0 } } + #[doc(alias = "GST_QUERY_IS_SERIALIZED")] pub fn is_serialized(&self) -> bool { unsafe { ((*self.as_ptr()).type_ as u32) & ffi::GST_QUERY_TYPE_SERIALIZED != 0 } } @@ -229,6 +233,7 @@ impl Position { impl Position { #[doc(alias = "get_result")] + #[doc(alias = "gst_query_parse_position")] pub fn result(&self) -> GenericFormattedValue { unsafe { let mut fmt = mem::MaybeUninit::uninit(); @@ -241,6 +246,7 @@ impl Position { } #[doc(alias = "get_format")] + #[doc(alias = "gst_query_parse_position")] pub fn format(&self) -> crate::Format { unsafe { let mut fmt = mem::MaybeUninit::uninit(); @@ -274,6 +280,7 @@ impl Duration { impl Duration { #[doc(alias = "get_result")] + #[doc(alias = "gst_query_parse_duration")] pub fn result(&self) -> GenericFormattedValue { unsafe { let mut fmt = mem::MaybeUninit::uninit(); @@ -286,6 +293,7 @@ impl Duration { } #[doc(alias = "get_format")] + #[doc(alias = "gst_query_parse_duration")] pub fn format(&self) -> crate::Format { unsafe { let mut fmt = mem::MaybeUninit::uninit(); @@ -325,6 +333,7 @@ impl Default for Latency { impl Latency { #[doc(alias = "get_result")] + #[doc(alias = "gst_query_parse_latency")] pub fn result(&self) -> (bool, crate::ClockTime, Option) { unsafe { let mut live = mem::MaybeUninit::uninit(); @@ -377,6 +386,7 @@ impl Seeking { impl Seeking { #[doc(alias = "get_result")] + #[doc(alias = "gst_query_parse_seeking")] pub fn result(&self) -> (bool, GenericFormattedValue, GenericFormattedValue) { unsafe { let mut fmt = mem::MaybeUninit::uninit(); @@ -400,6 +410,7 @@ impl Seeking { } #[doc(alias = "get_format")] + #[doc(alias = "gst_query_parse_seeking")] pub fn format(&self) -> crate::Format { unsafe { let mut fmt = mem::MaybeUninit::uninit(); @@ -448,6 +459,7 @@ impl Segment { impl Segment { #[doc(alias = "get_result")] + #[doc(alias = "gst_query_parse_segment")] pub fn result(&self) -> (f64, GenericFormattedValue, GenericFormattedValue) { unsafe { let mut rate = mem::MaybeUninit::uninit(); @@ -471,6 +483,7 @@ impl Segment { } #[doc(alias = "get_format")] + #[doc(alias = "gst_query_parse_segment")] pub fn format(&self) -> crate::Format { unsafe { let mut fmt = mem::MaybeUninit::uninit(); @@ -525,6 +538,7 @@ impl Convert { impl Convert { #[doc(alias = "get_result")] + #[doc(alias = "gst_query_parse_convert")] pub fn result(&self) -> (GenericFormattedValue, GenericFormattedValue) { unsafe { let mut src_fmt = mem::MaybeUninit::uninit(); @@ -546,6 +560,7 @@ impl Convert { } } + #[doc(alias = "gst_query_parse_convert")] pub fn get(&self) -> (GenericFormattedValue, crate::Format) { unsafe { let mut src_fmt = mem::MaybeUninit::uninit(); @@ -602,6 +617,8 @@ impl Default for Formats { impl Formats { #[doc(alias = "get_result")] + #[doc(alias = "gst_query_parse_n_formats")] + #[doc(alias = "gst_query_parse_nth_format")] pub fn result(&self) -> Vec { unsafe { let mut n = mem::MaybeUninit::uninit(); @@ -621,6 +638,7 @@ impl Formats { } impl Formats { + #[doc(alias = "gst_query_set_formats")] #[doc(alias = "gst_query_set_formatsv")] pub fn set(&mut self, formats: &[crate::Format]) { unsafe { @@ -645,6 +663,7 @@ impl Buffering { impl Buffering { #[doc(alias = "get_format")] + #[doc(alias = "gst_query_parse_buffering_range")] pub fn format(&self) -> crate::Format { unsafe { let mut fmt = mem::MaybeUninit::uninit(); @@ -730,6 +749,7 @@ impl Buffering { #[doc(alias = "get_ranges")] #[doc(alias = "gst_query_get_n_buffering_ranges")] + #[doc(alias = "gst_query_parse_nth_buffering_range")] pub fn ranges(&self) -> Vec<(GenericFormattedValue, GenericFormattedValue)> { unsafe { let mut fmt = mem::MaybeUninit::uninit(); @@ -767,12 +787,14 @@ impl Buffering { } impl Buffering { + #[doc(alias = "gst_query_set_buffering_percent")] pub fn set_percent(&mut self, busy: bool, percent: i32) { unsafe { ffi::gst_query_set_buffering_percent(self.0.as_mut_ptr(), busy.into_glib(), percent); } } + #[doc(alias = "gst_query_set_buffering_range")] pub fn set_range>( &mut self, start: V, @@ -796,6 +818,7 @@ impl Buffering { } } + #[doc(alias = "gst_query_set_buffering_stats")] pub fn set_stats( &mut self, mode: crate::BufferingMode, @@ -815,6 +838,7 @@ impl Buffering { } } + #[doc(alias = "gst_query_add_buffering_range")] pub fn add_buffering_ranges + Copy>( &mut self, ranges: &[(V, V)], @@ -900,6 +924,8 @@ impl Uri { } } + #[doc(alias = "gst_query_set_uri_redirection")] + #[doc(alias = "gst_query_set_uri_redirection_permanent")] pub fn set_redirection(&mut self, uri: &str, permanent: bool) { unsafe { ffi::gst_query_set_uri_redirection(self.0.as_mut_ptr(), uri.to_glib_none().0); @@ -926,6 +952,7 @@ impl Allocation { } impl Allocation { + #[doc(alias = "gst_query_parse_allocation")] pub fn get(&self) -> (&crate::CapsRef, bool) { unsafe { let mut caps = ptr::null_mut(); @@ -939,6 +966,7 @@ impl Allocation { } } + #[doc(alias = "gst_query_parse_allocation")] pub fn get_owned(&self) -> (crate::Caps, bool) { unsafe { let (caps, need_pool) = self.get(); @@ -948,6 +976,7 @@ impl Allocation { #[doc(alias = "gst_allocation_params")] #[doc(alias = "gst_query_get_n_allocation_params")] + #[doc(alias = "gst_query_parse_nth_allocation_param")] pub fn allocation_params(&self) -> Vec<(Option, crate::AllocationParams)> { unsafe { let n = ffi::gst_query_get_n_allocation_params(self.0.as_ptr()); @@ -970,6 +999,7 @@ impl Allocation { #[doc(alias = "get_allocation_pools")] #[doc(alias = "gst_query_get_n_allocation_pools")] + #[doc(alias = "gst_query_parse_nth_allocation_pool")] pub fn allocation_pools(&self) -> Vec<(Option, u32, u32, u32)> { unsafe { let n = ffi::gst_query_get_n_allocation_pools(self.0.as_ptr()); @@ -1002,6 +1032,7 @@ impl Allocation { #[doc(alias = "get_allocation_metas")] #[doc(alias = "gst_query_get_n_allocation_metas")] + #[doc(alias = "gst_query_parse_nth_allocation_meta")] pub fn allocation_metas(&self) -> Vec<(glib::Type, Option<&crate::StructureRef>)> { unsafe { let n = ffi::gst_query_get_n_allocation_metas(self.0.as_ptr()); @@ -1226,6 +1257,7 @@ impl Scheduling { } #[doc(alias = "get_result")] + #[doc(alias = "gst_query_parse_scheduling")] pub fn result(&self) -> (crate::SchedulingFlags, i32, i32, i32) { unsafe { let mut flags = mem::MaybeUninit::uninit(); @@ -1252,6 +1284,7 @@ impl Scheduling { } impl Scheduling { + #[doc(alias = "gst_query_add_scheduling_mode")] pub fn add_scheduling_modes(&mut self, modes: &[crate::PadMode]) { unsafe { for mode in modes { @@ -1299,6 +1332,7 @@ impl AcceptCaps { } #[doc(alias = "get_caps_owned")] + #[doc(alias = "gst_query_parse_accept_caps")] pub fn caps_owned(&self) -> crate::Caps { unsafe { from_glib_none(self.caps().as_ptr()) } } @@ -1315,6 +1349,7 @@ impl AcceptCaps { } impl AcceptCaps { + #[doc(alias = "gst_query_set_accept_caps_result")] pub fn set_result(&mut self, accepted: bool) { unsafe { ffi::gst_query_set_accept_caps_result(self.0.as_mut_ptr(), accepted.into_glib()); @@ -1337,6 +1372,7 @@ impl Caps { impl Caps { #[doc(alias = "get_filter")] + #[doc(alias = "gst_query_parse_caps")] pub fn filter(&self) -> Option<&crate::CapsRef> { unsafe { let mut caps = ptr::null_mut(); @@ -1350,6 +1386,7 @@ impl Caps { } #[doc(alias = "get_filter_owned")] + #[doc(alias = "gst_query_parse_caps")] pub fn filter_owned(&self) -> Option { unsafe { self.filter().map(|caps| from_glib_none(caps.as_ptr())) } } @@ -1369,12 +1406,14 @@ impl Caps { } #[doc(alias = "get_result_owned")] + #[doc(alias = "gst_query_parse_caps_result")] pub fn result_owned(&self) -> Option { unsafe { self.result().map(|caps| from_glib_none(caps.as_ptr())) } } } impl Caps { + #[doc(alias = "gst_query_set_caps_result")] pub fn set_result(&mut self, caps: &crate::Caps) { unsafe { ffi::gst_query_set_caps_result(self.0.as_mut_ptr(), caps.as_mut_ptr()); @@ -1426,6 +1465,7 @@ impl Context { } #[doc(alias = "get_context_owned")] + #[doc(alias = "gst_query_parse_context")] pub fn context_owned(&self) -> Option { unsafe { self.context()