Struct gstreamer::event::Event

pub struct Event(_);

Methods

impl Event

pub unsafe fn from_glib_none(ptr: *const GstEvent) -> Self

pub unsafe fn from_glib_full(ptr: *const GstEvent) -> Self

pub unsafe fn from_glib_borrow(ptr: *const GstEvent) -> Self

pub unsafe fn into_ptr(self) -> *mut GstEvent

pub fn copy(&self) -> Self

impl Event

pub fn new_flush_start<'a>() -> FlushStartBuilder<'a>

pub fn new_flush_stop<'a>(reset_time: bool) -> FlushStopBuilder<'a>

pub fn new_stream_start(stream_id: &str) -> StreamStartBuilder

pub fn new_caps(caps: &Caps) -> CapsBuilder

pub fn new_segment<F: FormattedValue>(
    segment: &FormattedSegment<F>
) -> SegmentBuilder

pub fn new_tag<'a>(tags: TagList) -> TagBuilder<'a>

pub fn new_buffer_size<'a, V: Into<GenericFormattedValue>>(
    minsize: V,
    maxsize: V,
    async: bool
) -> BufferSizeBuilder<'a>

pub fn new_sink_message<'a>(
    name: &'a str,
    msg: &'a Message
) -> SinkMessageBuilder<'a>

pub fn new_eos<'a>() -> EosBuilder<'a>

pub fn new_toc(toc: &Toc, updated: bool) -> TocBuilder

pub fn new_protection<'a>(
    system_id: &'a str,
    data: &'a Buffer
) -> ProtectionBuilder<'a>

pub fn new_segment_done<'a, V: Into<GenericFormattedValue>>(
    position: V
) -> SegmentDoneBuilder<'a>

pub fn new_gap<'a>(timestamp: ClockTime, duration: ClockTime) -> GapBuilder<'a>

pub fn new_qos<'a>(
    type_: QOSType,
    proportion: f64,
    diff: i64,
    timestamp: ClockTime
) -> QosBuilder<'a>

pub fn new_seek<'a, V: Into<GenericFormattedValue>>(
    rate: f64,
    flags: SeekFlags,
    start_type: SeekType,
    start: V,
    stop_type: SeekType,
    stop: V
) -> SeekBuilder<'a>

pub fn new_navigation<'a>(structure: Structure) -> NavigationBuilder<'a>

pub fn new_latency<'a>(latency: ClockTime) -> LatencyBuilder<'a>

pub fn new_step<'a, V: Into<GenericFormattedValue>>(
    amount: V,
    rate: f64,
    flush: bool,
    intermediate: bool
) -> StepBuilder<'a>

pub fn new_reconfigure<'a>() -> ReconfigureBuilder<'a>

pub fn new_toc_select(uid: &str) -> TocSelectBuilder

pub fn new_custom_upstream<'a>(
    structure: Structure
) -> CustomUpstreamBuilder<'a>

pub fn new_custom_downstream<'a>(
    structure: Structure
) -> CustomDownstreamBuilder<'a>

pub fn new_custom_downstream_oob<'a>(
    structure: Structure
) -> CustomDownstreamOobBuilder<'a>

pub fn new_custom_downstream_sticky<'a>(
    structure: Structure
) -> CustomDownstreamStickyBuilder<'a>

pub fn new_custom_both<'a>(structure: Structure) -> CustomBothBuilder<'a>

pub fn new_custom_both_oob<'a>(structure: Structure) -> CustomBothOobBuilder<'a>

Methods from Deref<Target = GstRc<EventRef>>

pub fn make_mut(&mut self) -> &mut T

pub fn get_mut(&mut self) -> Option<&mut T>

pub fn is_writable(&self) -> bool

Trait Implementations

impl AsRef<EventRef> for Event

fn as_ref(&self) -> &EventRef

Performs the conversion.

impl Clone for Event

fn clone(&self) -> Event

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl From<GstRc<EventRef>> for Event

fn from(rc: GstRc<EventRef>) -> Event

Performs the conversion.

impl Into<GstRc<EventRef>> for Event

fn into(self) -> GstRc<EventRef>

Performs the conversion.

impl DerefMut for Event

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl Deref for Event

type Target = GstRc<EventRef>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl Debug for Event

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Borrow<EventRef> for Event

fn borrow(&self) -> &EventRef

Immutably borrows from an owned value.

impl FromGlibPtrFull<*const GstEvent> for Event

unsafe fn from_glib_full(ptr: *const GstEvent) -> Self

impl FromGlibPtrFull<*mut GstEvent> for Event

unsafe fn from_glib_full(ptr: *mut GstEvent) -> Self

impl<'a> ToGlibPtr<'a, *const GstEvent> for Event

type Storage = Stash<'a, *const GstEvent, GstRc<EventRef>>

