gstreamer/
message.rs

1// Take a look at the license at the top of the repository in the LICENSE file.
2
3use std::{borrow::Borrow, ffi::CStr, fmt, mem, num::NonZeroU32, ops::Deref, ops::DerefMut, ptr};
4
5use glib::{
6    translate::*,
7    value::{SendValue, ValueType},
8};
9use smallvec::SmallVec;
10
11use crate::{
12    ffi,
13    format::{CompatibleFormattedValue, FormattedValue},
14    prelude::*,
15    structure::*,
16    GenericFormattedValue, GroupId, MessageType, Object, Seqnum, TagList,
17};
18
19mini_object_wrapper!(Message, MessageRef, ffi::GstMessage, || {
20    ffi::gst_message_get_type()
21});
22
23impl MessageRef {
24    #[doc(alias = "get_src")]
25    #[inline]
26    pub fn src(&self) -> Option<&Object> {
27        unsafe {
28            if (*self.as_ptr()).src.is_null() {
29                None
30            } else {
31                Some(Object::from_glib_ptr_borrow(&(*self.as_ptr()).src))
32            }
33        }
34    }
35
36    #[doc(alias = "get_seqnum")]
37    #[doc(alias = "gst_message_get_seqnum")]
38    pub fn seqnum(&self) -> Seqnum {
39        unsafe {
40            let seqnum = ffi::gst_message_get_seqnum(self.as_mut_ptr());
41
42            if seqnum == 0 {
43                // seqnum for this message is invalid. This can happen with buggy elements
44                // overriding the seqnum with GST_SEQNUM_INVALID instead of the expected seqnum.
45                // As a workaround, let's generate an unused valid seqnum.
46                let next = Seqnum::next();
47
48                crate::warning!(
49                    crate::CAT_RUST,
50                    "get_seqnum detected invalid seqnum, returning next {:?}",
51                    next
52                );
53
54                return next;
55            }
56
57            Seqnum(NonZeroU32::new_unchecked(seqnum))
58        }
59    }
60
61    #[doc(alias = "gst_message_set_seqnum")]
62    pub fn set_seqnum(&self, seqnum: Seqnum) {
63        unsafe {
64            ffi::gst_message_set_seqnum(self.as_mut_ptr(), seqnum.0.get());
65        }
66    }
67
68    #[doc(alias = "get_structure")]
69    #[doc(alias = "gst_message_get_structure")]
70    #[inline]
71    pub fn structure(&self) -> Option<&StructureRef> {
72        unsafe {
73            let structure = ffi::gst_message_get_structure(self.as_mut_ptr());
74            if structure.is_null() {
75                None
76            } else {
77                Some(StructureRef::from_glib_borrow(structure))
78            }
79        }
80    }
81
82    #[doc(alias = "gst_message_writable_structure")]
83    #[inline]
84    pub fn structure_mut(&mut self) -> &mut StructureRef {
85        unsafe {
86            StructureRef::from_glib_borrow_mut(ffi::gst_message_writable_structure(
87                self.as_mut_ptr(),
88            ))
89        }
90    }
91
92    #[cfg(feature = "v1_26")]
93    #[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
94    #[doc(alias = "gst_message_writable_details")]
95    #[inline]
96    pub fn details(&self) -> Option<&StructureRef> {
97        unsafe {
98            let structure = ffi::gst_message_writable_details(self.as_mut_ptr());
99            if structure.is_null() {
100                None
101            } else {
102                Some(StructureRef::from_glib_borrow(structure))
103            }
104        }
105    }
106
107    #[cfg(feature = "v1_26")]
108    #[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
109    #[doc(alias = "gst_message_writable_details")]
110    #[inline]
111    pub fn details_mut(&mut self) -> &mut StructureRef {
112        unsafe {
113            StructureRef::from_glib_borrow_mut(ffi::gst_message_writable_details(self.as_mut_ptr()))
114        }
115    }
116
117    #[cfg(feature = "v1_26")]
118    #[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
119    #[doc(alias = "gst_message_set_details")]
120    #[inline]
121    pub fn set_details(&mut self, structure: Structure) {
122        unsafe {
123            ffi::gst_message_set_details(self.as_mut_ptr(), structure.into_glib_ptr());
124        }
125    }
126
127    #[doc(alias = "gst_message_has_name")]
128    #[inline]
129    pub fn has_name(&self, name: &str) -> bool {
130        self.structure().is_some_and(|s| s.has_name(name))
131    }
132
133    pub fn view(&self) -> MessageView<'_> {
134        unsafe {
135            let type_ = (*self.as_ptr()).type_;
136
137            match type_ {
138                ffi::GST_MESSAGE_EOS => Eos::view(self),
139                ffi::GST_MESSAGE_ERROR => Error::view(self),
140                ffi::GST_MESSAGE_WARNING => Warning::view(self),
141                ffi::GST_MESSAGE_INFO => Info::view(self),
142                ffi::GST_MESSAGE_TAG => Tag::view(self),
143                ffi::GST_MESSAGE_BUFFERING => Buffering::view(self),
144                ffi::GST_MESSAGE_STATE_CHANGED => StateChanged::view(self),
145                ffi::GST_MESSAGE_STATE_DIRTY => StateDirty::view(self),
146                ffi::GST_MESSAGE_STEP_DONE => StepDone::view(self),
147                ffi::GST_MESSAGE_CLOCK_PROVIDE => ClockProvide::view(self),
148                ffi::GST_MESSAGE_CLOCK_LOST => ClockLost::view(self),
149                ffi::GST_MESSAGE_NEW_CLOCK => NewClock::view(self),
150                ffi::GST_MESSAGE_STRUCTURE_CHANGE => StructureChange::view(self),
151                ffi::GST_MESSAGE_STREAM_STATUS => StreamStatus::view(self),
152                ffi::GST_MESSAGE_APPLICATION => Application::view(self),
153                ffi::GST_MESSAGE_ELEMENT => Element::view(self),
154                ffi::GST_MESSAGE_SEGMENT_START => SegmentStart::view(self),
155                ffi::GST_MESSAGE_SEGMENT_DONE => SegmentDone::view(self),
156                ffi::GST_MESSAGE_DURATION_CHANGED => DurationChanged::view(self),
157                ffi::GST_MESSAGE_LATENCY => Latency::view(self),
158                ffi::GST_MESSAGE_ASYNC_START => AsyncStart::view(self),
159                ffi::GST_MESSAGE_ASYNC_DONE => AsyncDone::view(self),
160                ffi::GST_MESSAGE_REQUEST_STATE => RequestState::view(self),
161                ffi::GST_MESSAGE_STEP_START => StepStart::view(self),
162                ffi::GST_MESSAGE_QOS => Qos::view(self),
163                ffi::GST_MESSAGE_PROGRESS => Progress::view(self),
164                ffi::GST_MESSAGE_TOC => Toc::view(self),
165                ffi::GST_MESSAGE_RESET_TIME => ResetTime::view(self),
166                ffi::GST_MESSAGE_STREAM_START => StreamStart::view(self),
167                ffi::GST_MESSAGE_NEED_CONTEXT => NeedContext::view(self),
168                ffi::GST_MESSAGE_HAVE_CONTEXT => HaveContext::view(self),
169                ffi::GST_MESSAGE_DEVICE_ADDED => DeviceAdded::view(self),
170                ffi::GST_MESSAGE_DEVICE_REMOVED => DeviceRemoved::view(self),
171                ffi::GST_MESSAGE_REDIRECT => Redirect::view(self),
172                ffi::GST_MESSAGE_PROPERTY_NOTIFY => PropertyNotify::view(self),
173                ffi::GST_MESSAGE_STREAM_COLLECTION => StreamCollection::view(self),
174                ffi::GST_MESSAGE_STREAMS_SELECTED => StreamsSelected::view(self),
175                #[cfg(feature = "v1_16")]
176                ffi::GST_MESSAGE_DEVICE_CHANGED => DeviceChanged::view(self),
177                #[cfg(feature = "v1_18")]
178                ffi::GST_MESSAGE_INSTANT_RATE_REQUEST => InstantRateRequest::view(self),
179                _ => MessageView::Other,
180            }
181        }
182    }
183
184    pub fn view_mut(&mut self) -> MessageViewMut<'_> {
185        unsafe {
186            let type_ = (*self.as_ptr()).type_;
187
188            match type_ {
189                ffi::GST_MESSAGE_EOS => Eos::view_mut(self),
190                ffi::GST_MESSAGE_ERROR => Error::view_mut(self),
191                ffi::GST_MESSAGE_WARNING => Warning::view_mut(self),
192                ffi::GST_MESSAGE_INFO => Info::view_mut(self),
193                ffi::GST_MESSAGE_TAG => Tag::view_mut(self),
194                ffi::GST_MESSAGE_BUFFERING => Buffering::view_mut(self),
195                ffi::GST_MESSAGE_STATE_CHANGED => StateChanged::view_mut(self),
196                ffi::GST_MESSAGE_STATE_DIRTY => StateDirty::view_mut(self),
197                ffi::GST_MESSAGE_STEP_DONE => StepDone::view_mut(self),
198                ffi::GST_MESSAGE_CLOCK_PROVIDE => ClockProvide::view_mut(self),
199                ffi::GST_MESSAGE_CLOCK_LOST => ClockLost::view_mut(self),
200                ffi::GST_MESSAGE_NEW_CLOCK => NewClock::view_mut(self),
201                ffi::GST_MESSAGE_STRUCTURE_CHANGE => StructureChange::view_mut(self),
202                ffi::GST_MESSAGE_STREAM_STATUS => StreamStatus::view_mut(self),
203                ffi::GST_MESSAGE_APPLICATION => Application::view_mut(self),
204                ffi::GST_MESSAGE_ELEMENT => Element::view_mut(self),
205                ffi::GST_MESSAGE_SEGMENT_START => SegmentStart::view_mut(self),
206                ffi::GST_MESSAGE_SEGMENT_DONE => SegmentDone::view_mut(self),
207                ffi::GST_MESSAGE_DURATION_CHANGED => DurationChanged::view_mut(self),
208                ffi::GST_MESSAGE_LATENCY => Latency::view_mut(self),
209                ffi::GST_MESSAGE_ASYNC_START => AsyncStart::view_mut(self),
210                ffi::GST_MESSAGE_ASYNC_DONE => AsyncDone::view_mut(self),
211                ffi::GST_MESSAGE_REQUEST_STATE => RequestState::view_mut(self),
212                ffi::GST_MESSAGE_STEP_START => StepStart::view_mut(self),
213                ffi::GST_MESSAGE_QOS => Qos::view_mut(self),
214                ffi::GST_MESSAGE_PROGRESS => Progress::view_mut(self),
215                ffi::GST_MESSAGE_TOC => Toc::view_mut(self),
216                ffi::GST_MESSAGE_RESET_TIME => ResetTime::view_mut(self),
217                ffi::GST_MESSAGE_STREAM_START => StreamStart::view_mut(self),
218                ffi::GST_MESSAGE_NEED_CONTEXT => NeedContext::view_mut(self),
219                ffi::GST_MESSAGE_HAVE_CONTEXT => HaveContext::view_mut(self),
220                ffi::GST_MESSAGE_DEVICE_ADDED => DeviceAdded::view_mut(self),
221                ffi::GST_MESSAGE_DEVICE_REMOVED => DeviceRemoved::view_mut(self),
222                ffi::GST_MESSAGE_REDIRECT => Redirect::view_mut(self),
223                ffi::GST_MESSAGE_PROPERTY_NOTIFY => PropertyNotify::view_mut(self),
224                ffi::GST_MESSAGE_STREAM_COLLECTION => StreamCollection::view_mut(self),
225                ffi::GST_MESSAGE_STREAMS_SELECTED => StreamsSelected::view_mut(self),
226                #[cfg(feature = "v1_16")]
227                ffi::GST_MESSAGE_DEVICE_CHANGED => DeviceChanged::view_mut(self),
228                #[cfg(feature = "v1_18")]
229                ffi::GST_MESSAGE_INSTANT_RATE_REQUEST => InstantRateRequest::view_mut(self),
230                _ => MessageViewMut::Other,
231            }
232        }
233    }
234
235    #[doc(alias = "get_type")]
236    #[inline]
237    pub fn type_(&self) -> MessageType {
238        unsafe { from_glib((*self.as_ptr()).type_) }
239    }
240}
241
242impl fmt::Debug for Message {
243    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
244        MessageRef::fmt(self, f)
245    }
246}
247
248impl fmt::Debug for MessageRef {
249    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
250        // Don't retrieve `seqnum` using `MessageRef::get_seqnum`
251        // because it would generate a new seqnum if a buggy `Element`
252        // emitted a `Message` with an invalid `seqnum`.
253        // We want to help the user find out there is something wrong here,
254        // so they can investigate the origin.
255        let seqnum = unsafe { ffi::gst_message_get_seqnum(self.as_mut_ptr()) };
256        let seqnum = if seqnum != 0 {
257            &seqnum as &dyn fmt::Debug
258        } else {
259            &"INVALID (0)" as &dyn fmt::Debug
260        };
261
262        f.debug_struct("Message")
263            .field("ptr", &self.as_ptr())
264            .field("type", &unsafe {
265                let type_ = ffi::gst_message_type_get_name((*self.as_ptr()).type_);
266                CStr::from_ptr(type_).to_str().unwrap()
267            })
268            .field("seqnum", seqnum)
269            .field(
270                "src",
271                &self
272                    .src()
273                    .map(|s| s.name())
274                    .as_ref()
275                    .map(glib::GString::as_str),
276            )
277            .field("structure", &self.structure())
278            .finish()
279    }
280}
281
282#[derive(Debug)]
283#[non_exhaustive]
284pub enum MessageView<'a> {
285    Eos(&'a Eos),
286    Error(&'a Error),
287    Warning(&'a Warning),
288    Info(&'a Info),
289    Tag(&'a Tag),
290    Buffering(&'a Buffering),
291    StateChanged(&'a StateChanged),
292    StateDirty(&'a StateDirty),
293    StepDone(&'a StepDone),
294    ClockProvide(&'a ClockProvide),
295    ClockLost(&'a ClockLost),
296    NewClock(&'a NewClock),
297    StructureChange(&'a StructureChange),
298    StreamStatus(&'a StreamStatus),
299    Application(&'a Application),
300    Element(&'a Element),
301    SegmentStart(&'a SegmentStart),
302    SegmentDone(&'a SegmentDone),
303    DurationChanged(&'a DurationChanged),
304    Latency(&'a Latency),
305    AsyncStart(&'a AsyncStart),
306    AsyncDone(&'a AsyncDone),
307    RequestState(&'a RequestState),
308    StepStart(&'a StepStart),
309    Qos(&'a Qos),
310    Progress(&'a Progress),
311    Toc(&'a Toc),
312    ResetTime(&'a ResetTime),
313    StreamStart(&'a StreamStart),
314    NeedContext(&'a NeedContext),
315    HaveContext(&'a HaveContext),
316    DeviceAdded(&'a DeviceAdded),
317    DeviceRemoved(&'a DeviceRemoved),
318    PropertyNotify(&'a PropertyNotify),
319    StreamCollection(&'a StreamCollection),
320    StreamsSelected(&'a StreamsSelected),
321    Redirect(&'a Redirect),
322    #[cfg(feature = "v1_16")]
323    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
324    DeviceChanged(&'a DeviceChanged),
325    #[cfg(feature = "v1_18")]
326    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
327    InstantRateRequest(&'a InstantRateRequest),
328    Other,
329}
330
331#[derive(Debug)]
332#[non_exhaustive]
333pub enum MessageViewMut<'a> {
334    Eos(&'a mut Eos),
335    Error(&'a mut Error),
336    Warning(&'a mut Warning),
337    Info(&'a mut Info),
338    Tag(&'a mut Tag),
339    Buffering(&'a mut Buffering),
340    StateChanged(&'a mut StateChanged),
341    StateDirty(&'a mut StateDirty),
342    StepDone(&'a mut StepDone),
343    ClockProvide(&'a mut ClockProvide),
344    ClockLost(&'a mut ClockLost),
345    NewClock(&'a mut NewClock),
346    StructureChange(&'a mut StructureChange),
347    StreamStatus(&'a mut StreamStatus),
348    Application(&'a mut Application),
349    Element(&'a mut Element),
350    SegmentStart(&'a mut SegmentStart),
351    SegmentDone(&'a mut SegmentDone),
352    DurationChanged(&'a mut DurationChanged),
353    Latency(&'a mut Latency),
354    AsyncStart(&'a mut AsyncStart),
355    AsyncDone(&'a mut AsyncDone),
356    RequestState(&'a mut RequestState),
357    StepStart(&'a mut StepStart),
358    Qos(&'a mut Qos),
359    Progress(&'a mut Progress),
360    Toc(&'a mut Toc),
361    ResetTime(&'a mut ResetTime),
362    StreamStart(&'a mut StreamStart),
363    NeedContext(&'a mut NeedContext),
364    HaveContext(&'a mut HaveContext),
365    DeviceAdded(&'a mut DeviceAdded),
366    DeviceRemoved(&'a mut DeviceRemoved),
367    PropertyNotify(&'a mut PropertyNotify),
368    StreamCollection(&'a mut StreamCollection),
369    StreamsSelected(&'a mut StreamsSelected),
370    Redirect(&'a mut Redirect),
371    #[cfg(feature = "v1_16")]
372    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
373    DeviceChanged(&'a mut DeviceChanged),
374    #[cfg(feature = "v1_18")]
375    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
376    InstantRateRequest(&'a mut InstantRateRequest),
377    Other,
378}
379
380macro_rules! declare_concrete_message(
381    ($name:ident, $param:ident) => {
382        #[repr(transparent)]
383        pub struct $name<$param = MessageRef>($param);
384
385        impl $name {
386            #[inline]
387            pub fn message(&self) -> &MessageRef {
388                unsafe { &*(self as *const Self as *const MessageRef) }
389            }
390
391            #[inline]
392            pub fn message_mut(&mut self) -> &mut MessageRef {
393                unsafe { &mut *(self as *mut Self as *mut MessageRef) }
394            }
395
396            #[inline]
397            unsafe fn view(message: &MessageRef) -> MessageView<'_> {
398                let message = &*(message as *const MessageRef as *const Self);
399                MessageView::$name(message)
400            }
401
402            #[inline]
403            unsafe fn view_mut(message: &mut MessageRef) -> MessageViewMut<'_> {
404                let message = &mut *(message as *mut MessageRef as *mut Self);
405                MessageViewMut::$name(message)
406            }
407        }
408
409        impl Deref for $name {
410            type Target = MessageRef;
411
412            #[inline]
413            fn deref(&self) -> &Self::Target {
414                unsafe {
415                    &*(self as *const Self as *const Self::Target)
416                }
417            }
418        }
419
420        impl DerefMut for $name {
421            #[inline]
422            fn deref_mut(&mut self) -> &mut Self::Target {
423                self.message_mut()
424            }
425        }
426
427        impl ToOwned for $name {
428            type Owned = $name<Message>;
429
430            #[inline]
431            fn to_owned(&self) -> Self::Owned {
432                $name::<Message>(self.copy())
433            }
434        }
435
436        impl $name<Message> {
437            #[inline]
438            pub fn get_mut(&mut self) -> Option<&mut $name> {
439                self.0.get_mut().map(|message| unsafe {
440                    &mut *(message as *mut MessageRef as *mut $name)
441                })
442            }
443        }
444
445        impl Deref for $name<Message> {
446            type Target = $name;
447
448            #[inline]
449            fn deref(&self) -> &Self::Target {
450                unsafe { &*(self.0.as_ptr() as *const Self::Target) }
451            }
452        }
453
454        impl DerefMut for $name<Message> {
455            #[inline]
456            fn deref_mut(&mut self) -> &mut Self::Target {
457                debug_assert!(self.0.is_writable());
458                unsafe { &mut *(self.0.as_mut_ptr() as *mut Self::Target) }
459            }
460        }
461
462        impl Borrow<$name> for $name<Message> {
463            #[inline]
464            fn borrow(&self) -> &$name {
465                &*self
466            }
467        }
468
469        impl From<$name<Message>> for Message {
470            #[inline]
471            fn from(concrete: $name<Message>) -> Self {
472                skip_assert_initialized!();
473                concrete.0
474            }
475        }
476    }
477);
478
479declare_concrete_message!(Eos, T);
480impl Eos {
481    #[doc(alias = "gst_message_new_eos")]
482    #[allow(clippy::new_ret_no_self)]
483    pub fn new() -> Message {
484        skip_assert_initialized!();
485        Self::builder().build()
486    }
487
488    pub fn builder<'a>() -> EosBuilder<'a> {
489        assert_initialized_main_thread!();
490        EosBuilder::new()
491    }
492}
493
494impl std::fmt::Debug for Eos {
495    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
496        f.debug_struct("Eos")
497            .field("structure", &self.message().structure())
498            .field("source", &self.src().map(|obj| (obj, obj.name())))
499            .finish()
500    }
501}
502
503impl std::fmt::Debug for Eos<Message> {
504    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
505        Eos::<MessageRef>::fmt(self, f)
506    }
507}
508
509declare_concrete_message!(Error, T);
510impl Error {
511    #[doc(alias = "gst_message_new_error")]
512    #[allow(clippy::new_ret_no_self)]
513    pub fn new<T: MessageErrorDomain>(error: T, message: &str) -> Message {
514        skip_assert_initialized!();
515        Self::builder(error, message).build()
516    }
517
518    pub fn builder<T: MessageErrorDomain>(error: T, message: &str) -> ErrorBuilder<'_> {
519        assert_initialized_main_thread!();
520        ErrorBuilder::new(glib::Error::new(error, message))
521    }
522
523    pub fn builder_from_error<'a>(error: glib::Error) -> ErrorBuilder<'a> {
524        assert_initialized_main_thread!();
525
526        assert!([
527            crate::CoreError::domain(),
528            crate::ResourceError::domain(),
529            crate::StreamError::domain(),
530            crate::LibraryError::domain(),
531        ]
532        .contains(&error.domain()));
533        ErrorBuilder::new(error)
534    }
535
536    #[doc(alias = "get_error")]
537    #[doc(alias = "gst_message_parse_error")]
538    pub fn error(&self) -> glib::Error {
539        unsafe {
540            let mut error = ptr::null_mut();
541
542            ffi::gst_message_parse_error(self.as_mut_ptr(), &mut error, ptr::null_mut());
543
544            from_glib_full(error)
545        }
546    }
547
548    #[doc(alias = "get_debug")]
549    #[doc(alias = "gst_message_parse_error")]
550    pub fn debug(&self) -> Option<glib::GString> {
551        unsafe {
552            let mut debug = ptr::null_mut();
553
554            ffi::gst_message_parse_error(self.as_mut_ptr(), ptr::null_mut(), &mut debug);
555
556            from_glib_full(debug)
557        }
558    }
559
560    #[doc(alias = "get_details")]
561    #[doc(alias = "gst_message_parse_error_details")]
562    pub fn details(&self) -> Option<&StructureRef> {
563        unsafe {
564            let mut details = ptr::null();
565
566            ffi::gst_message_parse_error_details(self.as_mut_ptr(), &mut details);
567
568            if details.is_null() {
569                None
570            } else {
571                Some(StructureRef::from_glib_borrow(details))
572            }
573        }
574    }
575
576    #[cfg(feature = "v1_26")]
577    #[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
578    #[doc(alias = "gst_message_parse_error_writable_details")]
579    pub fn writable_details(&mut self) -> &mut StructureRef {
580        unsafe {
581            let mut details = ptr::null_mut();
582
583            ffi::gst_message_parse_error_writable_details(self.as_mut_ptr(), &mut details);
584
585            StructureRef::from_glib_borrow_mut(details)
586        }
587    }
588}
589
590impl std::fmt::Display for Error {
591    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
592        write!(f, "{}", self.error())
593    }
594}
595
596impl std::fmt::Debug for Error {
597    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
598        f.debug_struct("Error")
599            .field("structure", &self.message().structure())
600            .field("source", &self.src().map(|obj| (obj, obj.name())))
601            .field("error", &self.error())
602            .field("debug", &self.debug())
603            .field("details", &self.details())
604            .finish()
605    }
606}
607
608impl std::fmt::Debug for Error<Message> {
609    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
610        Error::<MessageRef>::fmt(self, f)
611    }
612}
613
614declare_concrete_message!(Warning, T);
615impl Warning {
616    #[doc(alias = "gst_message_new_warning")]
617    #[allow(clippy::new_ret_no_self)]
618    pub fn new<T: MessageErrorDomain>(error: T, message: &str) -> Message {
619        skip_assert_initialized!();
620        Self::builder(error, message).build()
621    }
622
623    pub fn builder<T: MessageErrorDomain>(error: T, message: &str) -> WarningBuilder<'_> {
624        assert_initialized_main_thread!();
625        WarningBuilder::new(glib::Error::new(error, message))
626    }
627
628    pub fn builder_from_error<'a>(error: glib::Error) -> WarningBuilder<'a> {
629        assert_initialized_main_thread!();
630
631        assert!([
632            crate::CoreError::domain(),
633            crate::ResourceError::domain(),
634            crate::StreamError::domain(),
635            crate::LibraryError::domain(),
636        ]
637        .contains(&error.domain()));
638        WarningBuilder::new(error)
639    }
640
641    #[doc(alias = "get_error")]
642    #[doc(alias = "gst_message_parse_warning")]
643    pub fn error(&self) -> glib::Error {
644        unsafe {
645            let mut error = ptr::null_mut();
646
647            ffi::gst_message_parse_warning(self.as_mut_ptr(), &mut error, ptr::null_mut());
648
649            from_glib_full(error)
650        }
651    }
652
653    #[doc(alias = "get_debug")]
654    #[doc(alias = "gst_message_parse_warning")]
655    pub fn debug(&self) -> Option<glib::GString> {
656        unsafe {
657            let mut debug = ptr::null_mut();
658
659            ffi::gst_message_parse_warning(self.as_mut_ptr(), ptr::null_mut(), &mut debug);
660
661            from_glib_full(debug)
662        }
663    }
664
665    #[doc(alias = "get_details")]
666    #[doc(alias = "gst_message_parse_warning_details")]
667    pub fn details(&self) -> Option<&StructureRef> {
668        unsafe {
669            let mut details = ptr::null();
670
671            ffi::gst_message_parse_warning_details(self.as_mut_ptr(), &mut details);
672
673            if details.is_null() {
674                None
675            } else {
676                Some(StructureRef::from_glib_borrow(details))
677            }
678        }
679    }
680
681    #[cfg(feature = "v1_26")]
682    #[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
683    #[doc(alias = "gst_message_parse_warning_writable_details")]
684    pub fn writable_details(&mut self) -> &mut StructureRef {
685        unsafe {
686            let mut details = ptr::null_mut();
687
688            ffi::gst_message_parse_warning_writable_details(self.as_mut_ptr(), &mut details);
689
690            StructureRef::from_glib_borrow_mut(details)
691        }
692    }
693}
694
695impl std::fmt::Display for Warning {
696    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
697        write!(f, "{}", self.error())
698    }
699}
700
701impl std::fmt::Debug for Warning {
702    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
703        f.debug_struct("Warning")
704            .field("structure", &self.message().structure())
705            .field("source", &self.src().map(|obj| (obj, obj.name())))
706            .field("error", &self.error())
707            .field("debug", &self.debug())
708            .field("details", &self.details())
709            .finish()
710    }
711}
712
713impl std::fmt::Debug for Warning<Message> {
714    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
715        Warning::<MessageRef>::fmt(self, f)
716    }
717}
718
719declare_concrete_message!(Info, T);
720impl Info {
721    #[doc(alias = "gst_message_new_info")]
722    #[allow(clippy::new_ret_no_self)]
723    pub fn new<T: MessageErrorDomain>(error: T, message: &str) -> Message {
724        skip_assert_initialized!();
725        Self::builder(error, message).build()
726    }
727
728    pub fn builder<T: MessageErrorDomain>(error: T, message: &str) -> InfoBuilder<'_> {
729        assert_initialized_main_thread!();
730        InfoBuilder::new(glib::Error::new(error, message))
731    }
732
733    pub fn builder_from_error<'a>(error: glib::Error) -> InfoBuilder<'a> {
734        assert_initialized_main_thread!();
735
736        assert!([
737            crate::CoreError::domain(),
738            crate::ResourceError::domain(),
739            crate::StreamError::domain(),
740            crate::LibraryError::domain(),
741        ]
742        .contains(&error.domain()));
743        InfoBuilder::new(error)
744    }
745
746    #[doc(alias = "get_error")]
747    #[doc(alias = "gst_message_parse_info")]
748    pub fn error(&self) -> glib::Error {
749        unsafe {
750            let mut error = ptr::null_mut();
751
752            ffi::gst_message_parse_info(self.as_mut_ptr(), &mut error, ptr::null_mut());
753
754            from_glib_full(error)
755        }
756    }
757
758    #[doc(alias = "get_debug")]
759    #[doc(alias = "gst_message_parse_info")]
760    pub fn debug(&self) -> Option<glib::GString> {
761        unsafe {
762            let mut debug = ptr::null_mut();
763
764            ffi::gst_message_parse_info(self.as_mut_ptr(), ptr::null_mut(), &mut debug);
765
766            from_glib_full(debug)
767        }
768    }
769
770    #[doc(alias = "get_details")]
771    #[doc(alias = "gst_message_parse_info_details")]
772    pub fn details(&self) -> Option<&StructureRef> {
773        unsafe {
774            let mut details = ptr::null();
775
776            ffi::gst_message_parse_info_details(self.as_mut_ptr(), &mut details);
777
778            if details.is_null() {
779                None
780            } else {
781                Some(StructureRef::from_glib_borrow(details))
782            }
783        }
784    }
785
786    #[cfg(feature = "v1_26")]
787    #[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
788    #[doc(alias = "gst_message_parse_info_writable_details")]
789    pub fn writable_details(&mut self) -> &mut StructureRef {
790        unsafe {
791            let mut details = ptr::null_mut();
792
793            ffi::gst_message_parse_info_writable_details(self.as_mut_ptr(), &mut details);
794
795            StructureRef::from_glib_borrow_mut(details)
796        }
797    }
798}
799
800impl std::fmt::Display for Info {
801    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
802        write!(f, "{}", self.error())
803    }
804}
805
806impl std::fmt::Debug for Info {
807    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
808        f.debug_struct("Info")
809            .field("structure", &self.message().structure())
810            .field("source", &self.src().map(|obj| (obj, obj.name())))
811            .field("error", &self.error())
812            .field("debug", &self.debug())
813            .field("details", &self.details())
814            .finish()
815    }
816}
817
818impl std::fmt::Debug for Info<Message> {
819    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
820        Info::<MessageRef>::fmt(self, f)
821    }
822}
823
824declare_concrete_message!(Tag, T);
825impl Tag {
826    #[doc(alias = "gst_message_new_tag")]
827    #[allow(clippy::new_ret_no_self)]
828    pub fn new(tags: TagList) -> Message {
829        skip_assert_initialized!();
830        Self::builder(tags).build()
831    }
832
833    pub fn builder<'a>(tags: TagList) -> TagBuilder<'a> {
834        assert_initialized_main_thread!();
835        TagBuilder::new(tags)
836    }
837
838    #[doc(alias = "get_tags")]
839    #[doc(alias = "gst_message_parse_tag")]
840    pub fn tags(&self) -> TagList {
841        unsafe {
842            let mut tags = ptr::null_mut();
843            ffi::gst_message_parse_tag(self.as_mut_ptr(), &mut tags);
844            from_glib_full(tags)
845        }
846    }
847}
848
849impl std::fmt::Debug for Tag {
850    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
851        f.debug_struct("Tag")
852            .field("structure", &self.message().structure())
853            .field("source", &self.src().map(|obj| (obj, obj.name())))
854            .field("tags", &self.tags())
855            .finish()
856    }
857}
858
859impl std::fmt::Debug for Tag<Message> {
860    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
861        Tag::<MessageRef>::fmt(self, f)
862    }
863}
864
865declare_concrete_message!(Buffering, T);
866impl Buffering {
867    #[doc(alias = "gst_message_new_buffering")]
868    #[allow(clippy::new_ret_no_self)]
869    pub fn new(percent: i32) -> Message {
870        skip_assert_initialized!();
871        Self::builder(percent).build()
872    }
873
874    pub fn builder<'a>(percent: i32) -> BufferingBuilder<'a> {
875        assert_initialized_main_thread!();
876        BufferingBuilder::new(percent)
877    }
878
879    #[doc(alias = "get_percent")]
880    #[doc(alias = "gst_message_parse_buffering")]
881    pub fn percent(&self) -> i32 {
882        unsafe {
883            let mut p = mem::MaybeUninit::uninit();
884            ffi::gst_message_parse_buffering(self.as_mut_ptr(), p.as_mut_ptr());
885            p.assume_init()
886        }
887    }
888
889    #[doc(alias = "get_buffering_stats")]
890    #[doc(alias = "gst_message_parse_buffering_stats")]
891    pub fn buffering_stats(&self) -> (crate::BufferingMode, i32, i32, i64) {
892        unsafe {
893            let mut mode = mem::MaybeUninit::uninit();
894            let mut avg_in = mem::MaybeUninit::uninit();
895            let mut avg_out = mem::MaybeUninit::uninit();
896            let mut buffering_left = mem::MaybeUninit::uninit();
897
898            ffi::gst_message_parse_buffering_stats(
899                self.as_mut_ptr(),
900                mode.as_mut_ptr(),
901                avg_in.as_mut_ptr(),
902                avg_out.as_mut_ptr(),
903                buffering_left.as_mut_ptr(),
904            );
905
906            (
907                from_glib(mode.assume_init()),
908                avg_in.assume_init(),
909                avg_out.assume_init(),
910                buffering_left.assume_init(),
911            )
912        }
913    }
914}
915
916impl std::fmt::Debug for Buffering {
917    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
918        f.debug_struct("Buffering")
919            .field("structure", &self.message().structure())
920            .field("source", &self.src().map(|obj| (obj, obj.name())))
921            .field("percent", &self.percent())
922            .field("buffering-stats", &self.buffering_stats())
923            .finish()
924    }
925}
926
927impl std::fmt::Debug for Buffering<Message> {
928    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
929        Buffering::<MessageRef>::fmt(self, f)
930    }
931}
932
933declare_concrete_message!(StateChanged, T);
934impl StateChanged {
935    #[doc(alias = "gst_message_new_state_changed")]
936    #[allow(clippy::new_ret_no_self)]
937    pub fn new(old: crate::State, new: crate::State, pending: crate::State) -> Message {
938        skip_assert_initialized!();
939        Self::builder(old, new, pending).build()
940    }
941
942    pub fn builder<'a>(
943        old: crate::State,
944        new: crate::State,
945        pending: crate::State,
946    ) -> StateChangedBuilder<'a> {
947        assert_initialized_main_thread!();
948        StateChangedBuilder::new(old, new, pending)
949    }
950
951    #[doc(alias = "get_old")]
952    #[doc(alias = "gst_message_parse_state_changed")]
953    pub fn old(&self) -> crate::State {
954        unsafe {
955            let mut state = mem::MaybeUninit::uninit();
956
957            ffi::gst_message_parse_state_changed(
958                self.as_mut_ptr(),
959                state.as_mut_ptr(),
960                ptr::null_mut(),
961                ptr::null_mut(),
962            );
963
964            from_glib(state.assume_init())
965        }
966    }
967
968    #[doc(alias = "get_current")]
969    #[doc(alias = "gst_message_parse_state_changed")]
970    pub fn current(&self) -> crate::State {
971        unsafe {
972            let mut state = mem::MaybeUninit::uninit();
973
974            ffi::gst_message_parse_state_changed(
975                self.as_mut_ptr(),
976                ptr::null_mut(),
977                state.as_mut_ptr(),
978                ptr::null_mut(),
979            );
980
981            from_glib(state.assume_init())
982        }
983    }
984
985    #[doc(alias = "get_pending")]
986    #[doc(alias = "gst_message_parse_state_changed")]
987    pub fn pending(&self) -> crate::State {
988        unsafe {
989            let mut state = mem::MaybeUninit::uninit();
990
991            ffi::gst_message_parse_state_changed(
992                self.as_mut_ptr(),
993                ptr::null_mut(),
994                ptr::null_mut(),
995                state.as_mut_ptr(),
996            );
997
998            from_glib(state.assume_init())
999        }
1000    }
1001}
1002
1003impl std::fmt::Debug for StateChanged {
1004    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1005        f.debug_struct("StateChanged")
1006            .field("structure", &self.message().structure())
1007            .field("source", &self.src().map(|obj| (obj, obj.name())))
1008            .field("old", &self.old())
1009            .field("current", &self.current())
1010            .field("pending", &self.pending())
1011            .finish()
1012    }
1013}
1014
1015impl std::fmt::Debug for StateChanged<Message> {
1016    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1017        StateChanged::<MessageRef>::fmt(self, f)
1018    }
1019}
1020
1021declare_concrete_message!(StateDirty, T);
1022impl StateDirty {
1023    #[doc(alias = "gst_message_new_state_dirty")]
1024    #[allow(clippy::new_ret_no_self)]
1025    pub fn new() -> Message {
1026        skip_assert_initialized!();
1027        Self::builder().build()
1028    }
1029
1030    pub fn builder<'a>() -> StateDirtyBuilder<'a> {
1031        assert_initialized_main_thread!();
1032        StateDirtyBuilder::new()
1033    }
1034}
1035
1036impl std::fmt::Debug for StateDirty {
1037    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1038        f.debug_struct("StateDirty")
1039            .field("structure", &self.message().structure())
1040            .field("source", &self.src().map(|obj| (obj, obj.name())))
1041            .finish()
1042    }
1043}
1044
1045impl std::fmt::Debug for StateDirty<Message> {
1046    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1047        StateDirty::<MessageRef>::fmt(self, f)
1048    }
1049}
1050
1051declare_concrete_message!(StepDone, T);
1052impl StepDone {
1053    #[doc(alias = "gst_message_new_step_done")]
1054    #[allow(clippy::new_ret_no_self)]
1055    pub fn new(
1056        amount: impl FormattedValue,
1057        rate: f64,
1058        flush: bool,
1059        intermediate: bool,
1060        duration: impl Into<Option<crate::ClockTime>>,
1061        eos: bool,
1062    ) -> Message {
1063        skip_assert_initialized!();
1064        Self::builder(amount, rate, flush, intermediate, duration, eos).build()
1065    }
1066
1067    pub fn builder<'a>(
1068        amount: impl FormattedValue,
1069        rate: f64,
1070        flush: bool,
1071        intermediate: bool,
1072        duration: impl Into<Option<crate::ClockTime>>,
1073        eos: bool,
1074    ) -> StepDoneBuilder<'a> {
1075        assert_initialized_main_thread!();
1076        StepDoneBuilder::new(
1077            amount.into(),
1078            rate,
1079            flush,
1080            intermediate,
1081            duration.into(),
1082            eos,
1083        )
1084    }
1085
1086    #[doc(alias = "gst_message_parse_step_done")]
1087    pub fn get(
1088        &self,
1089    ) -> (
1090        GenericFormattedValue,
1091        f64,
1092        bool,
1093        bool,
1094        Option<crate::ClockTime>,
1095        bool,
1096    ) {
1097        unsafe {
1098            let mut format = mem::MaybeUninit::uninit();
1099            let mut amount = mem::MaybeUninit::uninit();
1100            let mut rate = mem::MaybeUninit::uninit();
1101            let mut flush = mem::MaybeUninit::uninit();
1102            let mut intermediate = mem::MaybeUninit::uninit();
1103            let mut duration = mem::MaybeUninit::uninit();
1104            let mut eos = mem::MaybeUninit::uninit();
1105
1106            ffi::gst_message_parse_step_done(
1107                self.as_mut_ptr(),
1108                format.as_mut_ptr(),
1109                amount.as_mut_ptr(),
1110                rate.as_mut_ptr(),
1111                flush.as_mut_ptr(),
1112                intermediate.as_mut_ptr(),
1113                duration.as_mut_ptr(),
1114                eos.as_mut_ptr(),
1115            );
1116
1117            (
1118                GenericFormattedValue::new(
1119                    from_glib(format.assume_init()),
1120                    amount.assume_init() as i64,
1121                ),
1122                rate.assume_init(),
1123                from_glib(flush.assume_init()),
1124                from_glib(intermediate.assume_init()),
1125                from_glib(duration.assume_init()),
1126                from_glib(eos.assume_init()),
1127            )
1128        }
1129    }
1130}
1131
1132impl std::fmt::Debug for StepDone {
1133    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1134        let (format, rate, flush, intermediate, duration, eos) = self.get();
1135        f.debug_struct("StepDone")
1136            .field("structure", &self.message().structure())
1137            .field("source", &self.src().map(|obj| (obj, obj.name())))
1138            .field("format", &format)
1139            .field("rate", &rate)
1140            .field("flush", &flush)
1141            .field("intermediate", &intermediate)
1142            .field("duration", &duration)
1143            .field("eos", &eos)
1144            .finish()
1145    }
1146}
1147
1148impl std::fmt::Debug for StepDone<Message> {
1149    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1150        StepDone::<MessageRef>::fmt(self, f)
1151    }
1152}
1153
1154declare_concrete_message!(ClockProvide, T);
1155impl ClockProvide {
1156    #[doc(alias = "gst_message_new_clock_provide")]
1157    #[allow(clippy::new_ret_no_self)]
1158    pub fn new(clock: &crate::Clock, ready: bool) -> Message {
1159        skip_assert_initialized!();
1160        Self::builder(clock, ready).build()
1161    }
1162
1163    pub fn builder(clock: &crate::Clock, ready: bool) -> ClockProvideBuilder<'_> {
1164        assert_initialized_main_thread!();
1165        ClockProvideBuilder::new(clock, ready)
1166    }
1167
1168    #[doc(alias = "get_clock")]
1169    #[doc(alias = "gst_message_parse_clock_provide")]
1170    pub fn clock(&self) -> Option<crate::Clock> {
1171        let mut clock = ptr::null_mut();
1172
1173        unsafe {
1174            ffi::gst_message_parse_clock_provide(self.as_mut_ptr(), &mut clock, ptr::null_mut());
1175
1176            from_glib_none(clock)
1177        }
1178    }
1179
1180    #[doc(alias = "get_ready")]
1181    #[doc(alias = "gst_message_parse_clock_provide")]
1182    pub fn is_ready(&self) -> bool {
1183        unsafe {
1184            let mut ready = mem::MaybeUninit::uninit();
1185
1186            ffi::gst_message_parse_clock_provide(
1187                self.as_mut_ptr(),
1188                ptr::null_mut(),
1189                ready.as_mut_ptr(),
1190            );
1191
1192            from_glib(ready.assume_init())
1193        }
1194    }
1195}
1196
1197impl std::fmt::Debug for ClockProvide {
1198    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1199        f.debug_struct("ClockProvide")
1200            .field("structure", &self.message().structure())
1201            .field("source", &self.src().map(|obj| (obj, obj.name())))
1202            .field("clock", &self.clock())
1203            .field("is-ready", &self.is_ready())
1204            .finish()
1205    }
1206}
1207
1208impl std::fmt::Debug for ClockProvide<Message> {
1209    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1210        ClockProvide::<MessageRef>::fmt(self, f)
1211    }
1212}
1213
1214declare_concrete_message!(ClockLost, T);
1215impl ClockLost {
1216    #[doc(alias = "gst_message_new_clock_lost")]
1217    #[allow(clippy::new_ret_no_self)]
1218    pub fn new(clock: &crate::Clock) -> Message {
1219        skip_assert_initialized!();
1220        Self::builder(clock).build()
1221    }
1222
1223    pub fn builder(clock: &crate::Clock) -> ClockLostBuilder<'_> {
1224        assert_initialized_main_thread!();
1225        ClockLostBuilder::new(clock)
1226    }
1227
1228    #[doc(alias = "get_clock")]
1229    #[doc(alias = "gst_message_parse_clock_lost")]
1230    pub fn clock(&self) -> Option<crate::Clock> {
1231        let mut clock = ptr::null_mut();
1232
1233        unsafe {
1234            ffi::gst_message_parse_clock_lost(self.as_mut_ptr(), &mut clock);
1235
1236            from_glib_none(clock)
1237        }
1238    }
1239}
1240
1241impl std::fmt::Debug for ClockLost {
1242    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1243        f.debug_struct("ClockLost")
1244            .field("structure", &self.message().structure())
1245            .field("source", &self.src().map(|obj| (obj, obj.name())))
1246            .field("clock", &self.clock())
1247            .finish()
1248    }
1249}
1250
1251impl std::fmt::Debug for ClockLost<Message> {
1252    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1253        ClockLost::<MessageRef>::fmt(self, f)
1254    }
1255}
1256
1257declare_concrete_message!(NewClock, T);
1258impl NewClock {
1259    #[doc(alias = "gst_message_new_new_clock")]
1260    #[allow(clippy::new_ret_no_self)]
1261    pub fn new(clock: &crate::Clock) -> Message {
1262        skip_assert_initialized!();
1263        Self::builder(clock).build()
1264    }
1265
1266    pub fn builder(clock: &crate::Clock) -> NewClockBuilder<'_> {
1267        assert_initialized_main_thread!();
1268        NewClockBuilder::new(clock)
1269    }
1270
1271    #[doc(alias = "get_clock")]
1272    #[doc(alias = "gst_message_parse_new_clock")]
1273    pub fn clock(&self) -> Option<crate::Clock> {
1274        let mut clock = ptr::null_mut();
1275
1276        unsafe {
1277            ffi::gst_message_parse_new_clock(self.as_mut_ptr(), &mut clock);
1278
1279            from_glib_none(clock)
1280        }
1281    }
1282}
1283
1284impl std::fmt::Debug for NewClock {
1285    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1286        f.debug_struct("NewClock")
1287            .field("structure", &self.message().structure())
1288            .field("source", &self.src().map(|obj| (obj, obj.name())))
1289            .field("clock", &self.clock())
1290            .finish()
1291    }
1292}
1293
1294impl std::fmt::Debug for NewClock<Message> {
1295    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1296        NewClock::<MessageRef>::fmt(self, f)
1297    }
1298}
1299
1300declare_concrete_message!(StructureChange, T);
1301impl StructureChange {
1302    #[doc(alias = "gst_message_new_structure_change")]
1303    #[allow(clippy::new_ret_no_self)]
1304    pub fn new(type_: crate::StructureChangeType, owner: &crate::Element, busy: bool) -> Message {
1305        skip_assert_initialized!();
1306        Self::builder(type_, owner, busy).build()
1307    }
1308
1309    pub fn builder(
1310        type_: crate::StructureChangeType,
1311        owner: &crate::Element,
1312        busy: bool,
1313    ) -> StructureChangeBuilder<'_> {
1314        assert_initialized_main_thread!();
1315        StructureChangeBuilder::new(type_, owner, busy)
1316    }
1317
1318    #[doc(alias = "gst_message_parse_structure_change")]
1319    pub fn get(&self) -> (crate::StructureChangeType, crate::Element, bool) {
1320        unsafe {
1321            let mut type_ = mem::MaybeUninit::uninit();
1322            let mut owner = ptr::null_mut();
1323            let mut busy = mem::MaybeUninit::uninit();
1324
1325            ffi::gst_message_parse_structure_change(
1326                self.as_mut_ptr(),
1327                type_.as_mut_ptr(),
1328                &mut owner,
1329                busy.as_mut_ptr(),
1330            );
1331
1332            (
1333                from_glib(type_.assume_init()),
1334                from_glib_none(owner),
1335                from_glib(busy.assume_init()),
1336            )
1337        }
1338    }
1339}
1340
1341impl std::fmt::Debug for StructureChange {
1342    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1343        let (type_, owner, busy) = self.get();
1344
1345        f.debug_struct("StructureChange")
1346            .field("structure", &self.message().structure())
1347            .field("source", &self.src().map(|obj| (obj, obj.name())))
1348            .field("type", &type_)
1349            .field("owner", &owner)
1350            .field("busy", &busy)
1351            .finish()
1352    }
1353}
1354
1355impl std::fmt::Debug for StructureChange<Message> {
1356    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1357        StructureChange::<MessageRef>::fmt(self, f)
1358    }
1359}
1360
1361declare_concrete_message!(StreamStatus, T);
1362impl StreamStatus {
1363    #[doc(alias = "gst_message_new_stream_status")]
1364    #[allow(clippy::new_ret_no_self)]
1365    pub fn new(type_: crate::StreamStatusType, owner: &crate::Element) -> Message {
1366        skip_assert_initialized!();
1367        Self::builder(type_, owner).build()
1368    }
1369
1370    pub fn builder(
1371        type_: crate::StreamStatusType,
1372        owner: &crate::Element,
1373    ) -> StreamStatusBuilder<'_> {
1374        assert_initialized_main_thread!();
1375        StreamStatusBuilder::new(type_, owner)
1376    }
1377
1378    #[doc(alias = "gst_message_parse_stream_status")]
1379    pub fn get(&self) -> (crate::StreamStatusType, crate::Element) {
1380        unsafe {
1381            let mut type_ = mem::MaybeUninit::uninit();
1382            let mut owner = ptr::null_mut();
1383
1384            ffi::gst_message_parse_stream_status(self.as_mut_ptr(), type_.as_mut_ptr(), &mut owner);
1385
1386            (from_glib(type_.assume_init()), from_glib_none(owner))
1387        }
1388    }
1389
1390    #[doc(alias = "get_stream_status_object")]
1391    #[doc(alias = "gst_message_get_stream_status_object")]
1392    pub fn stream_status_object(&self) -> Option<glib::Value> {
1393        unsafe {
1394            let value = ffi::gst_message_get_stream_status_object(self.as_mut_ptr());
1395
1396            from_glib_none(value)
1397        }
1398    }
1399}
1400
1401impl std::fmt::Debug for StreamStatus {
1402    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1403        f.debug_struct("StreamStatus")
1404            .field("structure", &self.message().structure())
1405            .field("source", &self.src().map(|obj| (obj, obj.name())))
1406            .field("status", &self.stream_status_object())
1407            .finish()
1408    }
1409}
1410
1411impl std::fmt::Debug for StreamStatus<Message> {
1412    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1413        StreamStatus::<MessageRef>::fmt(self, f)
1414    }
1415}
1416
1417declare_concrete_message!(Application, T);
1418impl Application {
1419    #[doc(alias = "gst_message_new_application")]
1420    #[allow(clippy::new_ret_no_self)]
1421    pub fn new(structure: crate::Structure) -> Message {
1422        skip_assert_initialized!();
1423        Self::builder(structure).build()
1424    }
1425
1426    pub fn builder<'a>(structure: crate::Structure) -> ApplicationBuilder<'a> {
1427        assert_initialized_main_thread!();
1428        ApplicationBuilder::new(structure)
1429    }
1430}
1431
1432impl std::fmt::Debug for Application {
1433    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1434        f.debug_struct("Application")
1435            .field("structure", &self.message().structure())
1436            .field("source", &self.src().map(|obj| (obj, obj.name())))
1437            .finish()
1438    }
1439}
1440
1441impl std::fmt::Debug for Application<Message> {
1442    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1443        Application::<MessageRef>::fmt(self, f)
1444    }
1445}
1446
1447declare_concrete_message!(Element, T);
1448impl Element {
1449    #[doc(alias = "gst_message_new_element")]
1450    #[allow(clippy::new_ret_no_self)]
1451    pub fn new(structure: crate::Structure) -> Message {
1452        skip_assert_initialized!();
1453        Self::builder(structure).build()
1454    }
1455
1456    pub fn builder<'a>(structure: crate::Structure) -> ElementBuilder<'a> {
1457        assert_initialized_main_thread!();
1458        ElementBuilder::new(structure)
1459    }
1460}
1461
1462impl std::fmt::Debug for Element {
1463    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1464        f.debug_struct("Element")
1465            .field("structure", &self.message().structure())
1466            .field("source", &self.src().map(|obj| (obj, obj.name())))
1467            .finish()
1468    }
1469}
1470
1471impl std::fmt::Debug for Element<Message> {
1472    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1473        Element::<MessageRef>::fmt(self, f)
1474    }
1475}
1476
1477declare_concrete_message!(SegmentStart, T);
1478impl SegmentStart {
1479    #[doc(alias = "gst_message_new_segment_start")]
1480    #[allow(clippy::new_ret_no_self)]
1481    pub fn new(position: impl FormattedValue) -> Message {
1482        skip_assert_initialized!();
1483        Self::builder(position).build()
1484    }
1485
1486    pub fn builder<'a>(position: impl FormattedValue) -> SegmentStartBuilder<'a> {
1487        assert_initialized_main_thread!();
1488        SegmentStartBuilder::new(position.into())
1489    }
1490
1491    #[doc(alias = "gst_message_parse_segment_start")]
1492    pub fn get(&self) -> GenericFormattedValue {
1493        unsafe {
1494            let mut format = mem::MaybeUninit::uninit();
1495            let mut position = mem::MaybeUninit::uninit();
1496
1497            ffi::gst_message_parse_segment_start(
1498                self.as_mut_ptr(),
1499                format.as_mut_ptr(),
1500                position.as_mut_ptr(),
1501            );
1502
1503            GenericFormattedValue::new(from_glib(format.assume_init()), position.assume_init())
1504        }
1505    }
1506}
1507
1508impl std::fmt::Debug for SegmentStart {
1509    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1510        f.debug_struct("SegmentStart")
1511            .field("structure", &self.message().structure())
1512            .field("source", &self.src().map(|obj| (obj, obj.name())))
1513            .field("segment", &self.get())
1514            .finish()
1515    }
1516}
1517
1518impl std::fmt::Debug for SegmentStart<Message> {
1519    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1520        SegmentStart::<MessageRef>::fmt(self, f)
1521    }
1522}
1523
1524declare_concrete_message!(SegmentDone, T);
1525impl SegmentDone {
1526    #[doc(alias = "gst_message_new_segment_done")]
1527    #[allow(clippy::new_ret_no_self)]
1528    pub fn new(position: impl FormattedValue) -> Message {
1529        skip_assert_initialized!();
1530        Self::builder(position).build()
1531    }
1532
1533    pub fn builder<'a>(position: impl FormattedValue) -> SegmentDoneBuilder<'a> {
1534        assert_initialized_main_thread!();
1535        SegmentDoneBuilder::new(position.into())
1536    }
1537
1538    #[doc(alias = "gst_message_parse_segment_done")]
1539    pub fn get(&self) -> GenericFormattedValue {
1540        unsafe {
1541            let mut format = mem::MaybeUninit::uninit();
1542            let mut position = mem::MaybeUninit::uninit();
1543
1544            ffi::gst_message_parse_segment_done(
1545                self.as_mut_ptr(),
1546                format.as_mut_ptr(),
1547                position.as_mut_ptr(),
1548            );
1549
1550            GenericFormattedValue::new(from_glib(format.assume_init()), position.assume_init())
1551        }
1552    }
1553}
1554
1555impl std::fmt::Debug for SegmentDone {
1556    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1557        f.debug_struct("SegmentDone")
1558            .field("structure", &self.message().structure())
1559            .field("source", &self.src().map(|obj| (obj, obj.name())))
1560            .field("segment", &self.get())
1561            .finish()
1562    }
1563}
1564
1565impl std::fmt::Debug for SegmentDone<Message> {
1566    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1567        SegmentDone::<MessageRef>::fmt(self, f)
1568    }
1569}
1570
1571declare_concrete_message!(DurationChanged, T);
1572impl DurationChanged {
1573    #[doc(alias = "gst_message_new_duration_changed")]
1574    #[allow(clippy::new_ret_no_self)]
1575    pub fn new() -> Message {
1576        skip_assert_initialized!();
1577        Self::builder().build()
1578    }
1579
1580    pub fn builder<'a>() -> DurationChangedBuilder<'a> {
1581        assert_initialized_main_thread!();
1582        DurationChangedBuilder::new()
1583    }
1584}
1585
1586impl std::fmt::Debug for DurationChanged {
1587    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1588        f.debug_struct("DurationChanged")
1589            .field("structure", &self.message().structure())
1590            .field("source", &self.src().map(|obj| (obj, obj.name())))
1591            .finish()
1592    }
1593}
1594
1595impl std::fmt::Debug for DurationChanged<Message> {
1596    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1597        DurationChanged::<MessageRef>::fmt(self, f)
1598    }
1599}
1600
1601declare_concrete_message!(Latency, T);
1602impl Latency {
1603    #[doc(alias = "gst_message_new_latency")]
1604    #[allow(clippy::new_ret_no_self)]
1605    pub fn new() -> Message {
1606        skip_assert_initialized!();
1607        Self::builder().build()
1608    }
1609
1610    pub fn builder<'a>() -> LatencyBuilder<'a> {
1611        assert_initialized_main_thread!();
1612        LatencyBuilder::new()
1613    }
1614}
1615
1616impl std::fmt::Debug for Latency {
1617    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1618        f.debug_struct("Latency")
1619            .field("structure", &self.message().structure())
1620            .field("source", &self.src().map(|obj| (obj, obj.name())))
1621            .finish()
1622    }
1623}
1624
1625impl std::fmt::Debug for Latency<Message> {
1626    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1627        Latency::<MessageRef>::fmt(self, f)
1628    }
1629}
1630
1631declare_concrete_message!(AsyncStart, T);
1632impl AsyncStart {
1633    #[doc(alias = "gst_message_new_async_start")]
1634    #[allow(clippy::new_ret_no_self)]
1635    pub fn new() -> Message {
1636        skip_assert_initialized!();
1637        Self::builder().build()
1638    }
1639
1640    pub fn builder<'a>() -> AsyncStartBuilder<'a> {
1641        assert_initialized_main_thread!();
1642        AsyncStartBuilder::new()
1643    }
1644}
1645
1646impl std::fmt::Debug for AsyncStart {
1647    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1648        f.debug_struct("AsyncStart")
1649            .field("structure", &self.message().structure())
1650            .field("source", &self.src().map(|obj| (obj, obj.name())))
1651            .finish()
1652    }
1653}
1654
1655impl std::fmt::Debug for AsyncStart<Message> {
1656    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1657        AsyncStart::<MessageRef>::fmt(self, f)
1658    }
1659}
1660
1661declare_concrete_message!(AsyncDone, T);
1662impl AsyncDone {
1663    #[doc(alias = "gst_message_new_async_done")]
1664    #[allow(clippy::new_ret_no_self)]
1665    pub fn new(running_time: impl Into<Option<crate::ClockTime>>) -> Message {
1666        skip_assert_initialized!();
1667        Self::builder().running_time(running_time).build()
1668    }
1669
1670    pub fn builder<'a>() -> AsyncDoneBuilder<'a> {
1671        assert_initialized_main_thread!();
1672        AsyncDoneBuilder::new()
1673    }
1674
1675    #[doc(alias = "get_running_time")]
1676    #[doc(alias = "gst_message_parse_async_done")]
1677    pub fn running_time(&self) -> Option<crate::ClockTime> {
1678        unsafe {
1679            let mut running_time = mem::MaybeUninit::uninit();
1680
1681            ffi::gst_message_parse_async_done(self.as_mut_ptr(), running_time.as_mut_ptr());
1682
1683            from_glib(running_time.assume_init())
1684        }
1685    }
1686}
1687
1688impl std::fmt::Debug for AsyncDone {
1689    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1690        f.debug_struct("AsyncDone")
1691            .field("structure", &self.message().structure())
1692            .field("source", &self.src().map(|obj| (obj, obj.name())))
1693            .field("running-time", &self.running_time())
1694            .finish()
1695    }
1696}
1697
1698impl std::fmt::Debug for AsyncDone<Message> {
1699    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1700        AsyncDone::<MessageRef>::fmt(self, f)
1701    }
1702}
1703
1704declare_concrete_message!(RequestState, T);
1705impl RequestState {
1706    #[doc(alias = "gst_message_new_request_state")]
1707    #[allow(clippy::new_ret_no_self)]
1708    pub fn new(state: crate::State) -> Message {
1709        skip_assert_initialized!();
1710        Self::builder(state).build()
1711    }
1712
1713    pub fn builder<'a>(state: crate::State) -> RequestStateBuilder<'a> {
1714        assert_initialized_main_thread!();
1715        RequestStateBuilder::new(state)
1716    }
1717
1718    #[doc(alias = "get_requested_state")]
1719    #[doc(alias = "gst_message_parse_request_state")]
1720    pub fn requested_state(&self) -> crate::State {
1721        unsafe {
1722            let mut state = mem::MaybeUninit::uninit();
1723
1724            ffi::gst_message_parse_request_state(self.as_mut_ptr(), state.as_mut_ptr());
1725
1726            from_glib(state.assume_init())
1727        }
1728    }
1729}
1730
1731impl std::fmt::Debug for RequestState {
1732    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1733        f.debug_struct("RequestState")
1734            .field("structure", &self.message().structure())
1735            .field("source", &self.src().map(|obj| (obj, obj.name())))
1736            .field("requested-state", &self.requested_state())
1737            .finish()
1738    }
1739}
1740
1741impl std::fmt::Debug for RequestState<Message> {
1742    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1743        RequestState::<MessageRef>::fmt(self, f)
1744    }
1745}
1746
1747declare_concrete_message!(StepStart, T);
1748impl StepStart {
1749    #[doc(alias = "gst_message_new_step_start")]
1750    #[allow(clippy::new_ret_no_self)]
1751    pub fn new(
1752        active: bool,
1753        amount: impl FormattedValue,
1754        rate: f64,
1755        flush: bool,
1756        intermediate: bool,
1757    ) -> Message {
1758        skip_assert_initialized!();
1759        Self::builder(active, amount, rate, flush, intermediate).build()
1760    }
1761
1762    pub fn builder<'a>(
1763        active: bool,
1764        amount: impl FormattedValue,
1765        rate: f64,
1766        flush: bool,
1767        intermediate: bool,
1768    ) -> StepStartBuilder<'a> {
1769        assert_initialized_main_thread!();
1770        StepStartBuilder::new(active, amount.into(), rate, flush, intermediate)
1771    }
1772
1773    #[doc(alias = "gst_message_parse_step_start")]
1774    pub fn get(&self) -> (bool, GenericFormattedValue, f64, bool, bool) {
1775        unsafe {
1776            let mut active = mem::MaybeUninit::uninit();
1777            let mut format = mem::MaybeUninit::uninit();
1778            let mut amount = mem::MaybeUninit::uninit();
1779            let mut rate = mem::MaybeUninit::uninit();
1780            let mut flush = mem::MaybeUninit::uninit();
1781            let mut intermediate = mem::MaybeUninit::uninit();
1782
1783            ffi::gst_message_parse_step_start(
1784                self.as_mut_ptr(),
1785                active.as_mut_ptr(),
1786                format.as_mut_ptr(),
1787                amount.as_mut_ptr(),
1788                rate.as_mut_ptr(),
1789                flush.as_mut_ptr(),
1790                intermediate.as_mut_ptr(),
1791            );
1792
1793            (
1794                from_glib(active.assume_init()),
1795                GenericFormattedValue::new(
1796                    from_glib(format.assume_init()),
1797                    amount.assume_init() as i64,
1798                ),
1799                rate.assume_init(),
1800                from_glib(flush.assume_init()),
1801                from_glib(intermediate.assume_init()),
1802            )
1803        }
1804    }
1805}
1806
1807impl std::fmt::Debug for StepStart {
1808    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1809        let (active, amount, rate, flush, intermediate) = self.get();
1810        f.debug_struct("StepStart")
1811            .field("structure", &self.message().structure())
1812            .field("source", &self.src().map(|obj| (obj, obj.name())))
1813            .field("active", &active)
1814            .field("amount", &amount)
1815            .field("rate", &rate)
1816            .field("flush", &flush)
1817            .field("intermediate", &intermediate)
1818            .finish()
1819    }
1820}
1821
1822impl std::fmt::Debug for StepStart<Message> {
1823    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1824        StepStart::<MessageRef>::fmt(self, f)
1825    }
1826}
1827
1828declare_concrete_message!(Qos, T);
1829impl Qos {
1830    #[doc(alias = "gst_message_new_qos")]
1831    #[allow(clippy::new_ret_no_self)]
1832    pub fn new(
1833        live: bool,
1834        running_time: impl Into<Option<crate::ClockTime>>,
1835        stream_time: impl Into<Option<crate::ClockTime>>,
1836        timestamp: impl Into<Option<crate::ClockTime>>,
1837        duration: impl Into<Option<crate::ClockTime>>,
1838    ) -> Message {
1839        skip_assert_initialized!();
1840        Self::builder(live)
1841            .running_time(running_time)
1842            .stream_time(stream_time)
1843            .timestamp(timestamp)
1844            .duration(duration)
1845            .build()
1846    }
1847
1848    pub fn builder<'a>(live: bool) -> QosBuilder<'a> {
1849        assert_initialized_main_thread!();
1850        QosBuilder::new(live)
1851    }
1852
1853    #[doc(alias = "gst_message_parse_qos")]
1854    pub fn get(
1855        &self,
1856    ) -> (
1857        bool,
1858        Option<crate::ClockTime>,
1859        Option<crate::ClockTime>,
1860        Option<crate::ClockTime>,
1861        Option<crate::ClockTime>,
1862    ) {
1863        unsafe {
1864            let mut live = mem::MaybeUninit::uninit();
1865            let mut running_time = mem::MaybeUninit::uninit();
1866            let mut stream_time = mem::MaybeUninit::uninit();
1867            let mut timestamp = mem::MaybeUninit::uninit();
1868            let mut duration = mem::MaybeUninit::uninit();
1869
1870            ffi::gst_message_parse_qos(
1871                self.as_mut_ptr(),
1872                live.as_mut_ptr(),
1873                running_time.as_mut_ptr(),
1874                stream_time.as_mut_ptr(),
1875                timestamp.as_mut_ptr(),
1876                duration.as_mut_ptr(),
1877            );
1878
1879            (
1880                from_glib(live.assume_init()),
1881                from_glib(running_time.assume_init()),
1882                from_glib(stream_time.assume_init()),
1883                from_glib(timestamp.assume_init()),
1884                from_glib(duration.assume_init()),
1885            )
1886        }
1887    }
1888
1889    #[doc(alias = "get_values")]
1890    #[doc(alias = "gst_message_parse_qos_values")]
1891    pub fn values(&self) -> (i64, f64, i32) {
1892        unsafe {
1893            let mut jitter = mem::MaybeUninit::uninit();
1894            let mut proportion = mem::MaybeUninit::uninit();
1895            let mut quality = mem::MaybeUninit::uninit();
1896
1897            ffi::gst_message_parse_qos_values(
1898                self.as_mut_ptr(),
1899                jitter.as_mut_ptr(),
1900                proportion.as_mut_ptr(),
1901                quality.as_mut_ptr(),
1902            );
1903
1904            (
1905                jitter.assume_init(),
1906                proportion.assume_init(),
1907                quality.assume_init(),
1908            )
1909        }
1910    }
1911
1912    #[doc(alias = "get_stats")]
1913    #[doc(alias = "gst_message_parse_qos_stats")]
1914    pub fn stats(&self) -> (GenericFormattedValue, GenericFormattedValue) {
1915        unsafe {
1916            let mut format = mem::MaybeUninit::uninit();
1917            let mut processed = mem::MaybeUninit::uninit();
1918            let mut dropped = mem::MaybeUninit::uninit();
1919
1920            ffi::gst_message_parse_qos_stats(
1921                self.as_mut_ptr(),
1922                format.as_mut_ptr(),
1923                processed.as_mut_ptr(),
1924                dropped.as_mut_ptr(),
1925            );
1926
1927            (
1928                GenericFormattedValue::new(
1929                    from_glib(format.assume_init()),
1930                    processed.assume_init() as i64,
1931                ),
1932                GenericFormattedValue::new(
1933                    from_glib(format.assume_init()),
1934                    dropped.assume_init() as i64,
1935                ),
1936            )
1937        }
1938    }
1939}
1940
1941impl std::fmt::Debug for Qos {
1942    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1943        let (live, running_time, stream_time, timestamp, duration) = self.get();
1944        let (jitter, proportion, quality) = self.values();
1945        let (processed, dropped) = self.stats();
1946
1947        f.debug_struct("Qos")
1948            .field("structure", &self.message().structure())
1949            .field("source", &self.src().map(|obj| (obj, obj.name())))
1950            .field("live", &live)
1951            .field("running-time", &running_time)
1952            .field("stream-time", &stream_time)
1953            .field("timestamp", &timestamp)
1954            .field("duration", &duration)
1955            .field("jitter", &jitter)
1956            .field("proportion", &proportion)
1957            .field("quality", &quality)
1958            .field("processed", &processed)
1959            .field("dropped", &dropped)
1960            .finish()
1961    }
1962}
1963
1964impl std::fmt::Debug for Qos<Message> {
1965    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1966        Qos::<MessageRef>::fmt(self, f)
1967    }
1968}
1969
1970declare_concrete_message!(Progress, T);
1971impl Progress {
1972    #[doc(alias = "gst_message_new_progress")]
1973    #[allow(clippy::new_ret_no_self)]
1974    pub fn new(type_: crate::ProgressType, code: &str, text: &str) -> Message {
1975        skip_assert_initialized!();
1976        Self::builder(type_, code, text).build()
1977    }
1978
1979    pub fn builder<'a>(
1980        type_: crate::ProgressType,
1981        code: &'a str,
1982        text: &'a str,
1983    ) -> ProgressBuilder<'a> {
1984        assert_initialized_main_thread!();
1985        ProgressBuilder::new(type_, code, text)
1986    }
1987
1988    #[doc(alias = "gst_message_parse_progress")]
1989    pub fn get(&self) -> (crate::ProgressType, &str, &str) {
1990        unsafe {
1991            let mut type_ = mem::MaybeUninit::uninit();
1992            let mut code = ptr::null_mut();
1993            let mut text = ptr::null_mut();
1994
1995            ffi::gst_message_parse_progress(
1996                self.as_mut_ptr(),
1997                type_.as_mut_ptr(),
1998                &mut code,
1999                &mut text,
2000            );
2001
2002            let code = CStr::from_ptr(code).to_str().unwrap();
2003            let text = CStr::from_ptr(text).to_str().unwrap();
2004
2005            (from_glib(type_.assume_init()), code, text)
2006        }
2007    }
2008}
2009
2010impl std::fmt::Debug for Progress {
2011    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2012        let (type_, code, text) = self.get();
2013        f.debug_struct("Progress")
2014            .field("structure", &self.message().structure())
2015            .field("source", &self.src().map(|obj| (obj, obj.name())))
2016            .field("type", &type_)
2017            .field("code", &code)
2018            .field("text", &text)
2019            .finish()
2020    }
2021}
2022
2023impl std::fmt::Debug for Progress<Message> {
2024    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2025        Progress::<MessageRef>::fmt(self, f)
2026    }
2027}
2028
2029declare_concrete_message!(Toc, T);
2030impl Toc {
2031    // FIXME could use false for updated as default
2032    // Even better: use an enum for updated so that it is more explicit than true / false
2033    #[doc(alias = "gst_message_new_toc")]
2034    #[allow(clippy::new_ret_no_self)]
2035    pub fn new(toc: &crate::Toc, updated: bool) -> Message {
2036        skip_assert_initialized!();
2037        Self::builder(toc, updated).build()
2038    }
2039
2040    pub fn builder(toc: &crate::Toc, updated: bool) -> TocBuilder<'_> {
2041        assert_initialized_main_thread!();
2042        TocBuilder::new(toc, updated)
2043    }
2044
2045    #[doc(alias = "get_toc")]
2046    #[doc(alias = "gst_message_parse_toc")]
2047    pub fn toc(&self) -> (crate::Toc, bool) {
2048        unsafe {
2049            let mut toc = ptr::null_mut();
2050            let mut updated = mem::MaybeUninit::uninit();
2051            ffi::gst_message_parse_toc(self.as_mut_ptr(), &mut toc, updated.as_mut_ptr());
2052            (from_glib_full(toc), from_glib(updated.assume_init()))
2053        }
2054    }
2055}
2056
2057impl std::fmt::Debug for Toc {
2058    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2059        f.debug_struct("Toc")
2060            .field("structure", &self.message().structure())
2061            .field("source", &self.src().map(|obj| (obj, obj.name())))
2062            .field("toc", &self.toc())
2063            .finish()
2064    }
2065}
2066
2067impl std::fmt::Debug for Toc<Message> {
2068    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2069        Toc::<MessageRef>::fmt(self, f)
2070    }
2071}
2072
2073declare_concrete_message!(ResetTime, T);
2074impl ResetTime {
2075    #[doc(alias = "gst_message_new_reset_time")]
2076    #[allow(clippy::new_ret_no_self)]
2077    pub fn new(running_time: crate::ClockTime) -> Message {
2078        skip_assert_initialized!();
2079        Self::builder(running_time).build()
2080    }
2081
2082    pub fn builder<'a>(running_time: crate::ClockTime) -> ResetTimeBuilder<'a> {
2083        assert_initialized_main_thread!();
2084        ResetTimeBuilder::new(running_time)
2085    }
2086
2087    #[doc(alias = "get_running_time")]
2088    #[doc(alias = "gst_message_parse_reset_time")]
2089    pub fn running_time(&self) -> crate::ClockTime {
2090        unsafe {
2091            let mut running_time = mem::MaybeUninit::uninit();
2092
2093            ffi::gst_message_parse_reset_time(self.as_mut_ptr(), running_time.as_mut_ptr());
2094
2095            try_from_glib(running_time.assume_init()).expect("undefined running_time")
2096        }
2097    }
2098}
2099
2100impl std::fmt::Debug for ResetTime {
2101    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2102        f.debug_struct("ResetTime")
2103            .field("structure", &self.message().structure())
2104            .field("source", &self.src().map(|obj| (obj, obj.name())))
2105            .field("running-time", &self.running_time())
2106            .finish()
2107    }
2108}
2109
2110impl std::fmt::Debug for ResetTime<Message> {
2111    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2112        ResetTime::<MessageRef>::fmt(self, f)
2113    }
2114}
2115
2116declare_concrete_message!(StreamStart, T);
2117impl StreamStart {
2118    #[doc(alias = "gst_message_new_stream_start")]
2119    #[allow(clippy::new_ret_no_self)]
2120    pub fn new() -> Message {
2121        skip_assert_initialized!();
2122        Self::builder().build()
2123    }
2124
2125    pub fn builder<'a>() -> StreamStartBuilder<'a> {
2126        assert_initialized_main_thread!();
2127        StreamStartBuilder::new()
2128    }
2129
2130    #[doc(alias = "get_group_id")]
2131    #[doc(alias = "gst_message_parse_group_id")]
2132    pub fn group_id(&self) -> Option<GroupId> {
2133        unsafe {
2134            let mut group_id = mem::MaybeUninit::uninit();
2135
2136            if from_glib(ffi::gst_message_parse_group_id(
2137                self.as_mut_ptr(),
2138                group_id.as_mut_ptr(),
2139            )) {
2140                let group_id = group_id.assume_init();
2141                if group_id == 0 {
2142                    None
2143                } else {
2144                    Some(GroupId(NonZeroU32::new_unchecked(group_id)))
2145                }
2146            } else {
2147                None
2148            }
2149        }
2150    }
2151
2152    #[doc(alias = "gst_message_set_group_id")]
2153    pub fn set_group_id(&mut self, group_id: GroupId) {
2154        unsafe {
2155            ffi::gst_message_set_group_id(self.as_mut_ptr(), group_id.0.get());
2156        }
2157    }
2158}
2159
2160impl std::fmt::Debug for StreamStart {
2161    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2162        f.debug_struct("StreamStart")
2163            .field("structure", &self.message().structure())
2164            .field("source", &self.src().map(|obj| (obj, obj.name())))
2165            .field("group-id", &self.group_id())
2166            .finish()
2167    }
2168}
2169
2170impl std::fmt::Debug for StreamStart<Message> {
2171    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2172        StreamStart::<MessageRef>::fmt(self, f)
2173    }
2174}
2175
2176declare_concrete_message!(NeedContext, T);
2177impl NeedContext {
2178    #[doc(alias = "gst_message_new_need_context")]
2179    #[allow(clippy::new_ret_no_self)]
2180    pub fn new(context_type: &str) -> Message {
2181        skip_assert_initialized!();
2182        Self::builder(context_type).build()
2183    }
2184
2185    pub fn builder(context_type: &str) -> NeedContextBuilder<'_> {
2186        assert_initialized_main_thread!();
2187        NeedContextBuilder::new(context_type)
2188    }
2189
2190    #[doc(alias = "get_context_type")]
2191    #[doc(alias = "gst_message_parse_context_type")]
2192    pub fn context_type(&self) -> &str {
2193        unsafe {
2194            let mut context_type = ptr::null();
2195
2196            ffi::gst_message_parse_context_type(self.as_mut_ptr(), &mut context_type);
2197
2198            CStr::from_ptr(context_type).to_str().unwrap()
2199        }
2200    }
2201}
2202
2203impl std::fmt::Debug for NeedContext {
2204    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2205        f.debug_struct("NeedContext")
2206            .field("structure", &self.message().structure())
2207            .field("source", &self.src().map(|obj| (obj, obj.name())))
2208            .field("context-type", &self.context_type())
2209            .finish()
2210    }
2211}
2212
2213impl std::fmt::Debug for NeedContext<Message> {
2214    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2215        NeedContext::<MessageRef>::fmt(self, f)
2216    }
2217}
2218
2219declare_concrete_message!(HaveContext, T);
2220impl HaveContext {
2221    #[doc(alias = "gst_message_new_have_context")]
2222    #[allow(clippy::new_ret_no_self)]
2223    pub fn new(context: crate::Context) -> Message {
2224        skip_assert_initialized!();
2225        Self::builder(context).build()
2226    }
2227
2228    pub fn builder<'a>(context: crate::Context) -> HaveContextBuilder<'a> {
2229        assert_initialized_main_thread!();
2230        HaveContextBuilder::new(context)
2231    }
2232
2233    #[doc(alias = "get_context")]
2234    #[doc(alias = "gst_message_parse_have_context")]
2235    pub fn context(&self) -> crate::Context {
2236        unsafe {
2237            let mut context = ptr::null_mut();
2238            ffi::gst_message_parse_have_context(self.as_mut_ptr(), &mut context);
2239            from_glib_full(context)
2240        }
2241    }
2242}
2243
2244impl std::fmt::Debug for HaveContext {
2245    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2246        f.debug_struct("HaveContext")
2247            .field("structure", &self.message().structure())
2248            .field("source", &self.src().map(|obj| (obj, obj.name())))
2249            .field("context", &self.context())
2250            .finish()
2251    }
2252}
2253
2254impl std::fmt::Debug for HaveContext<Message> {
2255    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2256        HaveContext::<MessageRef>::fmt(self, f)
2257    }
2258}
2259
2260declare_concrete_message!(DeviceAdded, T);
2261impl DeviceAdded {
2262    #[doc(alias = "gst_message_new_device_added")]
2263    #[allow(clippy::new_ret_no_self)]
2264    pub fn new(device: &crate::Device) -> Message {
2265        skip_assert_initialized!();
2266        Self::builder(device).build()
2267    }
2268
2269    pub fn builder(device: &crate::Device) -> DeviceAddedBuilder<'_> {
2270        assert_initialized_main_thread!();
2271        DeviceAddedBuilder::new(device)
2272    }
2273
2274    #[doc(alias = "get_device")]
2275    #[doc(alias = "gst_message_parse_device_added")]
2276    pub fn device(&self) -> crate::Device {
2277        unsafe {
2278            let mut device = ptr::null_mut();
2279
2280            ffi::gst_message_parse_device_added(self.as_mut_ptr(), &mut device);
2281
2282            from_glib_full(device)
2283        }
2284    }
2285}
2286
2287impl std::fmt::Debug for DeviceAdded {
2288    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2289        f.debug_struct("DeviceAdded")
2290            .field("structure", &self.message().structure())
2291            .field("source", &self.src().map(|obj| (obj, obj.name())))
2292            .field("device", &self.device())
2293            .finish()
2294    }
2295}
2296
2297impl std::fmt::Debug for DeviceAdded<Message> {
2298    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2299        DeviceAdded::<MessageRef>::fmt(self, f)
2300    }
2301}
2302
2303declare_concrete_message!(DeviceRemoved, T);
2304impl DeviceRemoved {
2305    #[doc(alias = "gst_message_new_device_removed")]
2306    #[allow(clippy::new_ret_no_self)]
2307    pub fn new(device: &crate::Device) -> Message {
2308        skip_assert_initialized!();
2309        Self::builder(device).build()
2310    }
2311
2312    pub fn builder(device: &crate::Device) -> DeviceRemovedBuilder<'_> {
2313        assert_initialized_main_thread!();
2314        DeviceRemovedBuilder::new(device)
2315    }
2316
2317    #[doc(alias = "get_device")]
2318    #[doc(alias = "gst_message_parse_device_removed")]
2319    pub fn device(&self) -> crate::Device {
2320        unsafe {
2321            let mut device = ptr::null_mut();
2322
2323            ffi::gst_message_parse_device_removed(self.as_mut_ptr(), &mut device);
2324
2325            from_glib_full(device)
2326        }
2327    }
2328}
2329
2330impl std::fmt::Debug for DeviceRemoved {
2331    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2332        f.debug_struct("DeviceRemoved")
2333            .field("structure", &self.message().structure())
2334            .field("source", &self.src().map(|obj| (obj, obj.name())))
2335            .field("device", &self.device())
2336            .finish()
2337    }
2338}
2339
2340impl std::fmt::Debug for DeviceRemoved<Message> {
2341    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2342        DeviceRemoved::<MessageRef>::fmt(self, f)
2343    }
2344}
2345
2346declare_concrete_message!(PropertyNotify, T);
2347impl PropertyNotify {
2348    #[doc(alias = "gst_message_new_property_notify")]
2349    #[allow(clippy::new_ret_no_self)]
2350    pub fn new(object: &impl IsA<crate::Object>, property_name: &str) -> Message {
2351        skip_assert_initialized!();
2352        Self::builder(object, property_name).build()
2353    }
2354
2355    pub fn builder<'a>(
2356        object: &'a impl IsA<crate::Object>,
2357        property_name: &'a str,
2358    ) -> PropertyNotifyBuilder<'a> {
2359        assert_initialized_main_thread!();
2360        PropertyNotifyBuilder::new(property_name).src(object)
2361    }
2362
2363    #[doc(alias = "gst_message_parse_property_notify")]
2364    pub fn get(&self) -> (Object, &str, Option<&glib::Value>) {
2365        unsafe {
2366            let mut object = ptr::null_mut();
2367            let mut property_name = ptr::null();
2368            let mut value = ptr::null();
2369
2370            ffi::gst_message_parse_property_notify(
2371                self.as_mut_ptr(),
2372                &mut object,
2373                &mut property_name,
2374                &mut value,
2375            );
2376
2377            (
2378                from_glib_none(object),
2379                CStr::from_ptr(property_name).to_str().unwrap(),
2380                if value.is_null() {
2381                    None
2382                } else {
2383                    Some(&*(value as *const glib::Value))
2384                },
2385            )
2386        }
2387    }
2388}
2389
2390impl std::fmt::Debug for PropertyNotify {
2391    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2392        let (object, property_name, value) = self.get();
2393        f.debug_struct("PropertyNotify")
2394            .field("structure", &self.message().structure())
2395            .field("source", &self.src().map(|obj| (obj, obj.name())))
2396            .field("object", &object)
2397            .field("property-name", &property_name)
2398            .field("value", &value)
2399            .finish()
2400    }
2401}
2402
2403impl std::fmt::Debug for PropertyNotify<Message> {
2404    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2405        PropertyNotify::<MessageRef>::fmt(self, f)
2406    }
2407}
2408
2409declare_concrete_message!(StreamCollection, T);
2410impl StreamCollection {
2411    #[doc(alias = "gst_message_new_stream_collection")]
2412    #[allow(clippy::new_ret_no_self)]
2413    pub fn new(collection: &crate::StreamCollection) -> Message {
2414        skip_assert_initialized!();
2415        Self::builder(collection).build()
2416    }
2417
2418    pub fn builder(collection: &crate::StreamCollection) -> StreamCollectionBuilder<'_> {
2419        assert_initialized_main_thread!();
2420        StreamCollectionBuilder::new(collection)
2421    }
2422
2423    #[doc(alias = "get_stream_collection")]
2424    #[doc(alias = "gst_message_parse_stream_collection")]
2425    pub fn stream_collection(&self) -> crate::StreamCollection {
2426        unsafe {
2427            let mut collection = ptr::null_mut();
2428
2429            ffi::gst_message_parse_stream_collection(self.as_mut_ptr(), &mut collection);
2430
2431            from_glib_full(collection)
2432        }
2433    }
2434}
2435
2436impl std::fmt::Debug for StreamCollection {
2437    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2438        f.debug_struct("StreamCollection")
2439            .field("structure", &self.message().structure())
2440            .field("source", &self.src().map(|obj| (obj, obj.name())))
2441            .field("stream-collection", &self.stream_collection())
2442            .finish()
2443    }
2444}
2445
2446impl std::fmt::Debug for StreamCollection<Message> {
2447    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2448        StreamCollection::<MessageRef>::fmt(self, f)
2449    }
2450}
2451
2452declare_concrete_message!(StreamsSelected, T);
2453impl StreamsSelected {
2454    #[doc(alias = "gst_message_new_streams_selected")]
2455    #[allow(clippy::new_ret_no_self)]
2456    pub fn new(collection: &crate::StreamCollection) -> Message {
2457        skip_assert_initialized!();
2458        Self::builder(collection).build()
2459    }
2460
2461    pub fn builder(collection: &crate::StreamCollection) -> StreamsSelectedBuilder<'_> {
2462        assert_initialized_main_thread!();
2463        StreamsSelectedBuilder::new(collection)
2464    }
2465
2466    #[doc(alias = "get_stream_collection")]
2467    #[doc(alias = "gst_message_parse_streams_selected")]
2468    pub fn stream_collection(&self) -> crate::StreamCollection {
2469        unsafe {
2470            let mut collection = ptr::null_mut();
2471
2472            ffi::gst_message_parse_streams_selected(self.as_mut_ptr(), &mut collection);
2473
2474            from_glib_full(collection)
2475        }
2476    }
2477
2478    #[doc(alias = "get_streams")]
2479    #[doc(alias = "gst_message_streams_selected_get_size")]
2480    #[doc(alias = "gst_message_streams_selected_get_stream")]
2481    pub fn streams(&self) -> StreamsSelectedIter<'_> {
2482        StreamsSelectedIter::new(self)
2483    }
2484}
2485
2486impl std::fmt::Debug for StreamsSelected {
2487    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2488        struct StreamsDebug<'a>(&'a StreamsSelected);
2489
2490        impl std::fmt::Debug for StreamsDebug<'_> {
2491            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2492                f.debug_list().entries(self.0.streams()).finish()
2493            }
2494        }
2495
2496        f.debug_struct("StreamsSelected")
2497            .field("structure", &self.message().structure())
2498            .field("source", &self.src().map(|obj| (obj, obj.name())))
2499            .field("stream-collection", &self.stream_collection())
2500            .field("streams", &StreamsDebug(self))
2501            .finish()
2502    }
2503}
2504
2505impl std::fmt::Debug for StreamsSelected<Message> {
2506    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2507        StreamsSelected::<MessageRef>::fmt(self, f)
2508    }
2509}
2510
2511crate::utils::define_fixed_size_iter!(
2512    StreamsSelectedIter,
2513    &'a StreamsSelected,
2514    crate::Stream,
2515    |collection: &StreamsSelected| unsafe {
2516        ffi::gst_message_streams_selected_get_size(collection.as_mut_ptr()) as usize
2517    },
2518    |collection: &StreamsSelected, idx: usize| unsafe {
2519        from_glib_full(ffi::gst_message_streams_selected_get_stream(
2520            collection.as_mut_ptr(),
2521            idx as u32,
2522        ))
2523    }
2524);
2525
2526declare_concrete_message!(Redirect, T);
2527impl Redirect {
2528    #[doc(alias = "gst_message_new_redirect")]
2529    #[allow(clippy::new_ret_no_self)]
2530    pub fn new(location: &str) -> Message {
2531        skip_assert_initialized!();
2532        Self::builder(location).build()
2533    }
2534
2535    pub fn builder(location: &str) -> RedirectBuilder<'_> {
2536        assert_initialized_main_thread!();
2537        RedirectBuilder::new(location)
2538    }
2539
2540    #[doc(alias = "get_entries")]
2541    #[doc(alias = "gst_message_get_num_redirect_entries")]
2542    #[doc(alias = "gst_message_parse_redirect_entry")]
2543    pub fn entries(&self) -> RedirectEntriesIter<'_> {
2544        RedirectEntriesIter::new(self)
2545    }
2546}
2547
2548impl std::fmt::Debug for Redirect {
2549    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2550        struct EntriesDebug<'a>(&'a Redirect);
2551
2552        impl std::fmt::Debug for EntriesDebug<'_> {
2553            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2554                f.debug_list().entries(self.0.entries()).finish()
2555            }
2556        }
2557
2558        f.debug_struct("Redirect")
2559            .field("structure", &self.message().structure())
2560            .field("source", &self.src().map(|obj| (obj, obj.name())))
2561            .field("entries", &EntriesDebug(self))
2562            .finish()
2563    }
2564}
2565
2566impl std::fmt::Debug for Redirect<Message> {
2567    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2568        Redirect::<MessageRef>::fmt(self, f)
2569    }
2570}
2571
2572crate::utils::define_fixed_size_iter!(
2573    RedirectEntriesIter,
2574    &'a Redirect,
2575    (&'a str, Option<TagList>, Option<&'a StructureRef>),
2576    |collection: &Redirect| unsafe {
2577        ffi::gst_message_get_num_redirect_entries(collection.as_mut_ptr()) as usize
2578    },
2579    |collection: &Redirect, idx: usize| unsafe {
2580        let mut location = ptr::null();
2581        let mut tags = ptr::null_mut();
2582        let mut structure = ptr::null();
2583
2584        ffi::gst_message_parse_redirect_entry(
2585            collection.as_mut_ptr(),
2586            idx,
2587            &mut location,
2588            &mut tags,
2589            &mut structure,
2590        );
2591
2592        let structure = if structure.is_null() {
2593            None
2594        } else {
2595            Some(StructureRef::from_glib_borrow(structure))
2596        };
2597
2598        (
2599            CStr::from_ptr(location).to_str().unwrap(),
2600            from_glib_none(tags),
2601            structure,
2602        )
2603    }
2604);
2605
2606#[cfg(feature = "v1_16")]
2607#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2608declare_concrete_message!(DeviceChanged, T);
2609#[cfg(feature = "v1_16")]
2610#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
2611impl DeviceChanged {
2612    #[doc(alias = "gst_message_new_device_changed")]
2613    #[allow(clippy::new_ret_no_self)]
2614    pub fn new(device: &crate::Device, changed_device: &crate::Device) -> Message {
2615        skip_assert_initialized!();
2616        Self::builder(device, changed_device).build()
2617    }
2618
2619    pub fn builder<'a>(
2620        device: &'a crate::Device,
2621        changed_device: &'a crate::Device,
2622    ) -> DeviceChangedBuilder<'a> {
2623        assert_initialized_main_thread!();
2624        DeviceChangedBuilder::new(device, changed_device)
2625    }
2626
2627    #[doc(alias = "get_device_changed")]
2628    #[doc(alias = "gst_message_parse_device_changed")]
2629    pub fn device_changed(&self) -> (crate::Device, crate::Device) {
2630        unsafe {
2631            let mut device = ptr::null_mut();
2632            let mut changed_device = ptr::null_mut();
2633
2634            ffi::gst_message_parse_device_changed(
2635                self.as_mut_ptr(),
2636                &mut device,
2637                &mut changed_device,
2638            );
2639
2640            (from_glib_full(device), from_glib_full(changed_device))
2641        }
2642    }
2643}
2644
2645#[cfg(feature = "v1_16")]
2646impl std::fmt::Debug for DeviceChanged {
2647    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2648        f.debug_struct("DeviceChanged")
2649            .field("structure", &self.message().structure())
2650            .field("source", &self.src().map(|obj| (obj, obj.name())))
2651            .field("device-changed", &self.device_changed())
2652            .finish()
2653    }
2654}
2655
2656#[cfg(feature = "v1_16")]
2657impl std::fmt::Debug for DeviceChanged<Message> {
2658    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2659        DeviceChanged::<MessageRef>::fmt(self, f)
2660    }
2661}
2662
2663#[cfg(feature = "v1_18")]
2664#[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
2665declare_concrete_message!(InstantRateRequest, T);
2666#[cfg(feature = "v1_18")]
2667#[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
2668impl InstantRateRequest {
2669    #[doc(alias = "gst_message_new_instant_rate_request")]
2670    #[allow(clippy::new_ret_no_self)]
2671    pub fn new(rate_multiplier: f64) -> Message {
2672        skip_assert_initialized!();
2673        Self::builder(rate_multiplier).build()
2674    }
2675
2676    pub fn builder<'a>(rate_multiplier: f64) -> InstantRateRequestBuilder<'a> {
2677        assert_initialized_main_thread!();
2678        InstantRateRequestBuilder::new(rate_multiplier)
2679    }
2680
2681    #[doc(alias = "parse_instant_rate_request")]
2682    #[doc(alias = "gst_message_parse_instant_rate_request")]
2683    pub fn rate_multiplier(&self) -> f64 {
2684        unsafe {
2685            let mut rate_multiplier = mem::MaybeUninit::uninit();
2686
2687            ffi::gst_message_parse_instant_rate_request(
2688                self.as_mut_ptr(),
2689                rate_multiplier.as_mut_ptr(),
2690            );
2691
2692            rate_multiplier.assume_init()
2693        }
2694    }
2695}
2696
2697#[cfg(feature = "v1_18")]
2698impl std::fmt::Debug for InstantRateRequest {
2699    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2700        f.debug_struct("InstantRateRequest")
2701            .field("structure", &self.message().structure())
2702            .field("source", &self.src().map(|obj| (obj, obj.name())))
2703            .field("rate-multiplier", &self.rate_multiplier())
2704            .finish()
2705    }
2706}
2707
2708#[cfg(feature = "v1_18")]
2709impl std::fmt::Debug for InstantRateRequest<Message> {
2710    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2711        InstantRateRequest::<MessageRef>::fmt(self, f)
2712    }
2713}
2714
2715struct MessageBuilder<'a> {
2716    src: Option<Object>,
2717    seqnum: Option<Seqnum>,
2718    #[cfg(feature = "v1_26")]
2719    details: Option<Structure>,
2720    other_fields: Vec<(&'a str, glib::SendValue)>,
2721}
2722
2723impl<'a> MessageBuilder<'a> {
2724    fn new() -> Self {
2725        Self {
2726            src: None,
2727            seqnum: None,
2728            #[cfg(feature = "v1_26")]
2729            details: None,
2730            other_fields: Vec::new(),
2731        }
2732    }
2733
2734    pub fn src<O: IsA<Object> + Cast + Clone>(self, src: &O) -> Self {
2735        Self {
2736            src: Some(src.clone().upcast::<Object>()),
2737            ..self
2738        }
2739    }
2740
2741    fn seqnum(self, seqnum: Seqnum) -> Self {
2742        Self {
2743            seqnum: Some(seqnum),
2744            ..self
2745        }
2746    }
2747
2748    #[cfg(feature = "v1_26")]
2749    fn details(self, details: Structure) -> Self {
2750        Self {
2751            details: Some(details),
2752            ..self
2753        }
2754    }
2755
2756    fn other_field(self, name: &'a str, value: impl ToSendValue) -> Self {
2757        let mut other_fields = self.other_fields;
2758        other_fields.push((name, value.to_send_value()));
2759
2760        Self {
2761            other_fields,
2762            ..self
2763        }
2764    }
2765}
2766
2767macro_rules! message_builder_generic_impl {
2768    ($new_fn:expr) => {
2769        #[allow(clippy::needless_update)]
2770        pub fn src<O: IsA<Object> + Cast + Clone>(self, src: &O) -> Self {
2771            Self {
2772                builder: self.builder.src(src),
2773                ..self
2774            }
2775        }
2776
2777        #[allow(clippy::needless_update)]
2778        pub fn src_if<O: IsA<Object> + Cast + Clone>(self, src: &O, predicate: bool) -> Self {
2779            if predicate {
2780                self.src(src)
2781            } else {
2782                self
2783            }
2784        }
2785
2786        #[allow(clippy::needless_update)]
2787        pub fn src_if_some<O: IsA<Object> + Cast + Clone>(self, src: Option<&O>) -> Self {
2788            if let Some(src) = src {
2789                self.src(src)
2790            } else {
2791                self
2792            }
2793        }
2794
2795        #[doc(alias = "gst_message_set_seqnum")]
2796        #[allow(clippy::needless_update)]
2797        pub fn seqnum(self, seqnum: Seqnum) -> Self {
2798            Self {
2799                builder: self.builder.seqnum(seqnum),
2800                ..self
2801            }
2802        }
2803
2804        #[doc(alias = "gst_message_set_seqnum")]
2805        #[allow(clippy::needless_update)]
2806        pub fn seqnum_if(self, seqnum: Seqnum, predicate: bool) -> Self {
2807            if predicate {
2808                self.seqnum(seqnum)
2809            } else {
2810                self
2811            }
2812        }
2813
2814        #[doc(alias = "gst_message_set_seqnum")]
2815        #[allow(clippy::needless_update)]
2816        pub fn seqnum_if_some(self, seqnum: Option<Seqnum>) -> Self {
2817            if let Some(seqnum) = seqnum {
2818                self.seqnum(seqnum)
2819            } else {
2820                self
2821            }
2822        }
2823
2824        #[cfg(feature = "v1_26")]
2825        #[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
2826        #[doc(alias = "gst_message_set_details")]
2827        #[allow(clippy::needless_update)]
2828        pub fn details(self, details: Structure) -> Self {
2829            Self {
2830                builder: self.builder.details(details),
2831                ..self
2832            }
2833        }
2834
2835        #[cfg(feature = "v1_26")]
2836        #[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
2837        #[doc(alias = "gst_message_set_details")]
2838        #[allow(clippy::needless_update)]
2839        pub fn details_if(self, details: Structure, predicate: bool) -> Self {
2840            if predicate {
2841                self.details(details)
2842            } else {
2843                self
2844            }
2845        }
2846
2847        #[cfg(feature = "v1_26")]
2848        #[cfg_attr(docsrs, doc(cfg(feature = "v1_26")))]
2849        #[doc(alias = "gst_message_set_details")]
2850        #[allow(clippy::needless_update)]
2851        pub fn details_if_some(self, details: Option<Structure>) -> Self {
2852            if let Some(details) = details {
2853                self.details(details)
2854            } else {
2855                self
2856            }
2857        }
2858
2859        // rustdoc-stripper-ignore-next
2860        /// Sets field `name` to the given value `value`.
2861        ///
2862        /// Overrides any default or previously defined value for `name`.
2863        #[allow(clippy::needless_update)]
2864        pub fn other_field(self, name: &'a str, value: impl ToSendValue) -> Self {
2865            Self {
2866                builder: self.builder.other_field(name, value),
2867                ..self
2868            }
2869        }
2870
2871        impl_builder_gvalue_extra_setters!(other_field);
2872
2873        #[must_use = "Building the message without using it has no effect"]
2874        #[allow(clippy::redundant_closure_call)]
2875        pub fn build(mut self) -> Message {
2876            unsafe {
2877                let src = self.builder.src.to_glib_none().0;
2878                let msg = $new_fn(&mut self, src);
2879                if let Some(seqnum) = self.builder.seqnum {
2880                    ffi::gst_message_set_seqnum(msg, seqnum.0.get());
2881                }
2882
2883                #[cfg(feature = "v1_26")]
2884                if let Some(details) = self.builder.details {
2885                    ffi::gst_message_set_details(msg, details.into_glib_ptr());
2886                }
2887
2888                if !self.builder.other_fields.is_empty() {
2889                    let structure = ffi::gst_message_writable_structure(msg);
2890
2891                    if !structure.is_null() {
2892                        let structure = StructureRef::from_glib_borrow_mut(structure as *mut _);
2893
2894                        for (k, v) in self.builder.other_fields {
2895                            structure.set_value(k, v);
2896                        }
2897                    }
2898                }
2899
2900                from_glib_full(msg)
2901            }
2902        }
2903    };
2904}
2905
2906#[must_use = "The builder must be built to be used"]
2907pub struct EosBuilder<'a> {
2908    builder: MessageBuilder<'a>,
2909}
2910
2911impl<'a> EosBuilder<'a> {
2912    fn new() -> Self {
2913        skip_assert_initialized!();
2914        Self {
2915            builder: MessageBuilder::new(),
2916        }
2917    }
2918
2919    message_builder_generic_impl!(|_, src| ffi::gst_message_new_eos(src));
2920}
2921
2922pub trait MessageErrorDomain: glib::error::ErrorDomain {}
2923
2924impl MessageErrorDomain for crate::CoreError {}
2925impl MessageErrorDomain for crate::ResourceError {}
2926impl MessageErrorDomain for crate::StreamError {}
2927impl MessageErrorDomain for crate::LibraryError {}
2928
2929#[must_use = "The builder must be built to be used"]
2930pub struct ErrorBuilder<'a> {
2931    builder: MessageBuilder<'a>,
2932    error: glib::Error,
2933    debug: Option<&'a str>,
2934    #[allow(unused)]
2935    details: Option<Structure>,
2936}
2937
2938impl<'a> ErrorBuilder<'a> {
2939    fn new(error: glib::Error) -> Self {
2940        skip_assert_initialized!();
2941        Self {
2942            builder: MessageBuilder::new(),
2943            error,
2944            debug: None,
2945            details: None,
2946        }
2947    }
2948
2949    pub fn debug(self, debug: &'a str) -> Self {
2950        Self {
2951            debug: Some(debug),
2952            ..self
2953        }
2954    }
2955
2956    pub fn debug_if(self, debug: &'a str, predicate: bool) -> Self {
2957        if predicate {
2958            self.debug(debug)
2959        } else {
2960            self
2961        }
2962    }
2963
2964    pub fn debug_if_some(self, debug: Option<&'a str>) -> Self {
2965        if let Some(debug) = debug {
2966            self.debug(debug)
2967        } else {
2968            self
2969        }
2970    }
2971
2972    #[cfg(not(feature = "v1_26"))]
2973    pub fn details(self, details: Structure) -> Self {
2974        Self {
2975            details: Some(details),
2976            ..self
2977        }
2978    }
2979
2980    #[cfg(not(feature = "v1_26"))]
2981    pub fn details_if(self, details: Structure, predicate: bool) -> Self {
2982        if predicate {
2983            self.details(details)
2984        } else {
2985            self
2986        }
2987    }
2988
2989    #[cfg(not(feature = "v1_26"))]
2990    pub fn details_if_some(self, details: Option<Structure>) -> Self {
2991        if let Some(details) = details {
2992            self.details(details)
2993        } else {
2994            self
2995        }
2996    }
2997
2998    message_builder_generic_impl!(|s: &mut Self, src| {
2999        let details = match s.details.take() {
3000            None => ptr::null_mut(),
3001            Some(details) => details.into_glib_ptr(),
3002        };
3003
3004        ffi::gst_message_new_error_with_details(
3005            src,
3006            mut_override(s.error.to_glib_none().0),
3007            s.debug.to_glib_none().0,
3008            details,
3009        )
3010    });
3011}
3012
3013#[must_use = "The builder must be built to be used"]
3014pub struct WarningBuilder<'a> {
3015    builder: MessageBuilder<'a>,
3016    error: glib::Error,
3017    debug: Option<&'a str>,
3018    #[allow(unused)]
3019    details: Option<Structure>,
3020}
3021
3022impl<'a> WarningBuilder<'a> {
3023    fn new(error: glib::Error) -> Self {
3024        skip_assert_initialized!();
3025        Self {
3026            builder: MessageBuilder::new(),
3027            error,
3028            debug: None,
3029            details: None,
3030        }
3031    }
3032
3033    pub fn debug(self, debug: &'a str) -> Self {
3034        Self {
3035            debug: Some(debug),
3036            ..self
3037        }
3038    }
3039
3040    pub fn debug_if(self, debug: &'a str, predicate: bool) -> Self {
3041        if predicate {
3042            self.debug(debug)
3043        } else {
3044            self
3045        }
3046    }
3047
3048    pub fn debug_if_some(self, debug: Option<&'a str>) -> Self {
3049        if let Some(debug) = debug {
3050            self.debug(debug)
3051        } else {
3052            self
3053        }
3054    }
3055
3056    #[cfg(not(feature = "v1_26"))]
3057    pub fn details(self, details: Structure) -> Self {
3058        Self {
3059            details: Some(details),
3060            ..self
3061        }
3062    }
3063
3064    #[cfg(not(feature = "v1_26"))]
3065    pub fn details_if(self, details: Structure, predicate: bool) -> Self {
3066        if predicate {
3067            self.details(details)
3068        } else {
3069            self
3070        }
3071    }
3072
3073    #[cfg(not(feature = "v1_26"))]
3074    pub fn details_if_some(self, details: Option<Structure>) -> Self {
3075        if let Some(details) = details {
3076            self.details(details)
3077        } else {
3078            self
3079        }
3080    }
3081
3082    message_builder_generic_impl!(|s: &mut Self, src| {
3083        let details = match s.details.take() {
3084            None => ptr::null_mut(),
3085            Some(details) => details.into_glib_ptr(),
3086        };
3087
3088        ffi::gst_message_new_warning_with_details(
3089            src,
3090            mut_override(s.error.to_glib_none().0),
3091            s.debug.to_glib_none().0,
3092            details,
3093        )
3094    });
3095}
3096
3097#[must_use = "The builder must be built to be used"]
3098pub struct InfoBuilder<'a> {
3099    builder: MessageBuilder<'a>,
3100    error: glib::Error,
3101    debug: Option<&'a str>,
3102    #[allow(unused)]
3103    details: Option<Structure>,
3104}
3105
3106impl<'a> InfoBuilder<'a> {
3107    fn new(error: glib::Error) -> Self {
3108        skip_assert_initialized!();
3109        Self {
3110            builder: MessageBuilder::new(),
3111            error,
3112            debug: None,
3113            details: None,
3114        }
3115    }
3116
3117    pub fn debug(self, debug: &'a str) -> Self {
3118        Self {
3119            debug: Some(debug),
3120            ..self
3121        }
3122    }
3123
3124    pub fn debug_if(self, debug: &'a str, predicate: bool) -> Self {
3125        if predicate {
3126            self.debug(debug)
3127        } else {
3128            self
3129        }
3130    }
3131
3132    pub fn debug_if_some(self, debug: Option<&'a str>) -> Self {
3133        if let Some(debug) = debug {
3134            self.debug(debug)
3135        } else {
3136            self
3137        }
3138    }
3139
3140    #[cfg(not(feature = "v1_26"))]
3141    pub fn details(self, details: Structure) -> Self {
3142        Self {
3143            details: Some(details),
3144            ..self
3145        }
3146    }
3147
3148    #[cfg(not(feature = "v1_26"))]
3149    pub fn details_if(self, details: Structure, predicate: bool) -> Self {
3150        if predicate {
3151            self.details(details)
3152        } else {
3153            self
3154        }
3155    }
3156
3157    #[cfg(not(feature = "v1_26"))]
3158    pub fn details_if_some(self, details: Option<Structure>) -> Self {
3159        if let Some(details) = details {
3160            self.details(details)
3161        } else {
3162            self
3163        }
3164    }
3165
3166    message_builder_generic_impl!(|s: &mut Self, src| {
3167        let details = match s.details.take() {
3168            None => ptr::null_mut(),
3169            Some(details) => details.into_glib_ptr(),
3170        };
3171
3172        ffi::gst_message_new_info_with_details(
3173            src,
3174            mut_override(s.error.to_glib_none().0),
3175            s.debug.to_glib_none().0,
3176            details,
3177        )
3178    });
3179}
3180
3181#[must_use = "The builder must be built to be used"]
3182pub struct TagBuilder<'a> {
3183    builder: MessageBuilder<'a>,
3184    tags: Option<TagList>,
3185}
3186
3187impl<'a> TagBuilder<'a> {
3188    fn new(tags: TagList) -> Self {
3189        skip_assert_initialized!();
3190        Self {
3191            builder: MessageBuilder::new(),
3192            tags: Some(tags),
3193        }
3194    }
3195
3196    message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_tag(
3197        src,
3198        s.tags.take().into_glib_ptr()
3199    ));
3200}
3201
3202#[must_use = "The builder must be built to be used"]
3203pub struct BufferingBuilder<'a> {
3204    builder: MessageBuilder<'a>,
3205    percent: i32,
3206    stats: Option<(crate::BufferingMode, i32, i32, i64)>,
3207}
3208
3209impl<'a> BufferingBuilder<'a> {
3210    fn new(percent: i32) -> Self {
3211        skip_assert_initialized!();
3212        Self {
3213            builder: MessageBuilder::new(),
3214            percent,
3215            stats: None,
3216        }
3217    }
3218
3219    pub fn stats(
3220        self,
3221        mode: crate::BufferingMode,
3222        avg_in: i32,
3223        avg_out: i32,
3224        buffering_left: i64,
3225    ) -> Self {
3226        skip_assert_initialized!();
3227        Self {
3228            stats: Some((mode, avg_in, avg_out, buffering_left)),
3229            ..self
3230        }
3231    }
3232
3233    message_builder_generic_impl!(|s: &mut Self, src| {
3234        let msg = ffi::gst_message_new_buffering(src, s.percent);
3235
3236        if let Some((mode, avg_in, avg_out, buffering_left)) = s.stats {
3237            ffi::gst_message_set_buffering_stats(
3238                msg,
3239                mode.into_glib(),
3240                avg_in,
3241                avg_out,
3242                buffering_left,
3243            );
3244        }
3245
3246        msg
3247    });
3248}
3249
3250#[must_use = "The builder must be built to be used"]
3251pub struct StateChangedBuilder<'a> {
3252    builder: MessageBuilder<'a>,
3253    old: crate::State,
3254    new: crate::State,
3255    pending: crate::State,
3256}
3257
3258impl<'a> StateChangedBuilder<'a> {
3259    fn new(old: crate::State, new: crate::State, pending: crate::State) -> Self {
3260        skip_assert_initialized!();
3261        Self {
3262            builder: MessageBuilder::new(),
3263            old,
3264            new,
3265            pending,
3266        }
3267    }
3268
3269    message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_state_changed(
3270        src,
3271        s.old.into_glib(),
3272        s.new.into_glib(),
3273        s.pending.into_glib(),
3274    ));
3275}
3276
3277#[must_use = "The builder must be built to be used"]
3278pub struct StateDirtyBuilder<'a> {
3279    builder: MessageBuilder<'a>,
3280}
3281
3282impl<'a> StateDirtyBuilder<'a> {
3283    fn new() -> Self {
3284        skip_assert_initialized!();
3285        Self {
3286            builder: MessageBuilder::new(),
3287        }
3288    }
3289
3290    message_builder_generic_impl!(|_, src| ffi::gst_message_new_state_dirty(src));
3291}
3292
3293#[must_use = "The builder must be built to be used"]
3294pub struct StepDoneBuilder<'a> {
3295    builder: MessageBuilder<'a>,
3296    amount: GenericFormattedValue,
3297    rate: f64,
3298    flush: bool,
3299    intermediate: bool,
3300    duration: Option<crate::ClockTime>,
3301    eos: bool,
3302}
3303
3304impl<'a> StepDoneBuilder<'a> {
3305    fn new(
3306        amount: GenericFormattedValue,
3307        rate: f64,
3308        flush: bool,
3309        intermediate: bool,
3310        duration: Option<crate::ClockTime>,
3311        eos: bool,
3312    ) -> Self {
3313        skip_assert_initialized!();
3314        assert_eq!(amount.format(), duration.format());
3315        Self {
3316            builder: MessageBuilder::new(),
3317            amount,
3318            rate,
3319            flush,
3320            intermediate,
3321            duration,
3322            eos,
3323        }
3324    }
3325
3326    message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_step_done(
3327        src,
3328        s.amount.format().into_glib(),
3329        s.amount.value() as u64,
3330        s.rate,
3331        s.flush.into_glib(),
3332        s.intermediate.into_glib(),
3333        s.duration.into_raw_value() as u64,
3334        s.eos.into_glib(),
3335    ));
3336}
3337
3338#[must_use = "The builder must be built to be used"]
3339pub struct ClockProvideBuilder<'a> {
3340    builder: MessageBuilder<'a>,
3341    clock: &'a crate::Clock,
3342    ready: bool,
3343}
3344
3345impl<'a> ClockProvideBuilder<'a> {
3346    fn new(clock: &'a crate::Clock, ready: bool) -> Self {
3347        skip_assert_initialized!();
3348        Self {
3349            builder: MessageBuilder::new(),
3350            clock,
3351            ready,
3352        }
3353    }
3354
3355    message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_clock_provide(
3356        src,
3357        s.clock.to_glib_none().0,
3358        s.ready.into_glib()
3359    ));
3360}
3361
3362#[must_use = "The builder must be built to be used"]
3363pub struct ClockLostBuilder<'a> {
3364    builder: MessageBuilder<'a>,
3365    clock: &'a crate::Clock,
3366}
3367
3368impl<'a> ClockLostBuilder<'a> {
3369    fn new(clock: &'a crate::Clock) -> Self {
3370        skip_assert_initialized!();
3371        Self {
3372            builder: MessageBuilder::new(),
3373            clock,
3374        }
3375    }
3376
3377    message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_clock_lost(
3378        src,
3379        s.clock.to_glib_none().0
3380    ));
3381}
3382
3383#[must_use = "The builder must be built to be used"]
3384pub struct NewClockBuilder<'a> {
3385    builder: MessageBuilder<'a>,
3386    clock: &'a crate::Clock,
3387}
3388
3389impl<'a> NewClockBuilder<'a> {
3390    fn new(clock: &'a crate::Clock) -> Self {
3391        skip_assert_initialized!();
3392        Self {
3393            builder: MessageBuilder::new(),
3394            clock,
3395        }
3396    }
3397
3398    message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_new_clock(
3399        src,
3400        s.clock.to_glib_none().0
3401    ));
3402}
3403
3404#[must_use = "The builder must be built to be used"]
3405pub struct StructureChangeBuilder<'a> {
3406    builder: MessageBuilder<'a>,
3407    type_: crate::StructureChangeType,
3408    owner: &'a crate::Element,
3409    busy: bool,
3410}
3411
3412impl<'a> StructureChangeBuilder<'a> {
3413    fn new(type_: crate::StructureChangeType, owner: &'a crate::Element, busy: bool) -> Self {
3414        skip_assert_initialized!();
3415        Self {
3416            builder: MessageBuilder::new(),
3417            type_,
3418            owner,
3419            busy,
3420        }
3421    }
3422
3423    message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_structure_change(
3424        src,
3425        s.type_.into_glib(),
3426        s.owner.to_glib_none().0,
3427        s.busy.into_glib(),
3428    ));
3429}
3430
3431#[must_use = "The builder must be built to be used"]
3432pub struct StreamStatusBuilder<'a> {
3433    builder: MessageBuilder<'a>,
3434    type_: crate::StreamStatusType,
3435    owner: &'a crate::Element,
3436    status_object: Option<glib::SendValue>,
3437}
3438
3439impl<'a> StreamStatusBuilder<'a> {
3440    fn new(type_: crate::StreamStatusType, owner: &'a crate::Element) -> Self {
3441        skip_assert_initialized!();
3442        Self {
3443            builder: MessageBuilder::new(),
3444            type_,
3445            owner,
3446            status_object: None,
3447        }
3448    }
3449
3450    pub fn status_object(self, status_object: impl ToSendValue) -> Self {
3451        Self {
3452            status_object: Some(status_object.to_send_value()),
3453            ..self
3454        }
3455    }
3456
3457    pub fn status_object_if(self, status_object: impl ToSendValue, predicate: bool) -> Self {
3458        if predicate {
3459            self.status_object(status_object)
3460        } else {
3461            self
3462        }
3463    }
3464
3465    pub fn status_object_if_some(self, status_object: Option<impl ToSendValue>) -> Self {
3466        if let Some(status_object) = status_object {
3467            self.status_object(status_object)
3468        } else {
3469            self
3470        }
3471    }
3472
3473    message_builder_generic_impl!(|s: &mut Self, src| {
3474        let msg =
3475            ffi::gst_message_new_stream_status(src, s.type_.into_glib(), s.owner.to_glib_none().0);
3476        if let Some(ref status_object) = s.status_object {
3477            ffi::gst_message_set_stream_status_object(msg, status_object.to_glib_none().0);
3478        }
3479        msg
3480    });
3481}
3482
3483#[must_use = "The builder must be built to be used"]
3484pub struct ApplicationBuilder<'a> {
3485    builder: MessageBuilder<'a>,
3486    structure: Option<crate::Structure>,
3487}
3488
3489impl<'a> ApplicationBuilder<'a> {
3490    fn new(structure: crate::Structure) -> Self {
3491        skip_assert_initialized!();
3492        Self {
3493            builder: MessageBuilder::new(),
3494            structure: Some(structure),
3495        }
3496    }
3497
3498    message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_application(
3499        src,
3500        s.structure.take().unwrap().into_glib_ptr()
3501    ));
3502}
3503
3504#[must_use = "The builder must be built to be used"]
3505pub struct ElementBuilder<'a> {
3506    builder: MessageBuilder<'a>,
3507    structure: Option<crate::Structure>,
3508}
3509
3510impl<'a> ElementBuilder<'a> {
3511    fn new(structure: crate::Structure) -> Self {
3512        skip_assert_initialized!();
3513        Self {
3514            builder: MessageBuilder::new(),
3515            structure: Some(structure),
3516        }
3517    }
3518
3519    message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_element(
3520        src,
3521        s.structure.take().unwrap().into_glib_ptr()
3522    ));
3523}
3524
3525#[must_use = "The builder must be built to be used"]
3526pub struct SegmentStartBuilder<'a> {
3527    builder: MessageBuilder<'a>,
3528    position: GenericFormattedValue,
3529}
3530
3531impl<'a> SegmentStartBuilder<'a> {
3532    fn new(position: GenericFormattedValue) -> Self {
3533        skip_assert_initialized!();
3534        Self {
3535            builder: MessageBuilder::new(),
3536            position,
3537        }
3538    }
3539
3540    message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_segment_start(
3541        src,
3542        s.position.format().into_glib(),
3543        s.position.value(),
3544    ));
3545}
3546
3547#[must_use = "The builder must be built to be used"]
3548pub struct SegmentDoneBuilder<'a> {
3549    builder: MessageBuilder<'a>,
3550    position: GenericFormattedValue,
3551}
3552
3553impl<'a> SegmentDoneBuilder<'a> {
3554    fn new(position: GenericFormattedValue) -> Self {
3555        skip_assert_initialized!();
3556        Self {
3557            builder: MessageBuilder::new(),
3558            position,
3559        }
3560    }
3561
3562    message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_segment_done(
3563        src,
3564        s.position.format().into_glib(),
3565        s.position.value(),
3566    ));
3567}
3568
3569#[must_use = "The builder must be built to be used"]
3570pub struct DurationChangedBuilder<'a> {
3571    builder: MessageBuilder<'a>,
3572}
3573
3574impl<'a> DurationChangedBuilder<'a> {
3575    fn new() -> Self {
3576        skip_assert_initialized!();
3577        Self {
3578            builder: MessageBuilder::new(),
3579        }
3580    }
3581
3582    message_builder_generic_impl!(|_, src| ffi::gst_message_new_duration_changed(src));
3583}
3584
3585#[must_use = "The builder must be built to be used"]
3586pub struct LatencyBuilder<'a> {
3587    builder: MessageBuilder<'a>,
3588}
3589
3590impl<'a> LatencyBuilder<'a> {
3591    fn new() -> Self {
3592        skip_assert_initialized!();
3593        Self {
3594            builder: MessageBuilder::new(),
3595        }
3596    }
3597
3598    message_builder_generic_impl!(|_, src| ffi::gst_message_new_latency(src));
3599}
3600
3601#[must_use = "The builder must be built to be used"]
3602pub struct AsyncStartBuilder<'a> {
3603    builder: MessageBuilder<'a>,
3604}
3605
3606impl<'a> AsyncStartBuilder<'a> {
3607    fn new() -> Self {
3608        skip_assert_initialized!();
3609        Self {
3610            builder: MessageBuilder::new(),
3611        }
3612    }
3613
3614    message_builder_generic_impl!(|_, src| ffi::gst_message_new_async_start(src));
3615}
3616
3617#[must_use = "The builder must be built to be used"]
3618pub struct AsyncDoneBuilder<'a> {
3619    builder: MessageBuilder<'a>,
3620    running_time: Option<crate::ClockTime>,
3621}
3622
3623impl<'a> AsyncDoneBuilder<'a> {
3624    fn new() -> Self {
3625        skip_assert_initialized!();
3626        Self {
3627            builder: MessageBuilder::new(),
3628            running_time: None,
3629        }
3630    }
3631
3632    pub fn running_time(mut self, running_time: impl Into<Option<crate::ClockTime>>) -> Self {
3633        self.running_time = running_time.into();
3634        self
3635    }
3636
3637    pub fn running_time_if(self, running_time: crate::ClockTime, predicate: bool) -> Self {
3638        if predicate {
3639            self.running_time(running_time)
3640        } else {
3641            self
3642        }
3643    }
3644
3645    pub fn running_time_if_some(self, running_time: Option<crate::ClockTime>) -> Self {
3646        if let Some(running_time) = running_time {
3647            self.running_time(running_time)
3648        } else {
3649            self
3650        }
3651    }
3652
3653    message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_async_done(
3654        src,
3655        s.running_time.into_glib()
3656    ));
3657}
3658
3659#[must_use = "The builder must be built to be used"]
3660pub struct RequestStateBuilder<'a> {
3661    builder: MessageBuilder<'a>,
3662    state: crate::State,
3663}
3664
3665impl<'a> RequestStateBuilder<'a> {
3666    fn new(state: crate::State) -> Self {
3667        skip_assert_initialized!();
3668        Self {
3669            builder: MessageBuilder::new(),
3670            state,
3671        }
3672    }
3673
3674    message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_request_state(
3675        src,
3676        s.state.into_glib()
3677    ));
3678}
3679
3680#[must_use = "The builder must be built to be used"]
3681pub struct StepStartBuilder<'a> {
3682    builder: MessageBuilder<'a>,
3683    active: bool,
3684    amount: GenericFormattedValue,
3685    rate: f64,
3686    flush: bool,
3687    intermediate: bool,
3688}
3689
3690impl<'a> StepStartBuilder<'a> {
3691    fn new(
3692        active: bool,
3693        amount: GenericFormattedValue,
3694        rate: f64,
3695        flush: bool,
3696        intermediate: bool,
3697    ) -> Self {
3698        skip_assert_initialized!();
3699        Self {
3700            builder: MessageBuilder::new(),
3701            active,
3702            amount,
3703            rate,
3704            flush,
3705            intermediate,
3706        }
3707    }
3708
3709    message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_step_start(
3710        src,
3711        s.active.into_glib(),
3712        s.amount.format().into_glib(),
3713        s.amount.value() as u64,
3714        s.rate,
3715        s.flush.into_glib(),
3716        s.intermediate.into_glib(),
3717    ));
3718}
3719
3720#[must_use = "The builder must be built to be used"]
3721pub struct QosBuilder<'a> {
3722    builder: MessageBuilder<'a>,
3723    live: bool,
3724    running_time: Option<crate::ClockTime>,
3725    stream_time: Option<crate::ClockTime>,
3726    timestamp: Option<crate::ClockTime>,
3727    duration: Option<crate::ClockTime>,
3728    values: Option<(i64, f64, i32)>,
3729    stats: Option<(GenericFormattedValue, GenericFormattedValue)>,
3730}
3731
3732impl<'a> QosBuilder<'a> {
3733    fn new(live: bool) -> Self {
3734        skip_assert_initialized!();
3735        Self {
3736            builder: MessageBuilder::new(),
3737            live,
3738            running_time: None,
3739            stream_time: None,
3740            timestamp: None,
3741            duration: None,
3742            values: None,
3743            stats: None,
3744        }
3745    }
3746
3747    pub fn running_time(mut self, running_time: impl Into<Option<crate::ClockTime>>) -> Self {
3748        self.running_time = running_time.into();
3749        self
3750    }
3751
3752    pub fn running_time_if(self, running_time: crate::ClockTime, predicate: bool) -> Self {
3753        if predicate {
3754            self.running_time(running_time)
3755        } else {
3756            self
3757        }
3758    }
3759
3760    pub fn running_time_if_some(self, running_time: Option<crate::ClockTime>) -> Self {
3761        if let Some(running_time) = running_time {
3762            self.running_time(running_time)
3763        } else {
3764            self
3765        }
3766    }
3767
3768    pub fn stream_time(mut self, stream_time: impl Into<Option<crate::ClockTime>>) -> Self {
3769        self.stream_time = stream_time.into();
3770        self
3771    }
3772
3773    pub fn stream_time_if(self, stream_time: crate::ClockTime, predicate: bool) -> Self {
3774        if predicate {
3775            self.stream_time(stream_time)
3776        } else {
3777            self
3778        }
3779    }
3780
3781    pub fn stream_time_if_some(self, stream_time: Option<crate::ClockTime>) -> Self {
3782        if let Some(stream_time) = stream_time {
3783            self.stream_time(stream_time)
3784        } else {
3785            self
3786        }
3787    }
3788
3789    pub fn timestamp(mut self, timestamp: impl Into<Option<crate::ClockTime>>) -> Self {
3790        self.timestamp = timestamp.into();
3791        self
3792    }
3793
3794    pub fn timestamp_if(self, timestamp: crate::ClockTime, predicate: bool) -> Self {
3795        if predicate {
3796            self.timestamp(timestamp)
3797        } else {
3798            self
3799        }
3800    }
3801
3802    pub fn timestamp_if_some(self, timestamp: Option<crate::ClockTime>) -> Self {
3803        if let Some(timestamp) = timestamp {
3804            self.timestamp(timestamp)
3805        } else {
3806            self
3807        }
3808    }
3809
3810    pub fn duration(mut self, duration: impl Into<Option<crate::ClockTime>>) -> Self {
3811        self.duration = duration.into();
3812        self
3813    }
3814
3815    pub fn duration_if(self, duration: crate::ClockTime, predicate: bool) -> Self {
3816        if predicate {
3817            self.duration(duration)
3818        } else {
3819            self
3820        }
3821    }
3822
3823    pub fn duration_if_some(self, duration: Option<crate::ClockTime>) -> Self {
3824        if let Some(duration) = duration {
3825            self.duration(duration)
3826        } else {
3827            self
3828        }
3829    }
3830
3831    pub fn values(self, jitter: i64, proportion: f64, quality: i32) -> Self {
3832        Self {
3833            values: Some((jitter, proportion, quality)),
3834            ..self
3835        }
3836    }
3837
3838    pub fn stats<V: FormattedValue>(
3839        self,
3840        processed: V,
3841        dropped: impl CompatibleFormattedValue<V>,
3842    ) -> Self {
3843        let dropped = dropped.try_into_checked(processed).unwrap();
3844        Self {
3845            stats: Some((processed.into(), dropped.into())),
3846            ..self
3847        }
3848    }
3849
3850    message_builder_generic_impl!(|s: &mut Self, src| {
3851        let msg = ffi::gst_message_new_qos(
3852            src,
3853            s.live.into_glib(),
3854            s.running_time.into_glib(),
3855            s.stream_time.into_glib(),
3856            s.timestamp.into_glib(),
3857            s.duration.into_glib(),
3858        );
3859        if let Some((jitter, proportion, quality)) = s.values {
3860            ffi::gst_message_set_qos_values(msg, jitter, proportion, quality);
3861        }
3862        if let Some((processed, dropped)) = s.stats {
3863            ffi::gst_message_set_qos_stats(
3864                msg,
3865                processed.format().into_glib(),
3866                processed.value() as u64,
3867                dropped.value() as u64,
3868            );
3869        }
3870        msg
3871    });
3872}
3873
3874#[must_use = "The builder must be built to be used"]
3875pub struct ProgressBuilder<'a> {
3876    builder: MessageBuilder<'a>,
3877    type_: crate::ProgressType,
3878    code: &'a str,
3879    text: &'a str,
3880}
3881
3882impl<'a> ProgressBuilder<'a> {
3883    fn new(type_: crate::ProgressType, code: &'a str, text: &'a str) -> Self {
3884        skip_assert_initialized!();
3885        Self {
3886            builder: MessageBuilder::new(),
3887            type_,
3888            code,
3889            text,
3890        }
3891    }
3892
3893    message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_progress(
3894        src,
3895        s.type_.into_glib(),
3896        s.code.to_glib_none().0,
3897        s.text.to_glib_none().0,
3898    ));
3899}
3900
3901#[must_use = "The builder must be built to be used"]
3902pub struct TocBuilder<'a> {
3903    builder: MessageBuilder<'a>,
3904    toc: &'a crate::Toc,
3905    updated: bool,
3906}
3907
3908impl<'a> TocBuilder<'a> {
3909    fn new(toc: &'a crate::Toc, updated: bool) -> Self {
3910        skip_assert_initialized!();
3911        Self {
3912            builder: MessageBuilder::new(),
3913            toc,
3914            updated,
3915        }
3916    }
3917
3918    message_builder_generic_impl!(|s: &Self, src| ffi::gst_message_new_toc(
3919        src,
3920        s.toc.to_glib_none().0,
3921        s.updated.into_glib()
3922    ));
3923}
3924
3925#[must_use = "The builder must be built to be used"]
3926pub struct ResetTimeBuilder<'a> {
3927    builder: MessageBuilder<'a>,
3928    running_time: crate::ClockTime,
3929}
3930
3931impl<'a> ResetTimeBuilder<'a> {
3932    fn new(running_time: crate::ClockTime) -> Self {
3933        skip_assert_initialized!();
3934        Self {
3935            builder: MessageBuilder::new(),
3936            running_time,
3937        }
3938    }
3939
3940    message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_reset_time(
3941        src,
3942        s.running_time.into_glib()
3943    ));
3944}
3945
3946#[must_use = "The builder must be built to be used"]
3947pub struct StreamStartBuilder<'a> {
3948    builder: MessageBuilder<'a>,
3949    group_id: Option<GroupId>,
3950}
3951
3952impl<'a> StreamStartBuilder<'a> {
3953    fn new() -> Self {
3954        skip_assert_initialized!();
3955        Self {
3956            builder: MessageBuilder::new(),
3957            group_id: None,
3958        }
3959    }
3960
3961    pub fn group_id(self, group_id: GroupId) -> Self {
3962        Self {
3963            group_id: Some(group_id),
3964            ..self
3965        }
3966    }
3967
3968    pub fn group_id_if(self, group_id: GroupId, predicate: bool) -> Self {
3969        if predicate {
3970            self.group_id(group_id)
3971        } else {
3972            self
3973        }
3974    }
3975
3976    pub fn group_id_if_some(self, group_id: Option<GroupId>) -> Self {
3977        if let Some(group_id) = group_id {
3978            self.group_id(group_id)
3979        } else {
3980            self
3981        }
3982    }
3983
3984    message_builder_generic_impl!(|s: &mut Self, src| {
3985        let msg = ffi::gst_message_new_stream_start(src);
3986        if let Some(group_id) = s.group_id {
3987            ffi::gst_message_set_group_id(msg, group_id.0.get());
3988        }
3989        msg
3990    });
3991}
3992
3993#[must_use = "The builder must be built to be used"]
3994pub struct NeedContextBuilder<'a> {
3995    builder: MessageBuilder<'a>,
3996    context_type: &'a str,
3997}
3998
3999impl<'a> NeedContextBuilder<'a> {
4000    fn new(context_type: &'a str) -> Self {
4001        skip_assert_initialized!();
4002        Self {
4003            builder: MessageBuilder::new(),
4004            context_type,
4005        }
4006    }
4007
4008    message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_need_context(
4009        src,
4010        s.context_type.to_glib_none().0
4011    ));
4012}
4013
4014#[must_use = "The builder must be built to be used"]
4015pub struct HaveContextBuilder<'a> {
4016    builder: MessageBuilder<'a>,
4017    context: Option<crate::Context>,
4018}
4019
4020impl<'a> HaveContextBuilder<'a> {
4021    fn new(context: crate::Context) -> Self {
4022        skip_assert_initialized!();
4023        Self {
4024            builder: MessageBuilder::new(),
4025            context: Some(context),
4026        }
4027    }
4028
4029    message_builder_generic_impl!(|s: &mut Self, src| {
4030        let context = s.context.take().unwrap();
4031        ffi::gst_message_new_have_context(src, context.into_glib_ptr())
4032    });
4033}
4034
4035#[must_use = "The builder must be built to be used"]
4036pub struct DeviceAddedBuilder<'a> {
4037    builder: MessageBuilder<'a>,
4038    device: &'a crate::Device,
4039}
4040
4041impl<'a> DeviceAddedBuilder<'a> {
4042    fn new(device: &'a crate::Device) -> Self {
4043        skip_assert_initialized!();
4044        Self {
4045            builder: MessageBuilder::new(),
4046            device,
4047        }
4048    }
4049
4050    message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_device_added(
4051        src,
4052        s.device.to_glib_none().0
4053    ));
4054}
4055
4056#[must_use = "The builder must be built to be used"]
4057pub struct DeviceRemovedBuilder<'a> {
4058    builder: MessageBuilder<'a>,
4059    device: &'a crate::Device,
4060}
4061
4062impl<'a> DeviceRemovedBuilder<'a> {
4063    fn new(device: &'a crate::Device) -> Self {
4064        skip_assert_initialized!();
4065        Self {
4066            builder: MessageBuilder::new(),
4067            device,
4068        }
4069    }
4070
4071    message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_device_removed(
4072        src,
4073        s.device.to_glib_none().0
4074    ));
4075}
4076
4077#[must_use = "The builder must be built to be used"]
4078pub struct PropertyNotifyBuilder<'a> {
4079    builder: MessageBuilder<'a>,
4080    property_name: &'a str,
4081    value: Option<glib::SendValue>,
4082}
4083
4084impl<'a> PropertyNotifyBuilder<'a> {
4085    fn new(property_name: &'a str) -> Self {
4086        skip_assert_initialized!();
4087        Self {
4088            builder: MessageBuilder::new(),
4089            property_name,
4090            value: None,
4091        }
4092    }
4093
4094    pub fn value(self, value: impl ToSendValue) -> Self {
4095        Self {
4096            value: Some(value.to_send_value()),
4097            ..self
4098        }
4099    }
4100
4101    pub fn value_if(self, value: impl ToSendValue, predicate: bool) -> Self {
4102        if predicate {
4103            self.value(value)
4104        } else {
4105            self
4106        }
4107    }
4108
4109    pub fn value_if_some(self, value: Option<impl ToSendValue>) -> Self {
4110        if let Some(value) = value {
4111            self.value(value)
4112        } else {
4113            self
4114        }
4115    }
4116
4117    pub fn value_from_iter<V: ValueType + ToSendValue + FromIterator<SendValue>, I: ToSendValue>(
4118        self,
4119        name: &'a str,
4120        iter: impl IntoIterator<Item = I>,
4121    ) -> Self {
4122        let iter = iter.into_iter().map(|item| item.to_send_value());
4123        self.other_field(name, V::from_iter(iter))
4124    }
4125
4126    pub fn value_field_if_not_empty<
4127        V: ValueType + ToSendValue + FromIterator<SendValue>,
4128        I: ToSendValue,
4129    >(
4130        self,
4131        name: &'a str,
4132        iter: impl IntoIterator<Item = I>,
4133    ) -> Self {
4134        let mut iter = iter.into_iter().peekable();
4135        if iter.peek().is_some() {
4136            let iter = iter.map(|item| item.to_send_value());
4137            self.other_field(name, V::from_iter(iter))
4138        } else {
4139            self
4140        }
4141    }
4142
4143    message_builder_generic_impl!(|s: &mut Self, src| {
4144        let v = s.value.take();
4145        ffi::gst_message_new_property_notify(
4146            src,
4147            s.property_name.to_glib_none().0,
4148            v.as_ref().map(|v| v.as_ptr()).unwrap_or(ptr::null_mut()),
4149        )
4150    });
4151}
4152
4153#[must_use = "The builder must be built to be used"]
4154pub struct StreamCollectionBuilder<'a> {
4155    builder: MessageBuilder<'a>,
4156    collection: &'a crate::StreamCollection,
4157}
4158
4159impl<'a> StreamCollectionBuilder<'a> {
4160    fn new(collection: &'a crate::StreamCollection) -> Self {
4161        skip_assert_initialized!();
4162        Self {
4163            builder: MessageBuilder::new(),
4164            collection,
4165        }
4166    }
4167
4168    message_builder_generic_impl!(|s: &mut Self, src| {
4169        ffi::gst_message_new_stream_collection(src, s.collection.to_glib_none().0)
4170    });
4171}
4172
4173#[must_use = "The builder must be built to be used"]
4174pub struct StreamsSelectedBuilder<'a> {
4175    builder: MessageBuilder<'a>,
4176    collection: &'a crate::StreamCollection,
4177    streams: SmallVec<[crate::Stream; 8]>,
4178}
4179
4180impl<'a> StreamsSelectedBuilder<'a> {
4181    fn new(collection: &'a crate::StreamCollection) -> Self {
4182        skip_assert_initialized!();
4183        Self {
4184            builder: MessageBuilder::new(),
4185            collection,
4186            streams: SmallVec::default(),
4187        }
4188    }
4189
4190    pub fn streams<S: std::borrow::Borrow<crate::Stream>>(
4191        self,
4192        streams: impl IntoIterator<Item = S>,
4193    ) -> Self {
4194        Self {
4195            streams: streams
4196                .into_iter()
4197                .map(|s| s.borrow().clone())
4198                .collect::<SmallVec<_>>(),
4199            ..self
4200        }
4201    }
4202
4203    pub fn streams_if<S: std::borrow::Borrow<crate::Stream>>(
4204        self,
4205        streams: impl IntoIterator<Item = S>,
4206        predicate: bool,
4207    ) -> Self {
4208        if predicate {
4209            self.streams(streams)
4210        } else {
4211            self
4212        }
4213    }
4214
4215    pub fn streams_if_some<S: std::borrow::Borrow<crate::Stream>>(
4216        self,
4217        streams: Option<impl IntoIterator<Item = S>>,
4218    ) -> Self {
4219        if let Some(streams) = streams {
4220            self.streams(streams)
4221        } else {
4222            self
4223        }
4224    }
4225
4226    pub fn streams_if_not_empty<S: std::borrow::Borrow<crate::Stream>>(
4227        self,
4228        streams: impl IntoIterator<Item = S>,
4229    ) -> Self {
4230        let mut streams = streams.into_iter().peekable();
4231        if streams.peek().is_some() {
4232            self.streams(streams)
4233        } else {
4234            self
4235        }
4236    }
4237
4238    message_builder_generic_impl!(|s: &mut Self, src| {
4239        let msg = ffi::gst_message_new_streams_selected(src, s.collection.to_glib_none().0);
4240        for stream in &s.streams {
4241            ffi::gst_message_streams_selected_add(msg, stream.to_glib_none().0);
4242        }
4243        msg
4244    });
4245}
4246
4247#[must_use = "The builder must be built to be used"]
4248pub struct RedirectBuilder<'a> {
4249    builder: MessageBuilder<'a>,
4250    location: &'a str,
4251    tag_list: Option<TagList>,
4252    entry_struct: Option<Structure>,
4253    #[allow(clippy::type_complexity)]
4254    entries: SmallVec<[(&'a str, Option<TagList>, Option<Structure>); 4]>,
4255}
4256
4257impl<'a> RedirectBuilder<'a> {
4258    fn new(location: &'a str) -> Self {
4259        skip_assert_initialized!();
4260        Self {
4261            builder: MessageBuilder::new(),
4262            location,
4263            tag_list: None,
4264            entry_struct: None,
4265            entries: SmallVec::default(),
4266        }
4267    }
4268
4269    pub fn tag_list(self, tag_list: TagList) -> Self {
4270        Self {
4271            tag_list: Some(tag_list),
4272            ..self
4273        }
4274    }
4275
4276    pub fn tag_list_if(self, tag_list: TagList, predicate: bool) -> Self {
4277        if predicate {
4278            self.tag_list(tag_list)
4279        } else {
4280            self
4281        }
4282    }
4283
4284    pub fn tag_list_if_some(self, tag_list: Option<TagList>) -> Self {
4285        if let Some(tag_list) = tag_list {
4286            self.tag_list(tag_list)
4287        } else {
4288            self
4289        }
4290    }
4291
4292    pub fn entry_struct(self, entry_struct: Structure) -> Self {
4293        Self {
4294            entry_struct: Some(entry_struct),
4295            ..self
4296        }
4297    }
4298
4299    pub fn entry_struct_if(self, entry_struct: Structure, predicate: bool) -> Self {
4300        if predicate {
4301            self.entry_struct(entry_struct)
4302        } else {
4303            self
4304        }
4305    }
4306
4307    pub fn entry_struct_if_some(self, entry_struct: Option<Structure>) -> Self {
4308        if let Some(entry_struct) = entry_struct {
4309            self.entry_struct(entry_struct)
4310        } else {
4311            self
4312        }
4313    }
4314
4315    pub fn entries(
4316        self,
4317        entries: impl IntoIterator<Item = (&'a str, Option<TagList>, Option<Structure>)>,
4318    ) -> Self {
4319        skip_assert_initialized!();
4320        Self {
4321            entries: entries.into_iter().collect(),
4322            ..self
4323        }
4324    }
4325
4326    #[allow(clippy::type_complexity)]
4327    pub fn entries_if(
4328        self,
4329        entries: impl IntoIterator<Item = (&'a str, Option<TagList>, Option<Structure>)>,
4330        predicate: bool,
4331    ) -> Self {
4332        if predicate {
4333            self.entries(entries)
4334        } else {
4335            self
4336        }
4337    }
4338
4339    #[allow(clippy::type_complexity)]
4340    pub fn entries_if_some(
4341        self,
4342        entries: Option<impl IntoIterator<Item = (&'a str, Option<TagList>, Option<Structure>)>>,
4343    ) -> Self {
4344        if let Some(entries) = entries {
4345            self.entries(entries)
4346        } else {
4347            self
4348        }
4349    }
4350
4351    message_builder_generic_impl!(|s: &mut Self, src| {
4352        let entry_struct = s.entry_struct.take();
4353        let tag_list = s.tag_list.take();
4354
4355        let msg = ffi::gst_message_new_redirect(
4356            src,
4357            s.location.to_glib_none().0,
4358            tag_list.into_glib_ptr(),
4359            entry_struct.into_glib_ptr(),
4360        );
4361        for (location, tag_list, entry_struct) in mem::take(&mut s.entries) {
4362            ffi::gst_message_add_redirect_entry(
4363                msg,
4364                location.to_glib_none().0,
4365                tag_list.into_glib_ptr(),
4366                entry_struct.into_glib_ptr(),
4367            );
4368        }
4369        msg
4370    });
4371}
4372
4373#[cfg(feature = "v1_16")]
4374#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
4375#[must_use = "The builder must be built to be used"]
4376pub struct DeviceChangedBuilder<'a> {
4377    builder: MessageBuilder<'a>,
4378    device: &'a crate::Device,
4379    changed_device: &'a crate::Device,
4380}
4381
4382#[cfg(feature = "v1_16")]
4383#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
4384impl<'a> DeviceChangedBuilder<'a> {
4385    fn new(device: &'a crate::Device, changed_device: &'a crate::Device) -> Self {
4386        skip_assert_initialized!();
4387        Self {
4388            builder: MessageBuilder::new(),
4389            device,
4390            changed_device,
4391        }
4392    }
4393
4394    message_builder_generic_impl!(|s: &mut Self, src| ffi::gst_message_new_device_changed(
4395        src,
4396        s.device.to_glib_none().0,
4397        s.changed_device.to_glib_none().0,
4398    ));
4399}
4400
4401#[cfg(feature = "v1_18")]
4402#[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
4403#[must_use = "The builder must be built to be used"]
4404pub struct InstantRateRequestBuilder<'a> {
4405    builder: MessageBuilder<'a>,
4406    rate_multiplier: f64,
4407}
4408
4409#[cfg(feature = "v1_18")]
4410#[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
4411impl<'a> InstantRateRequestBuilder<'a> {
4412    fn new(rate_multiplier: f64) -> Self {
4413        skip_assert_initialized!();
4414        Self {
4415            builder: MessageBuilder::new(),
4416            rate_multiplier,
4417        }
4418    }
4419
4420    message_builder_generic_impl!(
4421        |s: &mut Self, src| ffi::gst_message_new_instant_rate_request(src, s.rate_multiplier,)
4422    );
4423}
4424
4425#[cfg(test)]
4426mod tests {
4427    use super::*;
4428
4429    #[test]
4430    fn test_simple() {
4431        crate::init().unwrap();
4432
4433        // Message without arguments
4434        let seqnum = Seqnum::next();
4435        let eos_msg = Eos::builder().seqnum(seqnum).build();
4436        match eos_msg.view() {
4437            MessageView::Eos(eos_msg) => {
4438                assert_eq!(eos_msg.seqnum(), seqnum);
4439                assert!(eos_msg.structure().is_none());
4440            }
4441            _ => panic!("eos_msg.view() is not a MessageView::Eos(_)"),
4442        }
4443
4444        // Message with arguments
4445        let buffering_msg = Buffering::new(42);
4446        match buffering_msg.view() {
4447            MessageView::Buffering(buffering_msg) => {
4448                assert_eq!(buffering_msg.percent(), 42);
4449            }
4450            _ => panic!("buffering_msg.view() is not a MessageView::Buffering(_)"),
4451        }
4452    }
4453
4454    #[test]
4455    #[allow(deprecated)]
4456    fn test_other_fields() {
4457        crate::init().unwrap();
4458
4459        let seqnum = Seqnum::next();
4460        let eos_msg = Eos::builder()
4461            .other_field("extra-field", true)
4462            .seqnum(seqnum)
4463            .build();
4464        match eos_msg.view() {
4465            MessageView::Eos(eos_msg) => {
4466                assert_eq!(eos_msg.seqnum(), seqnum);
4467                if let Some(other_fields) = eos_msg.structure() {
4468                    assert!(other_fields.has_field("extra-field"));
4469                }
4470            }
4471            _ => panic!("eos_msg.view() is not a MessageView::Eos(_)"),
4472        }
4473
4474        let buffering_msg = Buffering::builder(42)
4475            .other_field("extra-field", true)
4476            .build();
4477        match buffering_msg.view() {
4478            MessageView::Buffering(buffering_msg) => {
4479                assert_eq!(buffering_msg.percent(), 42);
4480                if let Some(other_fields) = buffering_msg.structure() {
4481                    assert!(other_fields.has_field("extra-field"));
4482                }
4483            }
4484            _ => panic!("buffering_msg.view() is not a MessageView::Buffering(_)"),
4485        }
4486    }
4487
4488    #[test]
4489    fn test_get_seqnum_valid() {
4490        crate::init().unwrap();
4491
4492        let msg = StreamStart::new();
4493        let seqnum = Seqnum(
4494            NonZeroU32::new(unsafe { ffi::gst_message_get_seqnum(msg.as_mut_ptr()) }).unwrap(),
4495        );
4496
4497        match msg.view() {
4498            MessageView::StreamStart(stream_start) => assert_eq!(seqnum, stream_start.seqnum()),
4499            _ => panic!(),
4500        }
4501    }
4502
4503    #[test]
4504    fn test_get_seqnum_invalid() {
4505        crate::init().unwrap();
4506
4507        let msg = StreamStart::new();
4508        let seqnum_init = msg.seqnum();
4509
4510        // Invalid the seqnum
4511        unsafe {
4512            (*msg.as_mut_ptr()).seqnum = ffi::GST_SEQNUM_INVALID as u32;
4513            assert_eq!(0, (*msg.as_ptr()).seqnum);
4514        };
4515
4516        match msg.view() {
4517            MessageView::StreamStart(stream_start) => {
4518                // get_seqnum is expected to return a new Seqnum,
4519                // further in the sequence than the last known seqnum.
4520                assert!(seqnum_init < stream_start.seqnum());
4521            }
4522            _ => panic!(),
4523        }
4524    }
4525}