Struct CompiledRoute 

pub struct CompiledRoute {
    pub route_key: String,
    pub args: Vec<FieldRule>,
    pub policy: Vec<Effect>,
    pub result: Vec<FieldRule>,
    pub post_policy: Vec<Effect>,
    pub plugin_overrides: HashMap<String, PluginOverride>,
}

Compiler output for a single route.

One CompiledRoute per route_key. The compiler merges global / default / tag / route-specific rules from the config hierarchy down into these four phase lists before the evaluator sees them — the IR has no notion of “tag rules” or “route overrides,” only “steps that fire in phase P.”

args and result are per-field pipelines (validators + transforms). policy and post_policy are step lists — predicate-and-action rules plus PDP calls, plugin invocations, and taint effects. See apl-dsl-spec §1.2 / §4 / §7.

Fields

route_key: String

args: Vec<FieldRule>

policy: Vec<Effect>

result: Vec<FieldRule>

post_policy: Vec<Effect>

plugin_overrides: HashMap<String, PluginOverride>

Per-plugin overrides declared on this route’s plugins: block. Keyed by plugin name; merged at dispatch time via EffectivePlugin::resolve(name, registry, &this.plugin_overrides). Per spec only config, capabilities, on_error are overridable; hooks/kind/source always come from the global declaration.

Implementations

impl CompiledRoute

pub fn new(route_key: impl Into<String>) -> Self

pub fn declared_phases(&self) -> PhaseSet

Which phases this route uses. Empty phases are not declared.

pub fn apply_layer(&mut self, more_specific: CompiledRoute)

Apply a more-specific policy layer on top of this one. Used by orchestrators (apl-cpex’s visitor) to stack the unified-config hierarchy least-to-most-specific:

effective = CompiledRoute::default()
effective.apply_layer(global_block)
effective.apply_layer(default_block)
effective.apply_layer(tag_block)
effective.apply_layer(route_block)

Each call adds the parameter on top of what’s already there; more_specific wins on collisions because it represents a later/narrower layer in the inheritance chain.

Merge semantics:

• policy / post_policy: more_specific’s steps append after self’s. Earlier layers run first — globals deny before route-specific rules get a chance.
• args / result: per-field; if both layers declare the same field, more_specific’s rule replaces self’s. Fields only in self stay; fields only in more_specific are added.
• plugin_overrides: HashMap merge; more_specific wins on key collisions, otherwise prefix’s entries fill gaps.

self.route_key is preserved — apply_layer doesn’t overwrite identity, just policy content.

Trait Implementations

impl Clone for CompiledRoute

fn clone(&self) -> CompiledRoute

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CompiledRoute

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

Formats the value using the given formatter.

impl Default for CompiledRoute

fn default() -> CompiledRoute

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for CompiledRoute

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for CompiledRoute

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

where __S: Serializer,

Serialize this value into the given Serde serializer.