Enum WorkflowVersionPolicy 

#[non_exhaustive]
pub enum WorkflowVersionPolicy {
    Pinned,
    ForwardCompatible,
    Explicit(Vec<FormatVersion>),
}

Declares which BDEW format versions a Workflow implementation can accept over the lifetime of in-flight processes.

BDEW releases two annual format updates. Processes that span a release boundary (e.g. a MABIS billing process that starts in October and settles in January) must accept inbound messages from both the old and the new format version. WorkflowVersionPolicy makes this acceptance declaration explicit and compiler-checked.

The engine can use this policy to validate that an incoming message’s format version is acceptable before constructing the command, surfacing the gap at dispatch time rather than during a runtime deserialization error.

Default

The default implementation of Workflow::version_policy() returns WorkflowVersionPolicy::ForwardCompatible, which accepts messages in any format version ≥ the creation FV. This is the correct default for the majority of BDEW MaKo processes, which routinely span annual release boundaries. Override to Pinned only for strictly short-lived workflows that are guaranteed to complete within a single BDEW release cycle.

Example

use mako_engine::version::{FormatVersion, WorkflowVersionPolicy};

// A GPKE process that lives at most 24 hours — pinned to creation FV:
fn version_policy() -> WorkflowVersionPolicy {
    WorkflowVersionPolicy::Pinned
}

// A MABIS billing process that spans the annual release boundary:
fn version_policy() -> WorkflowVersionPolicy {
    WorkflowVersionPolicy::Explicit(vec![
        FormatVersion::new("FV2025-10-01"),
        FormatVersion::new("FV2026-10-01"),
    ])
}

// An open-ended process that accepts all FVs >= creation:
fn version_policy() -> WorkflowVersionPolicy {
    WorkflowVersionPolicy::ForwardCompatible
}

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Pinned

Accept only the format version recorded at process creation.

Use for strictly short-lived workflows that are guaranteed to complete within a single BDEW release cycle (< 6 months). All counterparty messages must arrive before the next October-1 or April-1 FV boundary.

This is a stricter policy than the default ForwardCompatible. Most BDEW market-communication processes span release boundaries; prefer ForwardCompatible unless you have an explicit reason to pin.

ForwardCompatible

Accept any format version greater than or equal to the creation FV.

This is the default (via #[default]) for all MaKo workflows.

MaKo processes routinely span BDEW annual release boundaries: a Lieferbeginn process started on 2025-09-20 must still accept the counterparty’s APERAK reply sent on 2025-11-10 under the new FV2025-10-01 rules. ForwardCompatible handles this transparently.

Explicit(Vec<FormatVersion>)

Accept exactly the listed format versions.

Use when the set of acceptable format versions is known at compile time (e.g. a billing process that must handle exactly FV2025-10-01 and FV2026-10-01).

Implementations

impl WorkflowVersionPolicy

pub fn accepts(&self, fv: &FormatVersion, creation_fv: &FormatVersion) -> bool

Returns true if fv is acceptable under this policy given creation_fv (the format version recorded in the process’s WorkflowId).

Behaviour

Policy	Acceptance
Pinned	fv == creation_fv
ForwardCompatible	always (caller treats any FV as acceptable)
Explicit(list)	fv is in list

Trait Implementations

impl Clone for WorkflowVersionPolicy

fn clone(&self) -> WorkflowVersionPolicy

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for WorkflowVersionPolicy

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

Formats the value using the given formatter.

impl Default for WorkflowVersionPolicy

fn default() -> WorkflowVersionPolicy

Returns the “default value” for a type.

impl Eq for WorkflowVersionPolicy

impl PartialEq for WorkflowVersionPolicy

fn eq(&self, other: &WorkflowVersionPolicy) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for WorkflowVersionPolicy