Enum FenceKind 

pub enum FenceKind {
    Adapter,
    Memory,
    Policy,
    Injection,
    Provider,
    Cache,
    Trajectory,
    Agent,
    Intent,
    Tool,
    Rag,
    Json,
    Xml,
    Constraints,
    Tools,
    Manifest,
    Flow,
}

Supported fence block types (single source of truth)

Variants

Adapter

Memory

Policy

Injection

Provider

Cache

Trajectory

Agent

Intent

Tool

Rag

Json

Xml

Constraints

Tools

Manifest

Flow

Trait Implementations

impl Clone for FenceKind

fn clone(&self) -> FenceKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FenceKind

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

Formats the value using the given formatter.

impl Display for FenceKind

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

Formats the FenceKind as its lowercase string representation.

Examples

use cellstate_pipeline::pack::FenceKind;
assert_eq!(format!("{}", FenceKind::Adapter), "adapter");
assert_eq!(format!("{}", FenceKind::Json), "json");
assert_eq!(format!("{}", FenceKind::Constraints), "constraints");

impl FromStr for FenceKind

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a fence kind identifier into a FenceKind.

Matching is case-insensitive. Recognized identifiers: "adapter", "memory", "policy", "injection", "provider", "cache", "trajectory", "agent", "tool", "rag", "json", "xml", "constraints", "tools", and "manifest".

Returns

Ok(FenceKind) for a recognized identifier, Err(PackError::Validation) for unsupported input.

Examples

use std::str::FromStr;
use cellstate_pipeline::pack::FenceKind;
let k = FenceKind::from_str("tool").unwrap();
assert_eq!(k, FenceKind::Tool);

type Err = PackError

The associated error which can be returned from parsing.

impl Hash for FenceKind

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for FenceKind

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

impl Eq for FenceKind

impl StructuralPartialEq for FenceKind