enum-pipeline

Provides a way to use enums to describe and execute ordered data pipelines. 🦀🐾

I needed a succinct way to describe 2d pixel map operations for a game I'm working on. I wanted callers to be able to easily determine all possible operations (hence enum), with per-operation data (hence variants), and their operation-specific logic. This is what I came up with!

Quickstart

Some quick examples to get you started. For more information see docs.rs/enumpipeline and docs.rs/enumpipeline_derive.

Derive

```

[derive(Default)]

struct MacroMutRefData { acount: i32, bcount: i32, }

[derive(ExecuteWithMut)]

[execute_with(MacroMutRefData)]

enum MacroMutRefPipeline { #[handler(handlea)] A(i32), #[handler(handleb)] B, }

impl MacroMutRefPipeline { fn handlea(i: i32, arg: &mut MacroMutRefData) { arg.acount += 1; }

fn handle_b(arg: &mut MacroMutRefData) {
    arg.b_count += 1;
}

} ```

Then create and execute some pipelines:

let mut arg = MacroMutRefData::default(); vec![MacroMutRefPipeline::A(23), MacroMutRefPipeline::B].execute_with_mut(&mut arg);

Manual

```

[derive(Default)]

struct MutRefData { acount: i32, bcount: i32, }

enum MutRefPipeline { A(i32), B, }

impl ExecuteWithMut for MutRefPipeline { fn executewithmut(self, arg: &mut MutRefData) { match self { MutRefPipeline::A(i) => arg.acount += 1, MutRefPipeline::B => arg.bcount += 1, } } } ```

Then create and execute some pipelines:

let mut arg = MutRefData::default(); vec![MutRefPipeline::A(23), MutRefPipeline::B].execute_with_mut(&mut arg);

License

MIT