Struct PipelineBuilder 

pub struct PipelineBuilder<T: Clone + Send + Sync + 'static> { /* private fields */ }

PipelineBuilder provides flexibility and extensibility to your pipelines

Pipes/function can be appended to your type pipeline from other places in your code or even across crates.

#[derive(Default, Clone)]
struct MeaningOfLife(i32);



#[tokio::main]
async fn main() {

   let builder = PipelineBuilder::<MeaningOfLife>::new();

   builder.register(|pipeline| {
      Box::pin(async {
        pipeline.store_fn(|mut instance: MeaningOfLife| async {
            instance.0 = 42;
           instance
        }).await
     })
   }).await;
 
   let life = builder.build(MeaningOfLife::default()).await.deliver().await;
   assert_eq!(life.0, 42);
}

You can implement the PipelineBuilderTrait for your type as well

#[derive(Default, Clone)]
struct MeaningOfLife(i32);


#[fama::async_trait]
impl PipelineBuilderTrait for MeaningOfLife {

   // we are overriding the default implementation of this method in order
   // to append our pipe
   async fn setup_pipeline_builder(builder: PipelineBuilder<Self>) -> PipelineBuilder<Self> {
      builder.register(|pipeline| {
         Box::pin(async {
              pipeline.store_fn(|mut instance: MeaningOfLife| async {
                   instance.0 = 42;
                   instance
             }).await
         })
       }).await;

       builder
   }
   
}


#[tokio::main]
async fn main() {

   let new_life = MeaningOfLife(0);

   // Register/append a pipe/function to the pipeline
   MeaningOfLife::pipeline_builder().await
     .register(|pipeline| {
          Box::pin(async {
             pipeline.store_fn(|mut instance: MeaningOfLife| async {
                 if instance.0 == 0  {
                     instance.0 = 42 ;
                  } else {
                     instance.0 = instance.0 * 2;
                  }
                  instance
             }).await
         })
      }).await;
 
   let life = new_life.pipeline().await.deliver().await;
   assert_eq!(life.0, 84);
}

Implementations

impl<T: Clone + Send + Sync + 'static> PipelineBuilder<T>

pub fn new() -> Self

pub async fn initial() -> (bool, Self)

pub async fn register<F>(&self, callback: F) -> &Self

where F: FnMut(Pipeline<T>) -> BoxFuture<'static, Pipeline<T>> + Send + Sync + 'static,

pub async fn build(&self, content: T) -> Pipeline<T>

Trait Implementations

impl<T: Clone + Clone + Send + Sync + 'static> Clone for PipelineBuilder<T>

fn clone(&self) -> PipelineBuilder<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Clone + Send + Sync + 'static> Default for PipelineBuilder<T>

fn default() -> Self

Returns the “default value” for a type.