ConnectHandle

signals2

Struct ConnectHandle 

Source 
pub struct ConnectHandle<Args, R = (), C = DefaultCombiner, G = i32>
where
    Args: Clone + 'static,
    R: 'static,
    C: Combiner<R> + 'static,
    G: Ord + Send + Sync + 'static,
{ /* private fields */ }
Expand description

A handle to a signal that allows new slots to be connected to the underlying signal. Useful in cases where it is undesireable to allow unresitriced access to a signal while still allowing new slots to be connected. Internally, a ConnectHandle uses a WeakSignal. If the underlying signal no longer exists, connect will return a connection that is in a disconnected state.

§Example

use signals2::*;
 
let sig: Signal<(), i32> = Signal::new();
let connect_handle = sig.get_connect_handle();
let conn = connect_handle.connect(|| 1);
assert!(conn.connected());
assert_eq!(sig.emit(), Some(1));

std::mem::drop(sig);
let conn = connect_handle.connect(|| 2);
assert!(!conn.connected());

Trait Implementations§

Source§

impl<R, C, G> Connect0<R, C, G> for ConnectHandle<(), R, C, G>
where (): Clone + 'static, R: 'static, C: Combiner<R> + 'static, G: Ord + Send + Sync + 'static,

Source§

fn connect_group_position<F>( &self, f: F, group: Group<G>, pos: Position, ) -> Connection
where F: Fn() -> R + Send + Sync + 'static,

Connects the slot function f to the given Group at the given Position
Source§

fn connect_group_position_extended<F>( &self, f: F, group: Group<G>, pos: Position, ) -> Connection
where F: Fn(Connection) -> R + Send + Sync + 'static,

Connects the extended slot function f to the given Group at the given Position
Source§

fn connect_group<F>(&self, f: F, group: Group<G>) -> Connection
where F: Fn() -> R + Send + Sync + 'static,

Connects the slot function f to the given Group at Position::Back. Equivalent to calling connect_group_position(f, group, Position::Back).
Source§

fn connect_position<F>(&self, f: F, pos: Position) -> Connection
where F: Fn() -> R + Send + Sync + 'static,

Connects the slot function f to Group::Back at the given position. Equivalent to calling connect_group_position(f, Group::Back, pos).
Source§

fn connect<F>(&self, f: F) -> Connection
where F: Fn() -> R + Send + Sync + 'static,

Connects the slot function f to Group::Back at Position::Back. Equivalent to calling connect_group_position(f, Group::Back, Position::Back).
Source§

fn connect_group_extended<F>(&self, f: F, group: Group<G>) -> Connection
where F: Fn(Connection) -> R + Send + Sync + 'static,

Connects the extended slot function f to the given Group at Position::Back. Equivalent to calling connect_group_position_extended(f, group, Position::Back).
Source§

fn connect_position_extended<F>(&self, f: F, pos: Position) -> Connection
where F: Fn(Connection) -> R + Send + Sync + 'static,

Connects the extended slot function f to Group::Back at the given position. Equivalent to calling connect_group_position_extended(f, Group::Back, pos).
Source§

fn connect_extended<F>(&self, f: F) -> Connection
where F: Fn(Connection) -> R + Send + Sync + 'static,

Connects the extended slot function f to Group::Back at Position::Back. Equivalent to calling connect_group_position_extended(f, Group::Back, Position::Back).
Source§

impl<R, C, G, T0> Connect1<R, C, G, T0> for ConnectHandle<(T0,), R, C, G>
where (T0,): Clone + 'static, R: 'static, C: Combiner<R> + 'static, G: Ord + Send + Sync + 'static,

Source§

fn connect_group_position<F>( &self, f: F, group: Group<G>, pos: Position, ) -> Connection
where F: Fn(T0) -> R + Send + Sync + 'static,

Connects the slot function f to the given Group at the given Position
Source§

fn connect_group_position_extended<F>( &self, f: F, group: Group<G>, pos: Position, ) -> Connection
where F: Fn(Connection, T0) -> R + Send + Sync + 'static,

Connects the extended slot function f to the given Group at the given Position
Source§

fn connect_group<F>(&self, f: F, group: Group<G>) -> Connection
where F: Fn(T0) -> R + Send + Sync + 'static,

Connects the slot function f to the given Group at Position::Back. Equivalent to calling connect_group_position(f, group, Position::Back).
Source§

