Struct SplitSchema 

pub struct SplitSchema {
    pub sequential: Vec<NextOperation>,
    pub keyed: HashMap<String, NextOperation>,
    pub remaining: Option<NextOperation>,
    pub trace_settings: TraceSettings,
}

If the input message is a list-like or map-like object, split it into multiple output messages.

Note that the type of output message from the split depends on how the input message implements the Splittable trait. In many cases this will be a tuple of (key, value).

There are three ways to specify where the split output messages should go, and all can be used at the same time:

• sequential - For array-like collections, send the “first” element of the collection to the first operation listed in the sequential array. The “second” element of the collection goes to the second operation listed in the sequential array. And so on for all elements in the collection. If one of the elements in the collection is mentioned in the keyed set, then the sequence will pass over it as if the element does not exist at all.
• keyed - For map-like collections, send the split element associated with the specified key to its associated output.
• remaining - Any elements that are were not captured by sequential or by keyed will be sent to this.

Examples

Suppose I am an animal rescuer sorting through a new collection of animals that need recuing. My home has space for three exotic animals plus any number of dogs and cats.

I have a custom SpeciesCollection data structure that implements Splittable by allowing you to key on the type of animal.

In the workflow below, we send all cats and dogs to home, and we also send the first three non-dog and non-cat species to home. All remaining animals go to the zoo.

{
    "version": "0.1.0",
    "start": "select_animals",
    "ops": {
        "select_animals": {
            "type": "split",
            "sequential": [
                "home",
                "home",
                "home"
            ],
            "keyed": {
                "cat": "home",
                "dog": "home"
            },
            "remaining": "zoo"
        }
    }
}

If we input ["frog", "cat", "bear", "beaver", "dog", "rabbit", "dog", "monkey"] then frog, bear, and beaver will be sent to home since those are the first three animals that are not dog or cat, and we will also send one cat and two dog home. rabbit and monkey will be sent to the zoo.

Fields

sequential: Vec<NextOperation>

keyed: HashMap<String, NextOperation>

remaining: Option<NextOperation>

trace_settings: TraceSettings

Trait Implementations

impl BuildDiagramOperation for SplitSchema

fn build_diagram_operation( &self, id: &OperationName, ctx: &mut DiagramContext<'_, '_, '_, '_, '_>, ) -> Result<BuildStatus, DiagramErrorCode>

impl Clone for SplitSchema

fn clone(&self) -> SplitSchema

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SplitSchema

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SplitSchema

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for SplitSchema

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

fn always_inline_schema() -> bool

👎Deprecated:

Use inline_schema() instead

Only included for backward-compatibility - use inline_schema() instead“.

impl Serialize for SplitSchema

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.