[−][src]Struct gstreamer_check::TestClock
GstTestClock is an implementation of gst::Clock
which has different
behaviour compared to gst::SystemClock
. Time for gst::SystemClock
advances
according to the system time, while time for TestClock
changes only
when TestClock::set_time
or TestClock::advance_time
are
called. TestClock
provides unit tests with the possibility to
precisely advance the time in a deterministic manner, independent of the
system time or any other external factors.
Advancing the time of a TestClock
#include <gst/gst.h>
#include <gst/check/gsttestclock.h>
GstClock *clock;
GstTestClock *test_clock;
clock = gst_test_clock_new ();
test_clock = GST_TEST_CLOCK (clock);
GST_INFO ("Time: %" GST_TIME_FORMAT, GST_TIME_ARGS (gst_clock_get_time (clock)));
gst_test_clock_advance_time ( test_clock, 1 * GST_SECOND);
GST_INFO ("Time: %" GST_TIME_FORMAT, GST_TIME_ARGS (gst_clock_get_time (clock)));
g_usleep (10 * G_USEC_PER_SEC);
GST_INFO ("Time: %" GST_TIME_FORMAT, GST_TIME_ARGS (gst_clock_get_time (clock)));
gst_test_clock_set_time (test_clock, 42 * GST_SECOND);
GST_INFO ("Time: %" GST_TIME_FORMAT, GST_TIME_ARGS (gst_clock_get_time (clock)));
...
gst::Clock
allows for setting up single shot or periodic clock notifications
as well as waiting for these notifications synchronously (using
gst::Clock::id_wait
) or asynchronously (using gst::Clock::id_wait_async
or
gst::Clock::id_wait_async
). This is used by many GStreamer elements,
among them GstBaseSrc
and GstBaseSink
.
TestClock
keeps track of these clock notifications. By calling
TestClock::wait_for_next_pending_id
or
TestClock::wait_for_multiple_pending_ids
a unit tests may wait for the
next one or several clock notifications to be requested. Additionally unit
tests may release blocked waits in a controlled fashion by calling
TestClock::process_next_clock_id
. This way a unit test can control the
inaccuracy (jitter) of clock notifications, since the test can decide to
release blocked waits when the clock time has advanced exactly to, or past,
the requested clock notification time.
There are also interfaces for determining if a notification belongs to a
TestClock
or not, as well as getting the number of requested clock
notifications so far.
N.B.: When a unit test waits for a certain amount of clock notifications to
be requested in TestClock::wait_for_next_pending_id
or
TestClock::wait_for_multiple_pending_ids
then these functions may block
for a long time. If they block forever then the expected clock notifications
were never requested from TestClock
, and so the assumptions in the code
of the unit test are wrong. The unit test case runner in gstcheck is
expected to catch these cases either by the default test case timeout or the
one set for the unit test by calling tcase_set_timeout().
The sample code below assumes that the element under test will delay a
buffer pushed on the source pad by some latency until it arrives on the sink
pad. Moreover it is assumed that the element will at some point call
gst::Clock::id_wait
to synchronously wait for a specific time. The first
buffer sent will arrive exactly on time only delayed by the latency. The
second buffer will arrive a little late (7ms) due to simulated jitter in the
clock notification.
Demonstration of how to work with clock notifications and TestClock
#include <gst/gst.h>
#include <gst/check/gstcheck.h>
#include <gst/check/gsttestclock.h>
GstClockTime latency;
GstElement *element;
GstPad *srcpad;
GstClock *clock;
GstTestClock *test_clock;
GstBuffer buf;
GstClockID pending_id;
GstClockID processed_id;
latency = 42 * GST_MSECOND;
element = create_element (latency, ...);
srcpad = get_source_pad (element);
clock = gst_test_clock_new ();
test_clock = GST_TEST_CLOCK (clock);
gst_element_set_clock (element, clock);
GST_INFO ("Set time, create and push the first buffer\n");
gst_test_clock_set_time (test_clock, 0);
buf = create_test_buffer (gst_clock_get_time (clock), ...);
gst_assert_cmpint (gst_pad_push (srcpad, buf), ==, GST_FLOW_OK);
GST_INFO ("Block until element is waiting for a clock notification\n");
gst_test_clock_wait_for_next_pending_id (test_clock, &pending_id);
GST_INFO ("Advance to the requested time of the clock notification\n");
gst_test_clock_advance_time (test_clock, latency);
GST_INFO ("Release the next blocking wait and make sure it is the one from element\n");
processed_id = gst_test_clock_process_next_clock_id (test_clock);
g_assert (processed_id == pending_id);
g_assert_cmpint (GST_CLOCK_ENTRY_STATUS (processed_id), ==, GST_CLOCK_OK);
gst_clock_id_unref (pending_id);
gst_clock_id_unref (processed_id);
GST_INFO ("Validate that element produced an output buffer and check its timestamp\n");
g_assert_cmpint (get_number_of_output_buffer (...), ==, 1);
buf = get_buffer_pushed_by_element (element, ...);
g_assert_cmpint (GST_BUFFER_TIMESTAMP (buf), ==, latency);
gst_buffer_unref (buf);
GST_INFO ("Check that element does not wait for any clock notification\n");
g_assert (!gst_test_clock_peek_next_pending_id (test_clock, NULL));
GST_INFO ("Set time, create and push the second buffer\n");
gst_test_clock_advance_time (test_clock, 10 * GST_SECOND);
buf = create_test_buffer (gst_clock_get_time (clock), ...);
gst_assert_cmpint (gst_pad_push (srcpad, buf), ==, GST_FLOW_OK);
GST_INFO ("Block until element is waiting for a new clock notification\n");
(gst_test_clock_wait_for_next_pending_id (test_clock, &pending_id);
GST_INFO ("Advance past 7ms beyond the requested time of the clock notification\n");
gst_test_clock_advance_time (test_clock, latency + 7 * GST_MSECOND);
GST_INFO ("Release the next blocking wait and make sure it is the one from element\n");
processed_id = gst_test_clock_process_next_clock_id (test_clock);
g_assert (processed_id == pending_id);
g_assert_cmpint (GST_CLOCK_ENTRY_STATUS (processed_id), ==, GST_CLOCK_OK);
gst_clock_id_unref (pending_id);
gst_clock_id_unref (processed_id);
GST_INFO ("Validate that element produced an output buffer and check its timestamp\n");
g_assert_cmpint (get_number_of_output_buffer (...), ==, 1);
buf = get_buffer_pushed_by_element (element, ...);
g_assert_cmpint (GST_BUFFER_TIMESTAMP (buf), ==,
10 * GST_SECOND + latency + 7 * GST_MSECOND);
gst_buffer_unref (buf);
GST_INFO ("Check that element does not wait for any clock notification\n");
g_assert (!gst_test_clock_peek_next_pending_id (test_clock, NULL));
...
Since TestClock
is only supposed to be used in unit tests it calls
g_assert
, g_assert_cmpint
or g_assert_cmpuint
to validate all function
arguments. This will highlight any issues with the unit test code itself.
Implements
Implementations
impl TestClock
[src]
pub fn new() -> TestClock
[src]
Creates a new test clock with its time set to zero.
MT safe.
Returns
a TestClock
cast to gst::Clock
.
pub fn with_start_time(start_time: ClockTime) -> TestClock
[src]
pub fn advance_time(&self, delta: ClockTimeDiff)
[src]
Advances the time of the self
by the amount given by delta
. The
time of self
is monotonically increasing, therefore providing a
delta
which is negative or zero is a programming error.
MT safe.
delta
a positive gst::ClockTimeDiff
to be added to the time of the clock
pub fn crank(&self) -> bool
[src]
A "crank" consists of three steps:
1: Wait for a gst::ClockID
to be registered with the TestClock
.
2: Advance the TestClock
to the time the gst::ClockID
is waiting, unless
the clock time is already passed the clock id (Since: 1.18).
3: Release the gst::ClockID
wait.
A "crank" can be though of as the notion of
manually driving the clock forward to its next logical step.
Returns
true
if the crank was successful, false
otherwise.
MT safe.
pub fn get_next_entry_time(&self) -> ClockTime
[src]
Retrieve the requested time for the next pending clock notification.
MT safe.
Returns
a gst::ClockTime
set to the time of the next pending clock
notification. If no clock notifications have been requested
GST_CLOCK_TIME_NONE
will be returned.
pub fn peek_id_count(&self) -> u32
[src]
Determine the number of pending clock notifications that have been
requested from the self
.
MT safe.
Returns
the number of pending clock notifications.
pub fn set_time(&self, new_time: ClockTime)
[src]
Sets the time of self
to the time given by new_time
. The time of
self
is monotonically increasing, therefore providing a new_time
which is earlier or equal to the time of the clock as given by
gst::ClockExt::get_time
is a programming error.
MT safe.
new_time
a gst::ClockTime
later than that returned by gst::ClockExt::get_time
pub fn wait_for_pending_id_count(&self, count: u32)
[src]
Blocks until at least count
clock notifications have been requested from
self
. There is no timeout for this wait, see the main description of
TestClock
.
Deprecated
use TestClock::wait_for_multiple_pending_ids
instead.
count
the number of pending clock notifications to wait for
pub fn get_property_clock_type(&self) -> ClockType
[src]
pub fn set_property_clock_type(&self, clock_type: ClockType)
[src]
pub fn get_property_start_time(&self) -> u64
[src]
When a TestClock
is constructed it will have a certain start time set.
If the clock was created using TestClock::new_with_start_time
then
this property contains the value of the start_time
argument. If
TestClock::new
was called the clock started at time zero, and thus
this property contains the value 0.
pub fn connect_property_clock_type_notify<F: Fn(&TestClock) + Send + Sync + 'static>(
&self,
f: F
) -> SignalHandlerId
[src]
&self,
f: F
) -> SignalHandlerId
impl TestClock
[src]
pub fn has_id(&self, id: &ClockId) -> bool
[src]
Checks whether self
was requested to provide the clock notification
given by id
.
MT safe.
id
a gst::ClockID
clock notification
Returns
true
if the clock has been asked to provide the given clock
notification, false
otherwise.
pub fn peek_next_pending_id(&self) -> Option<ClockId>
[src]
Determines if the pending_id
is the next clock notification scheduled to
be triggered given the current time of the self
.
MT safe.
pending_id
a gst::ClockID
clock
notification to look for
Returns
true
if pending_id
is the next clock notification to be
triggered, false
otherwise.
pub fn process_id(&self, pending_id: &ClockId) -> bool
[src]
pub fn process_id_list(&self, pending_list: &[&ClockId]) -> u32
[src]
Processes and releases the pending IDs in the list.
MT safe.
pending_list
List
of pending GstClockIDs
pub fn process_next_clock_id(&self) -> Option<ClockId>
[src]
pub fn wait_for_multiple_pending_ids(&self, count: u32) -> Vec<ClockId>
[src]
Blocks until at least count
clock notifications have been requested from
self
. There is no timeout for this wait, see the main description of
TestClock
.
MT safe.
count
the number of pending clock notifications to wait for
pending_list
Address
of a glib::List
pointer variable to store the list of pending GstClockIDs
that expired, or None
pub fn wait_for_next_pending_id(&self) -> ClockId
[src]
Waits until a clock notification is requested from self
. There is no
timeout for this wait, see the main description of TestClock
. A reference
to the pending clock notification is stored in pending_id
.
MT safe.
pending_id
gst::ClockID
with information about the pending clock notification
pub fn timed_wait_for_multiple_pending_ids(
&self,
count: u32,
timeout_ms: u32
) -> (bool, Vec<ClockId>)
[src]
&self,
count: u32,
timeout_ms: u32
) -> (bool, Vec<ClockId>)
Blocks until at least count
clock notifications have been requested from
self
, or the timeout expires.
MT safe.
Feature: v1_16
count
the number of pending clock notifications to wait for
timeout_ms
the timeout in milliseconds
pending_list
Address
of a glib::List
pointer variable to store the list of pending GstClockIDs
that expired, or None
Returns
a gboolean
true
if the waits have been registered, false
if not.
(Could be that it timed out waiting or that more waits than waits was found)
Trait Implementations
impl Clone for TestClock
[src]
impl Debug for TestClock
[src]
impl Default for TestClock
[src]
impl Eq for TestClock
[src]
impl Hash for TestClock
[src]
fn hash<__H: Hasher>(&self, state: &mut __H)
[src]
fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl IsA<Clock> for TestClock
[src]
impl IsA<Object> for TestClock
[src]
impl Ord for TestClock
[src]
fn cmp(&self, other: &TestClock) -> Ordering
[src]
#[must_use]fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<T: ObjectType> PartialEq<T> for TestClock
[src]
impl<T: ObjectType> PartialOrd<T> for TestClock
[src]
fn partial_cmp(&self, other: &T) -> Option<Ordering>
[src]
#[must_use]fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
impl Send for TestClock
[src]
impl StaticType for TestClock
[src]
fn static_type() -> Type
[src]
impl Sync for TestClock
[src]
Auto Trait Implementations
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<Super, Sub> CanDowncast<Sub> for Super where
Sub: IsA<Super>,
Super: IsA<Super>,
[src]
Sub: IsA<Super>,
Super: IsA<Super>,
impl<T> Cast for T where
T: ObjectType,
[src]
T: ObjectType,
fn upcast<T>(self) -> T where
Self: IsA<T>,
T: ObjectType,
[src]
Self: IsA<T>,
T: ObjectType,
fn upcast_ref<T>(&self) -> &T where
Self: IsA<T>,
T: ObjectType,
[src]
Self: IsA<T>,
T: ObjectType,
fn downcast<T>(self) -> Result<T, Self> where
Self: CanDowncast<T>,
T: ObjectType,
[src]
Self: CanDowncast<T>,
T: ObjectType,
fn downcast_ref<T>(&self) -> Option<&T> where
Self: CanDowncast<T>,
T: ObjectType,
[src]
Self: CanDowncast<T>,
T: ObjectType,
fn dynamic_cast<T>(self) -> Result<T, Self> where
T: ObjectType,
[src]
T: ObjectType,
fn dynamic_cast_ref<T>(&self) -> Option<&T> where
T: ObjectType,
[src]
T: ObjectType,
unsafe fn unsafe_cast<T>(self) -> T where
T: ObjectType,
[src]
T: ObjectType,
unsafe fn unsafe_cast_ref<T>(&self) -> &T where
T: ObjectType,
[src]
T: ObjectType,
impl<O> ClockExt for O where
O: IsA<Clock>,
[src]
O: IsA<Clock>,
fn add_observation(&self, slave: ClockTime, master: ClockTime) -> Option<f64>
[src]
fn add_observation_unapplied(
&self,
slave: ClockTime,
master: ClockTime
) -> Option<(f64, ClockTime, ClockTime, ClockTime, ClockTime)>
[src]
&self,
slave: ClockTime,
master: ClockTime
) -> Option<(f64, ClockTime, ClockTime, ClockTime, ClockTime)>
fn adjust_unlocked(&self, internal: ClockTime) -> ClockTime
[src]
fn get_calibration(&self) -> (ClockTime, ClockTime, ClockTime, ClockTime)
[src]
fn get_internal_time(&self) -> ClockTime
[src]
fn get_master(&self) -> Option<Clock>
[src]
fn get_resolution(&self) -> ClockTime
[src]
fn get_time(&self) -> ClockTime
[src]
fn get_timeout(&self) -> ClockTime
[src]
fn is_synced(&self) -> bool
[src]
fn set_calibration(
&self,
internal: ClockTime,
external: ClockTime,
rate_num: ClockTime,
rate_denom: ClockTime
)
[src]
&self,
internal: ClockTime,
external: ClockTime,
rate_num: ClockTime,
rate_denom: ClockTime
)
fn set_master<P>(&self, master: Option<&P>) -> Result<(), BoolError> where
P: IsA<Clock>,
[src]
P: IsA<Clock>,
fn set_resolution(&self, resolution: ClockTime) -> ClockTime
[src]
fn set_synced(&self, synced: bool)
[src]
fn set_timeout(&self, timeout: ClockTime)
[src]
fn unadjust_unlocked(&self, external: ClockTime) -> ClockTime
[src]
fn wait_for_sync(&self, timeout: ClockTime) -> Result<(), BoolError>
[src]
fn get_property_window_size(&self) -> i32
[src]
fn set_property_window_size(&self, window_size: i32)
[src]
fn get_property_window_threshold(&self) -> i32
[src]
fn set_property_window_threshold(&self, window_threshold: i32)
[src]
fn connect_synced<F>(&self, f: F) -> SignalHandlerId where
F: 'static + Send + Sync + Fn(&O, bool),
[src]
F: 'static + Send + Sync + Fn(&O, bool),
fn connect_property_timeout_notify<F>(&self, f: F) -> SignalHandlerId where
F: 'static + Send + Sync + Fn(&O),
[src]
F: 'static + Send + Sync + Fn(&O),
fn connect_property_window_size_notify<F>(&self, f: F) -> SignalHandlerId where
F: 'static + Send + Sync + Fn(&O),
[src]
F: 'static + Send + Sync + Fn(&O),
fn connect_property_window_threshold_notify<F>(&self, f: F) -> SignalHandlerId where
F: 'static + Send + Sync + Fn(&O),
[src]
F: 'static + Send + Sync + Fn(&O),
impl<O> ClockExtManual for O where
O: IsA<Clock>,
[src]
O: IsA<Clock>,
fn new_periodic_id(
&self,
start_time: ClockTime,
interval: ClockTime
) -> Result<ClockId, BoolError>
[src]
&self,
start_time: ClockTime,
interval: ClockTime
) -> Result<ClockId, BoolError>
fn periodic_id_reinit(
&self,
id: &ClockId,
start_time: ClockTime,
interval: ClockTime
) -> Result<(), BoolError>
[src]
&self,
id: &ClockId,
start_time: ClockTime,
interval: ClockTime
) -> Result<(), BoolError>
fn new_single_shot_id(&self, time: ClockTime) -> Result<ClockId, BoolError>
[src]
fn single_shot_id_reinit(
&self,
id: &ClockId,
time: ClockTime
) -> Result<(), BoolError>
[src]
&self,
id: &ClockId,
time: ClockTime
) -> Result<(), BoolError>
fn set_clock_flags(&self, flags: ClockFlags)
[src]
fn unset_clock_flags(&self, flags: ClockFlags)
[src]
fn get_clock_flags(&self) -> ClockFlags
[src]
impl<T> From<T> for T
[src]
impl<O> GObjectExtManualGst for O where
O: IsA<Object>,
[src]
O: IsA<Object>,
fn set_property_from_str(&self, name: &str, value: &str)
[src]
impl<O> GstObjectExt for O where
O: IsA<Object>,
[src]
O: IsA<Object>,
fn default_error(&self, error: &Error, debug: Option<&str>)
[src]
fn get_control_rate(&self) -> ClockTime
[src]
fn get_name(&self) -> GString
[src]
fn get_parent(&self) -> Option<Object>
[src]
fn get_path_string(&self) -> GString
[src]
fn has_active_control_bindings(&self) -> bool
[src]
fn has_ancestor<P>(&self, ancestor: &P) -> bool where
P: IsA<Object>,
[src]
P: IsA<Object>,
fn has_as_ancestor<P>(&self, ancestor: &P) -> bool where
P: IsA<Object>,
[src]
P: IsA<Object>,
fn has_as_parent<P>(&self, parent: &P) -> bool where
P: IsA<Object>,
[src]
P: IsA<Object>,
fn set_control_binding_disabled(&self, property_name: &str, disabled: bool)
[src]
fn set_control_bindings_disabled(&self, disabled: bool)
[src]
fn set_control_rate(&self, control_rate: ClockTime)
[src]
fn set_parent<P>(&self, parent: &P) -> Result<(), BoolError> where
P: IsA<Object>,
[src]
P: IsA<Object>,
fn suggest_next_sync(&self) -> ClockTime
[src]
fn sync_values(&self, timestamp: ClockTime) -> Result<(), BoolError>
[src]
fn unparent(&self)
[src]
fn connect_property_parent_notify<F>(&self, f: F) -> SignalHandlerId where
F: 'static + Send + Sync + Fn(&O),
[src]
F: 'static + Send + Sync + Fn(&O),
impl<O> GstObjectExtManual for O where
O: IsA<Object>,
[src]
O: IsA<Object>,
fn connect_deep_notify<F>(&self, name: Option<&str>, f: F) -> SignalHandlerId where
F: 'static + Send + Sync + Fn(&O, &Object, &ParamSpec),
[src]
F: 'static + Send + Sync + Fn(&O, &Object, &ParamSpec),
fn set_object_flags(&self, flags: ObjectFlags)
[src]
fn unset_object_flags(&self, flags: ObjectFlags)
[src]
fn get_object_flags(&self) -> ObjectFlags
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> ObjectExt for T where
T: ObjectType,
[src]
T: ObjectType,
fn is<U>(&self) -> bool where
U: StaticType,
[src]
U: StaticType,
fn get_type(&self) -> Type
[src]
fn get_object_class(&self) -> &ObjectClass
[src]
fn set_properties(
&self,
property_values: &[(&str, &dyn ToValue)]
) -> Result<(), BoolError>
[src]
&self,
property_values: &[(&str, &dyn ToValue)]
) -> Result<(), BoolError>
fn set_property<'a, N>(
&self,
property_name: N,
value: &dyn ToValue
) -> Result<(), BoolError> where
N: Into<&'a str>,
[src]
&self,
property_name: N,
value: &dyn ToValue
) -> Result<(), BoolError> where
N: Into<&'a str>,
fn get_property<'a, N>(&self, property_name: N) -> Result<Value, BoolError> where
N: Into<&'a str>,
[src]
N: Into<&'a str>,
unsafe fn set_qdata<QD>(&self, key: Quark, value: QD) where
QD: 'static,
[src]
QD: 'static,
unsafe fn get_qdata<QD>(&self, key: Quark) -> Option<&QD> where
QD: 'static,
[src]
QD: 'static,
unsafe fn steal_qdata<QD>(&self, key: Quark) -> Option<QD> where
QD: 'static,
[src]
QD: 'static,
unsafe fn set_data<QD>(&self, key: &str, value: QD) where
QD: 'static,
[src]
QD: 'static,
unsafe fn get_data<QD>(&self, key: &str) -> Option<&QD> where
QD: 'static,
[src]
QD: 'static,
unsafe fn steal_data<QD>(&self, key: &str) -> Option<QD> where
QD: 'static,
[src]
QD: 'static,
fn block_signal(&self, handler_id: &SignalHandlerId)
[src]
fn unblock_signal(&self, handler_id: &SignalHandlerId)
[src]
fn stop_signal_emission(&self, signal_name: &str)
[src]
fn disconnect(&self, handler_id: SignalHandlerId)
[src]
fn connect_notify<F>(&self, name: Option<&str>, f: F) -> SignalHandlerId where
F: 'static + Send + Sync + Fn(&T, &ParamSpec),
[src]
F: 'static + Send + Sync + Fn(&T, &ParamSpec),
unsafe fn connect_notify_unsafe<F>(
&self,
name: Option<&str>,
f: F
) -> SignalHandlerId where
F: Fn(&T, &ParamSpec),
[src]
&self,
name: Option<&str>,
f: F
) -> SignalHandlerId where
F: Fn(&T, &ParamSpec),
fn notify<'a, N>(&self, property_name: N) where
N: Into<&'a str>,
[src]
N: Into<&'a str>,
fn notify_by_pspec(&self, pspec: &ParamSpec)
[src]
fn has_property<'a, N>(&self, property_name: N, type_: Option<Type>) -> bool where
N: Into<&'a str>,
[src]
N: Into<&'a str>,
fn get_property_type<'a, N>(&self, property_name: N) -> Option<Type> where
N: Into<&'a str>,
[src]
N: Into<&'a str>,
fn find_property<'a, N>(&self, property_name: N) -> Option<ParamSpec> where
N: Into<&'a str>,
[src]
N: Into<&'a str>,
fn list_properties(&self) -> Vec<ParamSpec>
[src]
fn connect<'a, N, F>(
&self,
signal_name: N,
after: bool,
callback: F
) -> Result<SignalHandlerId, BoolError> where
F: Fn(&[Value]) -> Option<Value> + Send + Sync + 'static,
N: Into<&'a str>,
[src]
&self,
signal_name: N,
after: bool,
callback: F
) -> Result<SignalHandlerId, BoolError> where
F: Fn(&[Value]) -> Option<Value> + Send + Sync + 'static,
N: Into<&'a str>,
fn connect_local<'a, N, F>(
&self,
signal_name: N,
after: bool,
callback: F
) -> Result<SignalHandlerId, BoolError> where
F: Fn(&[Value]) -> Option<Value> + 'static,
N: Into<&'a str>,
[src]
&self,
signal_name: N,
after: bool,
callback: F
) -> Result<SignalHandlerId, BoolError> where
F: Fn(&[Value]) -> Option<Value> + 'static,
N: Into<&'a str>,
unsafe fn connect_unsafe<'a, N, F>(
&self,
signal_name: N,
after: bool,
callback: F
) -> Result<SignalHandlerId, BoolError> where
F: Fn(&[Value]) -> Option<Value>,
N: Into<&'a str>,
[src]
&self,
signal_name: N,
after: bool,
callback: F
) -> Result<SignalHandlerId, BoolError> where
F: Fn(&[Value]) -> Option<Value>,
N: Into<&'a str>,
fn emit<'a, N>(
&self,
signal_name: N,
args: &[&dyn ToValue]
) -> Result<Option<Value>, BoolError> where
N: Into<&'a str>,
[src]
&self,
signal_name: N,
args: &[&dyn ToValue]
) -> Result<Option<Value>, BoolError> where
N: Into<&'a str>,
fn downgrade(&self) -> WeakRef<T>
[src]
fn bind_property<'a, O, N, M>(
&'a self,
source_property: N,
target: &'a O,
target_property: M
) -> BindingBuilder<'a> where
M: Into<&'a str>,
N: Into<&'a str>,
O: ObjectType,
[src]
&'a self,
source_property: N,
target: &'a O,
target_property: M
) -> BindingBuilder<'a> where
M: Into<&'a str>,
N: Into<&'a str>,
O: ObjectType,
fn ref_count(&self) -> u32
[src]
impl<'a, T> ToGlibContainerFromSlice<'a, *const GList> for T where
T: GlibPtrDefault + ToGlibPtr<'a, <T as GlibPtrDefault>::GlibType>,
[src]
T: GlibPtrDefault + ToGlibPtr<'a, <T as GlibPtrDefault>::GlibType>,
type Storage = (Option<List>, Vec<Stash<'a, <T as GlibPtrDefault>::GlibType, T>>)
fn to_glib_none_from_slice(
t: &'a [T]
) -> (*const GList, <T as ToGlibContainerFromSlice<'a, *const GList>>::Storage)
[src]
t: &'a [T]
) -> (*const GList, <T as ToGlibContainerFromSlice<'a, *const GList>>::Storage)
fn to_glib_container_from_slice(
_t: &'a [T]
) -> (*const GList, <T as ToGlibContainerFromSlice<'a, *const GList>>::Storage)
[src]
_t: &'a [T]
) -> (*const GList, <T as ToGlibContainerFromSlice<'a, *const GList>>::Storage)
fn to_glib_full_from_slice(_t: &[T]) -> *const GList
[src]
impl<'a, T> ToGlibContainerFromSlice<'a, *const GPtrArray> for T where
T: GlibPtrDefault + ToGlibPtr<'a, <T as GlibPtrDefault>::GlibType>,
[src]
T: GlibPtrDefault + ToGlibPtr<'a, <T as GlibPtrDefault>::GlibType>,
type Storage = (Option<PtrArray>, Vec<Stash<'a, <T as GlibPtrDefault>::GlibType, T>>)
fn to_glib_none_from_slice(
t: &'a [T]
) -> (*const GPtrArray, <T as ToGlibContainerFromSlice<'a, *const GPtrArray>>::Storage)
[src]
t: &'a [T]
) -> (*const GPtrArray, <T as ToGlibContainerFromSlice<'a, *const GPtrArray>>::Storage)
fn to_glib_container_from_slice(
_t: &'a [T]
) -> (*const GPtrArray, <T as ToGlibContainerFromSlice<'a, *const GPtrArray>>::Storage)
[src]
_t: &'a [T]
) -> (*const GPtrArray, <T as ToGlibContainerFromSlice<'a, *const GPtrArray>>::Storage)
fn to_glib_full_from_slice(_t: &[T]) -> *const GPtrArray
[src]
impl<'a, T> ToGlibContainerFromSlice<'a, *mut GArray> for T where
T: GlibPtrDefault + ToGlibPtr<'a, <T as GlibPtrDefault>::GlibType>,
[src]
T: GlibPtrDefault + ToGlibPtr<'a, <T as GlibPtrDefault>::GlibType>,
type Storage = (Option<Array>, Vec<Stash<'a, <T as GlibPtrDefault>::GlibType, T>>)
fn to_glib_none_from_slice(
t: &'a [T]
) -> (*mut GArray, <T as ToGlibContainerFromSlice<'a, *mut GArray>>::Storage)
[src]
t: &'a [T]
) -> (*mut GArray, <T as ToGlibContainerFromSlice<'a, *mut GArray>>::Storage)
fn to_glib_container_from_slice(
t: &'a [T]
) -> (*mut GArray, <T as ToGlibContainerFromSlice<'a, *mut GArray>>::Storage)
[src]
t: &'a [T]
) -> (*mut GArray, <T as ToGlibContainerFromSlice<'a, *mut GArray>>::Storage)
fn to_glib_full_from_slice(t: &[T]) -> *mut GArray
[src]
impl<'a, T> ToGlibContainerFromSlice<'a, *mut GList> for T where
T: GlibPtrDefault + ToGlibPtr<'a, <T as GlibPtrDefault>::GlibType>,
[src]
T: GlibPtrDefault + ToGlibPtr<'a, <T as GlibPtrDefault>::GlibType>,
type Storage = (Option<List>, Vec<Stash<'a, <T as GlibPtrDefault>::GlibType, T>>)
fn to_glib_none_from_slice(
t: &'a [T]
) -> (*mut GList, <T as ToGlibContainerFromSlice<'a, *mut GList>>::Storage)
[src]
t: &'a [T]
) -> (*mut GList, <T as ToGlibContainerFromSlice<'a, *mut GList>>::Storage)
fn to_glib_container_from_slice(
t: &'a [T]
) -> (*mut GList, <T as ToGlibContainerFromSlice<'a, *mut GList>>::Storage)
[src]
t: &'a [T]
) -> (*mut GList, <T as ToGlibContainerFromSlice<'a, *mut GList>>::Storage)
fn to_glib_full_from_slice(t: &[T]) -> *mut GList
[src]
impl<'a, T> ToGlibContainerFromSlice<'a, *mut GPtrArray> for T where
T: GlibPtrDefault + ToGlibPtr<'a, <T as GlibPtrDefault>::GlibType>,
[src]
T: GlibPtrDefault + ToGlibPtr<'a, <T as GlibPtrDefault>::GlibType>,
type Storage = (Option<PtrArray>, Vec<Stash<'a, <T as GlibPtrDefault>::GlibType, T>>)
fn to_glib_none_from_slice(
t: &'a [T]
) -> (*mut GPtrArray, <T as ToGlibContainerFromSlice<'a, *mut GPtrArray>>::Storage)
[src]
t: &'a [T]
) -> (*mut GPtrArray, <T as ToGlibContainerFromSlice<'a, *mut GPtrArray>>::Storage)
fn to_glib_container_from_slice(
t: &'a [T]
) -> (*mut GPtrArray, <T as ToGlibContainerFromSlice<'a, *mut GPtrArray>>::Storage)
[src]
t: &'a [T]
) -> (*mut GPtrArray, <T as ToGlibContainerFromSlice<'a, *mut GPtrArray>>::Storage)
fn to_glib_full_from_slice(t: &[T]) -> *mut GPtrArray
[src]
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
fn to_owned(&self) -> T
[src]
fn clone_into(&self, target: &mut T)
[src]
impl<T> ToSendValue for T where
T: ToValue + SetValue + Send + ?Sized,
[src]
T: ToValue + SetValue + Send + ?Sized,
fn to_send_value(&self) -> SendValue
[src]
impl<T> ToValue for T where
T: SetValue + ?Sized,
[src]
T: SetValue + ?Sized,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,