fn connect_position<F>(&self, f: F, pos: Position) -> Connection
where F: Fn(T0) -> R + Send + Sync + 'static,

Connects the slot function f to Group::Back at the given position. Equivalent to calling connect_group_position(f, Group::Back, pos).
Source§

fn connect<F>(&self, f: F) -> Connection
where F: Fn(T0) -> R + Send + Sync + 'static,

Connects the slot function f to Group::Back at Position::Back. Equivalent to calling connect_group_position(f, Group::Back, Position::Back).
Source§

fn connect_group_extended<F>(&self, f: F, group: Group<G>) -> Connection
where F: Fn(Connection, T0) -> R + Send + Sync + 'static,

Connects the extended slot function f to the given Group at Position::Back. Equivalent to calling connect_group_position_extended(f, group, Position::Back).
Source§

fn connect_position_extended<F>(&self, f: F, pos: Position) -> Connection
where F: Fn(Connection, T0) -> R + Send + Sync + 'static,

Connects the extended slot function f to Group::Back at the given position. Equivalent to calling connect_group_position_extended(f, Group::Back, pos).
Source§

fn connect_extended<F>(&self, f: F) -> Connection
where F: Fn(Connection, T0) -> R + Send + Sync + 'static,

Connects the extended slot function f to Group::Back at Position::Back. Equivalent to calling connect_group_position_extended(f, Group::Back, Position::Back).
Source§

impl<R, C, G, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Connect10<R, C, G, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> for ConnectHandle<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), R, C, G>
where (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9): Clone + 'static, R: 'static, C: Combiner<R> + 'static, G: Ord + Send + Sync + 'static,

Source§

fn connect_group_position<F>( &self, f: F, group: Group<G>, pos: Position, ) -> Connection
where F: Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> R + Send + Sync + 'static,

Connects the slot function f to the given Group at the given Position
Source§