fn to_glib_none(&'a self) -> Stash<'a, *const GstEvent, Self>

Transfer: none.

fn to_glib_full(&self) -> *const GstEvent

Transfer: full.

fn to_glib_container(&'a self) -> Stash<'a, P, Self>

Transfer: container.

impl<'a> ToGlibPtr<'a, *mut GstEvent> for Event

type Storage = Stash<'a, *mut GstEvent, GstRc<EventRef>>

fn to_glib_none(&'a self) -> Stash<'a, *mut GstEvent, Self>

Transfer: none.

fn to_glib_full(&self) -> *mut GstEvent

Transfer: full.

fn to_glib_container(&'a self) -> Stash<'a, P, Self>

Transfer: container.

impl FromGlibContainerAsVec<*mut GstEvent, *mut *mut GstEvent> for Event

unsafe fn from_glib_none_num_as_vec(
    ptr: *mut *mut GstEvent,
    num: usize
) -> Vec<Self>

unsafe fn from_glib_container_num_as_vec(
    ptr: *mut *mut GstEvent,
    num: usize
) -> Vec<Self>

unsafe fn from_glib_full_num_as_vec(
    ptr: *mut *mut GstEvent,
    num: usize
) -> Vec<Self>

impl FromGlibContainerAsVec<*mut GstEvent, *const *mut GstEvent> for Event

unsafe fn from_glib_none_num_as_vec(
    ptr: *const *mut GstEvent,
    num: usize
) -> Vec<Self>

unsafe fn from_glib_container_num_as_vec(
    _: *const *mut GstEvent,
    _: usize
) -> Vec<Self>

unsafe fn from_glib_full_num_as_vec(
    _: *const *mut GstEvent,
    _: usize
) -> Vec<Self>

impl<'a> ToGlibPtrMut<'a, *mut GstEvent> for Event

type Storage = StashMut<'a, *mut GstEvent, GstRc<EventRef>>

fn to_glib_none_mut(&'a mut self) -> StashMut<*mut GstEvent, Self>

Transfer: none.

impl GlibPtrDefault for Event

type GlibType = *mut GstEvent

impl FromGlibPtrNone<*const GstEvent> for Event

unsafe fn from_glib_none(ptr: *const GstEvent) -> Self

impl FromGlibPtrNone<*mut GstEvent> for Event

unsafe fn from_glib_none(ptr: *mut GstEvent) -> Self

impl FromGlibPtrArrayContainerAsVec<*mut GstEvent, *mut *mut GstEvent> for Event

unsafe fn from_glib_none_as_vec(ptr: *mut *mut GstEvent) -> Vec<Self>

unsafe fn from_glib_container_as_vec(ptr: *mut *mut GstEvent) -> Vec<Self>

unsafe fn from_glib_full_as_vec(ptr: *mut *mut GstEvent) -> Vec<Self>

impl FromGlibPtrArrayContainerAsVec<*mut GstEvent, *const *mut GstEvent> for Event

unsafe fn from_glib_none_as_vec(ptr: *const *mut GstEvent) -> Vec<Self>

unsafe fn from_glib_container_as_vec(_: *const *mut GstEvent) -> Vec<Self>

unsafe fn from_glib_full_as_vec(_: *const *mut GstEvent) -> Vec<Self>

impl FromGlibPtrBorrow<*const GstEvent> for Event

unsafe fn from_glib_borrow(ptr: *const GstEvent) -> Self

impl FromGlibPtrBorrow<*mut GstEvent> for Event

unsafe fn from_glib_borrow(ptr: *mut GstEvent) -> Self

impl<'a> ToGlibContainerFromSlice<'a, *mut *mut GstEvent> for Event

type Storage = (Vec<Stash<'a, *mut GstEvent, Event>>, Option<Vec<*mut GstEvent>>)

fn to_glib_none_from_slice(
    t: &'a [Event]
) -> (*mut *mut GstEvent, Self::Storage)

fn to_glib_container_from_slice(
    t: &'a [Event]
) -> (*mut *mut GstEvent, Self::Storage)

fn to_glib_full_from_slice(t: &[Event]) -> *mut *mut GstEvent

impl<'a> ToGlibContainerFromSlice<'a, *const *mut GstEvent> for Event

type Storage = (Vec<Stash<'a, *mut GstEvent, Event>>, Option<Vec<*mut GstEvent>>)

fn to_glib_none_from_slice(
    t: &'a [Event]
) -> (*const *mut GstEvent, Self::Storage)

fn to_glib_container_from_slice(
    _: &'a [Event]
) -> (*const *mut GstEvent, Self::Storage)

fn to_glib_full_from_slice(_: &[Event]) -> *const *mut GstEvent

impl StaticType for Event

fn static_type() -> Type

Returns the type identifier of Self.

impl<'a> FromValueOptional<'a> for Event

unsafe fn from_value_optional(v: &'a Value) -> Option<Self>

impl SetValue for Event

unsafe fn set_value(v: &mut Value, s: &Self)

impl SetValueOptional for Event

unsafe fn set_value_optional(v: &mut Value, s: Option<&Self>)