Trait pharos::Observable

pub trait Observable<Event> where
    Event: Clone + 'static + Send, {
    fn observe(&mut self, options: ObserveConfig<Event>) -> Events<Event>;
}

Indicate that a type is observable. You can call observe to get a stream of events.

Generally used with a Pharos object which manages the observers for you.

use pharos::*;
use futures::stream::StreamExt;

// The event we want to broadcast
//
#[ derive( Debug, Clone ) ]
//
enum Steps
{
  Step1     ,
  Step2     ,
  Done      ,

  // Data is possible, but it has to be clone and will be cloned for each observer
  // except observers that filter this event out.
  //
  Error(u8) ,
}


impl Steps
{
   fn is_err( &self ) -> bool
   {
      match self
      {
         Self::Error(_) => true  ,
         _              => false ,
      }
   }
}


// The object we want to be observable
//
struct Foo { pharos: Pharos<Steps> };

impl Observable<Steps> for Foo
{
   // Pharos implements observable, so we just forward the call.
   //
   fn observe( &mut self, options: ObserveConfig<Steps> ) -> Events<Steps>
   {
      self.pharos.observe( options )
   }
}


// use in async context
//
async fn task()
{
   let mut foo    = Foo { pharos: Pharos::default() };
   let mut errors = foo.observe( Filter::Pointer( Steps::is_err ).into() );

   // will only be notified on errors now
   //
   let next_error = errors.next().await;
}

Required methods

fn observe(&mut self, options: ObserveConfig<Event>) -> Events<Event>

Add an observer to the observable. Options can be in order to choose channel type and to filter events with a predicate.

Loading content...

Implementors

impl<Event> Observable<Event> for Pharos<Event> where
    Event: 'static + Clone + Send, 

fn observe(&mut self, options: ObserveConfig<Event>) -> Events<Event>

Loading content...