Struct FqlPattern 

pub struct FqlPattern {
    pub scope: PatternSegment,
    pub target: PatternSegment,
    pub child_path: Option<PatternSegment>,
    pub instance: Option<PatternSegment>,
}

A parsed FQL pattern for matching components and children.

Examples

"builtin::llm"        → scope=Exact("builtin"), target=Exact("llm")
"*::*"                 → scope=Wildcard, target=Wildcard
"builtin::llm/agent-1" → + child_path=Exact("agent-1")
"builtin::llm/*"      → + child_path=Wildcard

Fields

scope: PatternSegment

Namespace scope (e.g., “builtin”, “plugin”, “*”).

target: PatternSegment

Component name (e.g., “llm”, “hil”, “*”).

child_path: Option<PatternSegment>

Optional child path (e.g., “agent-1”, “*”).

instance: Option<PatternSegment>

Optional instance qualifier (e.g., “primary”, “0”).

Implementations

impl FqlPattern

pub fn parse(fql: &str) -> Result<Self, HookError>

Parses an FQL pattern string.

Format

<scope>::<target>[/<child_path>][#<instance>]

Errors

Returns HookError::InvalidFql if the string cannot be parsed.

pub fn matches( &self, component_id: &ComponentId, child_id: Option<&str>, ) -> bool

Returns true if this pattern matches the given component and optional child.

Matches against component_id.fqn() which returns "namespace::name".

Trait Implementations

impl Clone for FqlPattern

fn clone(&self) -> FqlPattern

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FqlPattern

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for FqlPattern

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for FqlPattern

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

Formats the value using the given formatter.

impl PartialEq for FqlPattern

fn eq(&self, other: &FqlPattern) -> 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 Serialize for FqlPattern

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for FqlPattern

impl StructuralPartialEq for FqlPattern