fn connect_group_position_extended<F>( &self, f: F, group: Group<G>, pos: Position, ) -> Connection
where F: Fn(Connection, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> R + Send + Sync + 'static,

Connects the extended slot function f to the given Group at the given Position
Source§

fn connect_group<F>(&self, f: F, group: Group<G>) -> Connection
where F: Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> R + Send + Sync + 'static,

Connects the slot function f to the given Group at Position::Back. Equivalent to calling connect_group_position(f, group, Position::Back).
Source§

fn connect_position<F>(&self, f: F, pos: Position) -> Connection
where F: Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> R + Send + Sync + 'static,

Connects the slot function f to Group::Back at the given position. Equivalent to calling connect_group_position(f, Group::Back, pos).
Source§

fn connect<F>(&self, f: F) -> Connection
where F: Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> R + Send + Sync + 'static,

Connects the slot function f to Group::Back at Position::Back. Equivalent to calling connect_group_position(f, Group::Back, Position::Back).
Source§

fn connect_group_extended<F>(&self, f: F, group: Group<G>) -> Connection
where F: Fn(Connection, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> R + Send + Sync + 'static,

Connects the extended slot function f to the given Group at Position::Back. Equivalent to calling connect_group_position_extended(f, group, Position::Back).
Source§

fn connect_position_extended<F>(&self, f: F, pos: Position) -> Connection
where F: Fn(Connection, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> R + Send + Sync + 'static,

Connects the extended slot function f to Group::Back at the given position. Equivalent to calling connect_group_position_extended(f, Group::Back, pos).
Source§

fn connect_extended<F>(&self, f: F) -> Connection
where F: Fn(Connection, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> R + Send + Sync + 'static,

Connects the extended slot function f to Group::Back at Position::Back. Equivalent to calling connect_group_position_extended(f, Group::Back, Position::Back).
Source§

impl<R, C, G, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Connect11<R, C, G, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> for ConnectHandle<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), R, C, G>
where (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10): Clone + 'static, R: 'static, C: Combiner<R> + 'static, G: Ord + Send + Sync + 'static,

Source§

fn connect_group_position<F>( &self, f: F, group: Group<G>, pos: Position, ) -> Connection
where F: Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R + Send + Sync + 'static,

Connects the slot function f to the given Group at the given Position
Source§

fn connect_group_position_extended<F>( &self, f: F, group: Group<G>, pos: Position, ) -> Connection
where F: Fn(Connection, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R + Send + Sync + 'static,

Connects the extended slot function f to the given Group at the given Position
Source§

fn connect_group<F>(&self, f: F, group: Group<G>) -> Connection
where F: Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R + Send + Sync + 'static,

Connects the slot function f to the given Group at Position::Back. Equivalent to calling connect_group_position(f, group, Position::Back).
Source§

fn connect_position<F>(&self, f: F, pos: Position) -> Connection
where F: Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R + Send + Sync + 'static,

Connects the slot function f to Group::Back at the given position. Equivalent to calling connect_group_position(f, Group::Back, pos).
Source§

fn connect<F>(&self, f: F) -> Connection
where F: Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R + Send + Sync + 'static,

Connects the slot function f to Group::Back at Position::Back. Equivalent to calling connect_group_position(f, Group::Back, Position::Back).
Source§

fn connect_group_extended<F>(&self, f: F, group: Group<G>) -> Connection
where F: Fn(Connection, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R + Send + Sync + 'static,

Connects the extended slot function f to the given Group at Position::Back. Equivalent to calling connect_group_position_extended(f, group, Position::Back).
Source§

fn connect_position_extended<F>(&self, f: F, pos: Position) -> Connection
where F: Fn(Connection, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R + Send + Sync + 'static,

Connects the extended slot function f to Group::Back at the given position. Equivalent to calling connect_group_position_extended(f, Group::Back, pos).
Source§

fn connect_extended<F>(&self, f: F) -> Connection
where F: Fn(Connection, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R + Send + Sync + 'static,

Connects the extended slot function f to Group::Back at Position::Back. Equivalent to calling connect_group_position_extended(f, Group::Back, Position::Back).
Source§

impl<R, C, G, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Connect12<R, C, G, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> for ConnectHandle<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), R, C, G>
where (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11): Clone + 'static, R: 'static, C: Combiner<R> + 'static, G: Ord + Send + Sync + 'static,

Source§

fn connect_group_position<F>( &self, f: F, group: Group<G>, pos: Position, ) -> Connection
where F: Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> R + Send + Sync + 'static,

Connects the slot function f to the given Group at the given Position
Source§

fn connect_group_position_extended<F>( &self, f: F, group: Group<G>, pos: Position, ) -> Connection
where F: Fn(Connection, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> R + Send + Sync + 'static,

Connects the extended slot function f to the given Group at the given Position
Source§

fn connect_group<F>(&self, f: F, group: Group<G>) -> Connection
where F: Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> R + Send + Sync + 'static,

Connects the slot function f to the given Group at Position::Back. Equivalent to calling connect_group_position(f, group, Position::Back).
Source§

fn connect_position<F>(&self, f: F, pos: Position) -> Connection
where F: Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> R + Send + Sync + 'static,

Connects the slot function f to Group::Back at the given position. Equivalent to calling connect_group_position(f, Group::Back, pos).
Source§

fn connect<F>(&self, f: F) -> Connection
where F: Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> R + Send + Sync + 'static,

Connects the slot function f to Group::Back at Position::Back. Equivalent to calling connect_group_position(f, Group::Back, Position::Back).
Source§

fn connect_group_extended<F>(&self, f: F, group: Group<G>) -> Connection
where F: Fn(Connection, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> R + Send + Sync + 'static,

Connects the extended slot function f to the given Group at Position::Back. Equivalent to calling connect_group_position_extended(f, group, Position::Back).
Source§

fn connect_position_extended<F>(&self, f: F, pos: Position) -> Connection
where F: Fn(Connection, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> R + Send + Sync + 'static,

Connects the extended slot function f to Group::Back at the given position. Equivalent to calling connect_group_position_extended(f, Group::Back, pos).
Source§

fn connect_extended<F>(&self, f: F) -> Connection
where F: Fn(Connection, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> R + Send + Sync + 'static,

Connects the extended slot function f to Group::Back at Position::Back. Equivalent to calling connect_group_position_extended(f, Group::Back, Position::Back).
Source§

impl<R, C, G, T0, T1> Connect2<R, C, G, T0, T1> for ConnectHandle<(T0, T1), R, C, G>
where (T0, T1): Clone + 'static, R: 'static, C: Combiner<R> + 'static, G: Ord + Send + Sync + 'static,

Source§

fn connect_group_position<F>( &self, f: F, group: Group<G>, pos: Position, ) -> Connection
where F: Fn(T0, T1) -> R + Send + Sync + 'static,

Connects the slot function f to the given Group at the given Position
Source§

fn connect_group_position_extended<F>( &self, f: F, group: Group<G>, pos: Position, ) -> Connection
where F: Fn(Connection, T0, T1) -> R + Send + Sync + 'static,

Connects the extended slot function f to the given Group at the given Position
Source§

fn connect_group<F>(&self, f: F, group: Group<G>) -> Connection
where F: Fn(T0, T1) -> R + Send + Sync + 'static,

Connects the slot function f to the given Group at Position::Back. Equivalent to calling connect_group_position(f, group, Position::Back).
Source§

fn connect_position<F>(&self, f: F, pos: Position) -> Connection
where F: Fn(T0, T1) -> R + Send + Sync + 'static,

Connects the slot function f to Group::Back at the given position. Equivalent to calling connect_group_position(f, Group::Back, pos).
Source§

fn connect<F>(&self, f: F) -> Connection
where F: Fn(T0, T1) -> R + Send + Sync + 'static,

Connects the slot function f to Group::Back at Position::Back. Equivalent to calling connect_group_position(f, Group::Back, Position::Back).
Source§

fn connect_group_extended<F>(&self, f: F, group: Group<G>) -> Connection
where F: Fn(Connection, T0, T1) -> R + Send + Sync + 'static,

Connects the extended slot function f to the given Group at Position::Back. Equivalent to calling connect_group_position_extended(f, group, Position::Back).
Source§

fn connect_position_extended<F>(&self, f: F, pos: Position) -> Connection
where F: Fn(Connection, T0, T1) -> R + Send + Sync + 'static,

Connects the extended slot function f to Group::Back at the given position. Equivalent to calling connect_group_position_extended(f, Group::Back, pos).
Source§

fn connect_extended<F>(&self, f: F) -> Connection
where F: Fn(Connection, T0, T1) -> R + Send + Sync + 'static,

Connects the extended slot function f to Group::Back at Position::Back. Equivalent to calling connect_group_position_extended(f, Group::Back, Position::Back).
Source§

impl<R, C, G, T0, T1, T2> Connect3<R, C, G, T0, T1, T2> for ConnectHandle<(T0, T1, T2), R, C, G>
where (T0, T1, T2): Clone + 'static, R: 'static, C: Combiner<R> + 'static, G: Ord + Send + Sync + 'static,

Source§

fn connect_group_position<F>( &self, f: F, group: Group<G>, pos: Position, ) -> Connection
where F: Fn(T0, T1, T2) -> R + Send + Sync + 'static,

Connects the slot function f to the given Group at the given Position
Source§

fn connect_group_position_extended<F>( &self, f: F, group: Group<G>, pos: Position, ) -> Connection
where F: Fn(Connection, T0, T1, T2) -> R + Send + Sync + 'static,

Connects the extended slot function f to the given Group at the given Position
Source§

fn connect_group<F>(&self, f: F, group: Group<G>) -> Connection
where F: Fn(T0, T1, T2) -> R + Send + Sync + 'static,

Connects the slot function f to the given Group at Position::Back. Equivalent to calling connect_group_position(f, group, Position::Back).
Source§

fn connect_position<F>(&self, f: F, pos: Position) -> Connection
where F: Fn(T0, T1, T2) -> R + Send + Sync + 'static,

Connects the slot function f to Group::Back at the given position. Equivalent to calling connect_group_position(f, Group::Back, pos).
Source§

fn connect<F>(&self, f: F) -> Connection
where F: Fn(T0, T1, T2) -> R + Send + Sync + 'static,

Connects the slot function f to Group::Back at Position::Back. Equivalent to calling connect_group_position(f, Group::Back, Position::Back).
Source§

fn connect_group_extended<F>(&self, f: F, group: Group<G>) -> Connection
where F: Fn(Connection, T0, T1, T2) -> R + Send + Sync + 'static,

Connects the extended slot function f to the given Group at Position::Back. Equivalent to calling connect_group_position_extended(f, group, Position::Back).
Source§

fn connect_position_extended<F>(&self, f: F, pos: Position) -> Connection
where F: Fn(Connection, T0, T1, T2) -> R + Send + Sync + 'static,

Connects the extended slot function f to Group::Back at the given position. Equivalent to calling connect_group_position_extended(f, Group::Back, pos).
Source§

fn connect_extended<F>(&self, f: F) -> Connection
where F: Fn(Connection, T0, T1, T2) -> R + Send + Sync + 'static,

Connects the extended slot function f to Group::Back at Position::Back. Equivalent to calling connect_group_position_extended(f, Group::Back, Position::Back).
Source§

impl<R, C, G, T0, T1, T2, T3> Connect4<R, C, G, T0, T1, T2, T3> for ConnectHandle<(T0, T1, T2, T3), R, C, G>
where (T0, T1, T2, T3): Clone + 'static, R: 'static, C: Combiner<R> + 'static, G: Ord + Send + Sync + 'static,

Source§

fn connect_group_position<F>( &self, f: F, group: Group<G>, pos: Position, ) -> Connection
where F: Fn(T0, T1, T2, T3) -> R + Send + Sync + 'static,

Connects the slot function f to the given Group at the given Position
Source§

fn connect_group_position_extended<F>( &self, f: F, group: Group<G>, pos: Position, ) -> Connection
where F: Fn(Connection, T0, T1, T2, T3) -> R + Send + Sync + 'static,

Connects the extended slot function f to the given Group at the given Position
Source§

fn connect_group<F>(&self, f: F, group: Group<G>) -> Connection
where F: Fn(T0, T1, T2, T3) -> R + Send + Sync + 'static,

Connects the slot function f to the given Group at Position::Back. Equivalent to calling connect_group_position(f, group, Position::Back).
Source§

fn connect_position<F>(&self, f: F, pos: Position) -> Connection
where F: Fn(T0, T1, T2, T3) -> R + Send + Sync + 'static,

Connects the slot function f to Group::Back at the given position. Equivalent to calling connect_group_position(f, Group::Back, pos).
Source§

fn connect<F>(&self, f: F) -> Connection
where F: Fn(T0, T1, T2, T3) -> R + Send + Sync + 'static,

Connects the slot function f to Group::Back at Position::Back. Equivalent to calling connect_group_position(f, Group::Back, Position::Back).
Source§

fn connect_group_extended<F>(&self, f: F, group: Group<G>) -> Connection
where F: Fn(Connection, T0, T1, T2, T3) -> R + Send + Sync + 'static,

Connects the extended slot function f to the given Group at Position::Back. Equivalent to calling connect_group_position_extended(f, group, Position::Back).
Source§

fn connect_position_extended<F>(&self, f: F, pos: Position) -> Connection
where F: Fn(Connection, T0, T1, T2, T3) -> R + Send + Sync + 'static,

Connects the extended slot function f to Group::Back at the given position. Equivalent to calling connect_group_position_extended(f, Group::Back, pos).
Source§

fn connect_extended<F>(&self, f: F) -> Connection
where F: Fn(Connection, T0, T1, T2, T3) -> R + Send + Sync + 'static,

Connects the extended slot function f to Group::Back at Position::Back. Equivalent to calling connect_group_position_extended(f, Group::Back, Position::Back).
Source§

impl<R, C, G, T0, T1, T2, T3, T4> Connect5<R, C, G, T0, T1, T2, T3, T4> for ConnectHandle<(T0, T1, T2, T3, T4), R, C, G>
where (T0, T1, T2, T3, T4): Clone + 'static, R: 'static, C: Combiner<R> + 'static, G: Ord + Send + Sync + 'static,

Source§

fn connect_group_position<F>( &self, f: F, group: Group<G>, pos: Position, ) -> Connection
where F: Fn(T0, T1, T2, T3, T4) -> R + Send + Sync + 'static,

Connects the slot function f to the given Group at the given Position
Source§

fn connect_group_position_extended<F>( &self, f: F, group: Group<G>, pos: Position, ) -> Connection
where F: Fn(Connection, T0, T1, T2, T3, T4) -> R + Send + Sync + 'static,

Connects the extended slot function f to the given Group at the given Position
Source§

fn connect_group<F>(&self, f: F, group: Group<G>) -> Connection
where F: Fn(T0, T1, T2, T3, T4) -> R + Send + Sync + 'static,

Connects the slot function f to the given Group at Position::Back. Equivalent to calling connect_group_position(f, group, Position::Back).
Source§

fn connect_position<F>(&self, f: F, pos: Position) -> Connection
where F: Fn(T0, T1, T2, T3, T4) -> R + Send + Sync + 'static,

Connects the slot function f to Group::Back at the given position. Equivalent to calling connect_group_position(f, Group::Back, pos).
Source§

fn connect<F>(&self, f: F) -> Connection
where F: Fn(T0, T1, T2, T3, T4) -> R + Send + Sync + 'static,

Connects the slot function f to Group::Back at Position::Back. Equivalent to calling connect_group_position(f, Group::Back, Position::Back).
Source§

fn connect_group_extended<F>(&self, f: F, group: Group<G>) -> Connection
where F: Fn(Connection, T0, T1, T2, T3, T4) -> R + Send + Sync + 'static,

Connects the extended slot function f to the given Group at Position::Back. Equivalent to calling connect_group_position_extended(f, group, Position::Back).
Source§

fn connect_position_extended<F>(&self, f: F, pos: Position) -> Connection
where F: Fn(Connection, T0, T1, T2, T3, T4) -> R + Send + Sync + 'static,

Connects the extended slot function f to Group::Back at the given position. Equivalent to calling connect_group_position_extended(f, Group::Back, pos).
Source§

fn connect_extended<F>(&self, f: F) -> Connection
where F: Fn(Connection, T0, T1, T2, T3, T4) -> R + Send + Sync + 'static,

Connects the extended slot function f to Group::Back at Position::Back. Equivalent to calling connect_group_position_extended(f, Group::Back, Position::Back).
Source§

impl<R, C, G, T0, T1, T2, T3, T4, T5> Connect6<R, C, G, T0, T1, T2, T3, T4, T5> for ConnectHandle<(T0, T1, T2, T3, T4, T5), R, C, G>
where (T0, T1, T2, T3, T4, T5): Clone + 'static, R: 'static, C: Combiner<R> + 'static, G: Ord + Send + Sync + 'static,

Source§

fn connect_group_position<F>( &self, f: F, group: Group<G>, pos: Position, ) -> Connection
where F: Fn(T0, T1, T2, T3, T4, T5) -> R + Send + Sync + 'static,

Connects the slot function f to the given Group at the given Position
Source§

fn connect_group_position_extended<F>( &self, f: F, group: Group<G>, pos: Position, ) -> Connection
where F: Fn(Connection, T0, T1, T2, T3, T4, T5) -> R + Send + Sync + 'static,

Connects the extended slot function f to the given Group at the given Position
Source§

fn connect_group<F>(&self, f: F, group: Group<G>) -> Connection
where F: Fn(T0, T1, T2, T3, T4, T5) -> R + Send + Sync + 'static,

Connects the slot function f to the given Group at Position::Back. Equivalent to calling connect_group_position(f, group, Position::Back).
Source§

fn connect_position<F>(&self, f: F, pos: Position) -> Connection
where F: Fn(T0, T1, T2, T3, T4, T5) -> R + Send + Sync + 'static,

Connects the slot function f to Group::Back at the given position. Equivalent to calling connect_group_position(f, Group::Back, pos).
Source§

fn connect<F>(&self, f: F) -> Connection
where F: Fn(T0, T1, T2, T3, T4, T5) -> R + Send + Sync + 'static,

Connects the slot function f to Group::Back at Position::Back. Equivalent to calling connect_group_position(f, Group::Back, Position::Back).
Source§

fn connect_group_extended<F>(&self, f: F, group: Group<G>) -> Connection
where F: Fn(Connection, T0, T1, T2, T3, T4, T5) -> R + Send + Sync + 'static,

Connects the extended slot function f to the given Group at Position::Back. Equivalent to calling connect_group_position_extended(f, group, Position::Back).
Source§

fn connect_position_extended<F>(&self, f: F, pos: Position) -> Connection
where F: Fn(Connection, T0, T1, T2, T3, T4, T5) -> R + Send + Sync + 'static,

Connects the extended slot function f to Group::Back at the given position. Equivalent to calling connect_group_position_extended(f, Group::Back, pos).
Source§

fn connect_extended<F>(&self, f: F) -> Connection
where F: Fn(Connection, T0, T1, T2, T3, T4, T5) -> R + Send + Sync + 'static,

Connects the extended slot function f to Group::Back at Position::Back. Equivalent to calling connect_group_position_extended(f, Group::Back, Position::Back).
Source§

impl<R, C, G, T0, T1, T2, T3, T4, T5, T6> Connect7<R, C, G, T0, T1, T2, T3, T4, T5, T6> for ConnectHandle<(T0, T1, T2, T3, T4, T5, T6), R, C, G>
where (T0, T1, T2, T3, T4, T5, T6): Clone + 'static, R: 'static, C: Combiner<R> + 'static, G: Ord + Send + Sync + 'static,

Source§

fn connect_group_position<F>( &self, f: F, group: Group<G>, pos: Position, ) -> Connection
where F: Fn(T0, T1, T2, T3, T4, T5, T6) -> R + Send + Sync + 'static,

Connects the slot function f to the given Group at the given Position
Source§

fn connect_group_position_extended<F>( &self, f: F, group: Group<G>, pos: Position, ) -> Connection
where F: Fn(Connection, T0, T1, T2, T3, T4, T5, T6) -> R + Send + Sync + 'static,

Connects the extended slot function f to the given Group at the given Position
Source§

fn connect_group<F>(&self, f: F, group: Group<G>) -> Connection
where F: Fn(T0, T1, T2, T3, T4, T5, T6) -> R + Send + Sync + 'static,

Connects the slot function f to the given Group at Position::Back. Equivalent to calling connect_group_position(f, group, Position::Back).
Source§

fn connect_position<F>(&self, f: F, pos: Position) -> Connection
where F: Fn(T0, T1, T2, T3, T4, T5, T6) -> R + Send + Sync + 'static,

Connects the slot function f to Group::Back at the given position. Equivalent to calling connect_group_position(f, Group::Back, pos).
Source§

fn connect<F>(&self, f: F) -> Connection
where F: Fn(T0, T1, T2, T3, T4, T5, T6) -> R + Send + Sync + 'static,

Connects the slot function f to Group::Back at Position::Back. Equivalent to calling connect_group_position(f, Group::Back, Position::Back).
Source§

fn connect_group_extended<F>(&self, f: F, group: Group<G>) -> Connection
where F: Fn(Connection, T0, T1, T2, T3, T4, T5, T6) -> R + Send + Sync + 'static,

Connects the extended slot function f to the given Group at Position::Back. Equivalent to calling connect_group_position_extended(f, group, Position::Back).
Source§

fn connect_position_extended<F>(&self, f: F, pos: Position) -> Connection
where F: Fn(Connection, T0, T1, T2, T3, T4, T5, T6) -> R + Send + Sync + 'static,

Connects the extended slot function f to Group::Back at the given position. Equivalent to calling connect_group_position_extended(f, Group::Back, pos).
Source§

fn connect_extended<F>(&self, f: F) -> Connection
where F: Fn(Connection, T0, T1, T2, T3, T4, T5, T6) -> R + Send + Sync + 'static,

Connects the extended slot function f to Group::Back at Position::Back. Equivalent to calling connect_group_position_extended(f, Group::Back, Position::Back).
Source§

impl<R, C, G, T0, T1, T2, T3, T4, T5, T6, T7> Connect8<R, C, G, T0, T1, T2, T3, T4, T5, T6, T7> for ConnectHandle<(T0, T1, T2, T3, T4, T5, T6, T7), R, C, G>
where (T0, T1, T2, T3, T4, T5, T6, T7): Clone + 'static, R: 'static, C: Combiner<R> + 'static, G: Ord + Send + Sync + 'static,

Source§

fn connect_group_position<F>( &self, f: F, group: Group<G>, pos: Position, ) -> Connection
where F: Fn(T0, T1, T2, T3, T4, T5, T6, T7) -> R + Send + Sync + 'static,

Connects the slot function f to the given Group at the given Position
Source§

fn connect_group_position_extended<F>( &self, f: F, group: Group<G>, pos: Position, ) -> Connection
where F: Fn(Connection, T0, T1, T2, T3, T4, T5, T6, T7) -> R + Send + Sync + 'static,

Connects the extended slot function f to the given Group at the given Position
Source§

fn connect_group<F>(&self, f: F, group: Group<G>) -> Connection
where F: Fn(T0, T1, T2, T3, T4, T5, T6, T7) -> R + Send + Sync + 'static,

Connects the slot function f to the given Group at Position::Back. Equivalent to calling connect_group_position(f, group, Position::Back).
Source§

fn connect_position<F>(&self, f: F, pos: Position) -> Connection
where F: Fn(T0, T1, T2, T3, T4, T5, T6, T7) -> R + Send + Sync + 'static,

Connects the slot function f to Group::Back at the given position. Equivalent to calling connect_group_position(f, Group::Back, pos).
Source§

fn connect<F>(&self, f: F) -> Connection
where F: Fn(T0, T1, T2, T3, T4, T5, T6, T7) -> R + Send + Sync + 'static,

Connects the slot function f to Group::Back at Position::Back. Equivalent to calling connect_group_position(f, Group::Back, Position::Back).
Source§

fn connect_group_extended<F>(&self, f: F, group: Group<G>) -> Connection
where F: Fn(Connection, T0, T1, T2, T3, T4, T5, T6, T7) -> R + Send + Sync + 'static,

Connects the extended slot function f to the given Group at Position::Back. Equivalent to calling connect_group_position_extended(f, group, Position::Back).
Source§

fn connect_position_extended<F>(&self, f: F, pos: Position) -> Connection
where F: Fn(Connection, T0, T1, T2, T3, T4, T5, T6, T7) -> R + Send + Sync + 'static,

Connects the extended slot function f to Group::Back at the given position. Equivalent to calling connect_group_position_extended(f, Group::Back, pos).
Source§

fn connect_extended<F>(&self, f: F) -> Connection
where F: Fn(Connection, T0, T1, T2, T3, T4, T5, T6, T7) -> R + Send + Sync + 'static,

Connects the extended slot function f to Group::Back at Position::Back. Equivalent to calling connect_group_position_extended(f, Group::Back, Position::Back).
Source§

impl<R, C, G, T0, T1, T2, T3, T4, T5, T6, T7, T8> Connect9<R, C, G, T0, T1, T2, T3, T4, T5, T6, T7, T8> for ConnectHandle<(T0, T1, T2, T3, T4, T5, T6, T7, T8), R, C, G>
where (T0, T1, T2, T3, T4, T5, T6, T7, T8): Clone + 'static, R: 'static, C: Combiner<R> + 'static, G: Ord + Send + Sync + 'static,

Source§

fn connect_group_position<F>( &self, f: F, group: Group<G>, pos: Position, ) -> Connection
where F: Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> R + Send + Sync + 'static,

Connects the slot function f to the given Group at the given Position
Source§

fn connect_group_position_extended<F>( &self, f: F, group: Group<G>, pos: Position, ) -> Connection
where F: Fn(Connection, T0, T1, T2, T3, T4, T5, T6, T7, T8) -> R + Send + Sync + 'static,

Connects the extended slot function f to the given Group at the given Position
Source§

fn connect_group<F>(&self, f: F, group: Group<G>) -> Connection
where F: Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> R + Send + Sync + 'static,

Connects the slot function f to the given Group at Position::Back. Equivalent to calling connect_group_position(f, group, Position::Back).
Source§

fn connect_position<F>(&self, f: F, pos: Position) -> Connection
where F: Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> R + Send + Sync + 'static,

Connects the slot function f to Group::Back at the given position. Equivalent to calling connect_group_position(f, Group::Back, pos).
Source§

fn connect<F>(&self, f: F) -> Connection
where F: Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> R + Send + Sync + 'static,

Connects the slot function f to Group::Back at Position::Back. Equivalent to calling connect_group_position(f, Group::Back, Position::Back).
Source§

fn connect_group_extended<F>(&self, f: F, group: Group<G>) -> Connection
where F: Fn(Connection, T0, T1, T2, T3, T4, T5, T6, T7, T8) -> R + Send + Sync + 'static,

Connects the extended slot function f to the given Group at Position::Back. Equivalent to calling connect_group_position_extended(f, group, Position::Back).
Source§

fn connect_position_extended<F>(&self, f: F, pos: Position) -> Connection
where F: Fn(Connection, T0, T1, T2, T3, T4, T5, T6, T7, T8) -> R + Send + Sync + 'static,

Connects the extended slot function f to Group::Back at the given position. Equivalent to calling connect_group_position_extended(f, Group::Back, pos).
Source§

fn connect_extended<F>(&self, f: F) -> Connection
where F: Fn(Connection, T0, T1, T2, T3, T4, T5, T6, T7, T8) -> R + Send + Sync + 'static,

Connects the extended slot function f to Group::Back at Position::Back. Equivalent to calling connect_group_position_extended(f, Group::Back, Position::Back).

Auto Trait Implementations§

§

impl<Args, R, C, G> Freeze for ConnectHandle<Args, R, C, G>

§

impl<Args, R, C, G> RefUnwindSafe for ConnectHandle<Args, R, C, G>

§

impl<Args, R, C, G> Send for ConnectHandle<Args, R, C, G>

§

impl<Args, R, C, G> Sync for ConnectHandle<Args, R, C, G>

§

impl<Args, R, C, G> Unpin for ConnectHandle<Args, R, C, G>

§

impl<Args, R, C, G> UnwindSafe for ConnectHandle<Args, R, C, G>

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.