Struct Guarded 

pub struct Guarded<T> { /* private fields */ }

A value that requires a WriteToken for mutable access.

Read access via .read() is always available. Write access via .write(token) requires a WriteToken proving the caller has the capability.

The framework issues write tokens only to plugins that declared the corresponding write capability (e.g., write_headers). Plugin code without a token cannot call .write().

Implementations

impl<T> Guarded<T>

pub fn new(value: T) -> Self

Wrap a value in a guard.

pub fn read(&self) -> &T

Read access — always available if the plugin can see this extension.

pub fn write(&mut self, _token: &WriteToken) -> &mut T

Write access — requires a WriteToken proving the caller has capability.

The framework issues WriteTokens only to plugins that declared the write capability in their config. Without the token, this method is uncallable — the plugin can read but not write.

Examples found in repository

examples/cmf_capabilities_demo.rs (line 177)

    async fn handle(
        &self,
        _payload: &MessagePayload,
        extensions: &Extensions,
        _ctx: &mut PluginContext,
    ) -> PluginResult<MessagePayload> {
        // Can see HTTP (has read_headers)
        if let Some(ref http) = extensions.http {
            println!(
                "  [header-injector] HTTP headers visible: {:?}",
                http.request_headers
            );
        }

        // Can NOT see security subject (no read_subject)
        if let Some(ref security) = extensions.security {
            if security.subject.is_some() {
                println!("  [header-injector] WARNING: Subject visible (unexpected!)");
            } else {
                println!("  [header-injector] Security subject: not visible (no read_subject)");
            }
        }

        // COW copy to modify — tokens propagate from the executor
        let mut modified = extensions.cow_copy();

        // Add a label via MonotonicSet (has append_labels)
        if modified.labels_write_token.is_some() {
            modified.security.as_mut().unwrap().add_label("PROCESSED");
            println!("  [header-injector] Added label 'PROCESSED'");
        }

        // Inject a header via Guarded (has write_headers)
        if let Some(ref token) = modified.http_write_token {
            modified
                .http
                .as_mut()
                .unwrap()
                .write(token)
                .set_header("X-Processed-By", "header-injector");
            println!("  [header-injector] Injected header 'X-Processed-By'");
        }

        PluginResult::modify_extensions(modified)
    }

pub fn into_inner(self) -> T

Consume the guard, returning the inner value.

Trait Implementations

impl<T: Clone> Clone for Guarded<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Guarded<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for Guarded<T>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for Guarded<T>

where T: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Serialize for Guarded<T>

where T: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.