Struct nuts::ActivityId

pub struct ActivityId<A> { /* fields omitted */ }

Handle to an Activity that has been registered, with a type parameter to track the activity's type. Can be used to add type-checked closures to the activity, which will be used as event listeners.

Implements Copy and Clone

Implementations

impl<A: Activity> ActivityId<A>

pub fn on_enter<F>(&self, f: F) where
    F: Fn(&mut A) + 'static, 

Registers a callback closure that is called when an activity changes from inactive to active.

pub fn on_enter_domained<F>(&self, f: F) where
    F: Fn(&mut A, &mut DomainState) + 'static, 

Same as on_enter but with domain access in closure

pub fn on_leave<F>(&self, f: F) where
    F: Fn(&mut A) + 'static, 

Registers a callback closure that is called when an activity changes from active to inactive.

pub fn on_leave_domained<F>(&self, f: F) where
    F: Fn(&mut A, &mut DomainState) + 'static, 

Same as on_leave but with domain access in closure

pub fn subscribe<F, MSG>(&self, f: F) where
    F: Fn(&mut A, &MSG) + 'static,
    MSG: Any, 

Registers a callback closure on an activity with a specific topic to listen to.

By default, the activity will only receive calls when it is active. Use subscribe_masked for more control over this behavior.

Example

struct MyActivity { id: usize };
struct MyMessage { text: String };

pub fn main() {
    let activity = nuts::new_activity(MyActivity { id: 0 } );
    activity.subscribe(
        |activity: &mut MyActivity, message: &MyMessage|
        println!("Subscriber with ID {} received text: {}", activity.id, message.text)
    );
}

In the example above, a subscription is created that waits for messages of type MyMessage to be published. So far, the code inside the closure is not executed and nothing is printed to the console.

Note that the first argument of the closure is a mutable reference to the activity object. The second argument is a read-only reference to the published message. Both types must match exactly or otherwise the closure will either not be accepted by the compiler.

A function with the correct argument types can also be used to subscribe.

struct MyActivity { id: usize };
struct MyMessage { text: String };

pub fn main() {
    let activity = nuts::new_activity(MyActivity { id: 0 } );
    activity.subscribe(MyActivity::print_text);
}

impl MyActivity {
    fn print_text(&mut self, message: &MyMessage) {
        println!("Subscriber with ID {} received text: {}", self.id, message.text)
    }
}

pub fn subscribe_mut<F, MSG>(&self, f: F) where
    F: Fn(&mut A, &mut MSG) + 'static,
    MSG: Any, 

Same as subscribe but gives mutable access to the message object.

pub fn subscribe_owned<F, MSG>(&self, f: F) where
    F: Fn(&mut A, MSG) + 'static,
    MSG: Any, 

Registers a callback closure on an activity with a specific topic to listen to. This variant takes ownership of the message. Only subscription per type is allowed. Othwerise, a pnic will occur when publishing.

pub fn subscribe_domained<F, MSG>(&self, f: F) where
    F: Fn(&mut A, &mut DomainState, &MSG) + 'static,
    MSG: Any, 

Registers a callback closure on an activity with a specific topic to listen to. Has mutable access to the DomainState object.

By default, the activity will only receive calls when it is active. Use subscribe_domained_masked for more control over this behavior.

Panics

Panics if the activity has not been registered with a domain.

pub fn subscribe_domained_mut<F, MSG>(&self, f: F) where
    F: Fn(&mut A, &mut DomainState, &mut MSG) + 'static,
    MSG: Any, 

Same as subscribe_domained but gives mutable access to the message object.

pub fn subscribe_domained_owned<F, MSG>(&self, f: F) where
    F: Fn(&mut A, &mut DomainState, MSG) + 'static,
    MSG: Any, 

Registers a callback closure on an activity with a specific topic to listen to and access to the domain. This variant takes ownership of the message. Only subscription per type is allowed. Otherwise, a panic will occur when publishing.

pub fn subscribe_masked<F, MSG>(&self, mask: SubscriptionFilter, f: F) where
    F: Fn(&mut A, &MSG) + 'static,
    MSG: Any, 

Registers a callback closure on an activity with a specific topic to listen to with filtering options.

pub fn subscribe_masked_mut<F, MSG>(&self, mask: SubscriptionFilter, f: F) where
    F: Fn(&mut A, &mut MSG) + 'static,
    MSG: Any, 

Same as subscribe_masked but gives mutable access to the message object.

pub fn subscribe_domained_masked<F, MSG>(&self, mask: SubscriptionFilter, f: F) where
    F: Fn(&mut A, &mut DomainState, &MSG) + 'static,
    MSG: Any, 

Registers a callback closure on an activity with a specific topic to listen to with filtering options. Has mutable access to the DomainState object.

Panics

Panics if the activity has not been registered with a domain.

pub fn subscribe_domained_masked_mut<F, MSG>(
    &self,
    mask: SubscriptionFilter,
    f: F
) where
    F: Fn(&mut A, &mut DomainState, &mut MSG) + 'static,
    MSG: Any, 

Same as subscribe_domained_masked but gives mutable access to the message object.

pub fn set_status(&self, status: LifecycleStatus)

Changes the lifecycle status of the activity

Trait Implementations

impl<A> Clone for ActivityId<A>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A> Copy for ActivityId<A>

impl<A: Debug> Debug for ActivityId<A>

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

Formats the value using the given formatter.

impl<A: Eq> Eq for ActivityId<A>

impl<A: Hash> Hash for ActivityId<A>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl<A> Into<UncheckedActivityId> for ActivityId<A>

fn into(self) -> UncheckedActivityId

Performs the conversion.

impl<A: Ord> Ord for ActivityId<A>

fn cmp(&self, other: &ActivityId<A>) -> Ordering

This method returns an Ordering between self and other.

#[must_use]fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl<A: PartialEq> PartialEq<ActivityId<A>> for ActivityId<A>

fn eq(&self, other: &ActivityId<A>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &ActivityId<A>) -> bool

This method tests for !=.

impl<A: PartialOrd> PartialOrd<ActivityId<A>> for ActivityId<A>

fn partial_cmp(&self, other: &ActivityId<A>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &ActivityId<A>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &ActivityId<A>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &ActivityId<A>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &ActivityId<A>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<A> StructuralEq for ActivityId<A>

impl<A> StructuralPartialEq for ActivityId<A>