Struct ProbingSolver 

pub struct ProbingSolver<'a> { /* private fields */ }

Depth-aware probing solver for streaming deserialization.

Unlike the batch solver, this solver accepts key reports at arbitrary depths. It’s designed for the “peek” strategy:

1. Deserializer scans keys (without parsing values) and reports them
2. Solver filters candidates based on which configs have that key path
3. Once one candidate remains, solver returns Solved
4. Deserializer rewinds and parses into the resolved type

Example

use facet::Facet;
use facet_solver::{Schema, ProbingSolver, ProbeResult};

#[derive(Facet)]
struct TextPayload { content: String }

#[derive(Facet)]
struct BinaryPayload { bytes: Vec<u8> }

#[derive(Facet)]
#[repr(u8)]
enum MessageKind {
    Text { payload: TextPayload },
    Binary { payload: BinaryPayload },
}

#[derive(Facet)]
struct Message {
    id: String,
    #[facet(flatten)]
    kind: MessageKind,
}

let schema = Schema::build(Message::SHAPE).unwrap();
let mut solver = ProbingSolver::new(&schema);

// "id" exists in both configs - keep going
assert!(matches!(solver.probe_key(&[], "id"), ProbeResult::KeepGoing));

// "payload" exists in both configs - keep going
assert!(matches!(solver.probe_key(&[], "payload"), ProbeResult::KeepGoing));

// "content" inside payload only exists in Text - solved!
match solver.probe_key(&["payload"], "content") {
    ProbeResult::Solved(config) => {
        assert!(config.has_key_path(&["payload", "content"]));
    }
    _ => panic!("expected Solved"),
}

Implementations

impl<'a> ProbingSolver<'a>

pub fn new(schema: &'a Schema) -> Self

Create a new probing solver from a schema.

pub fn from_resolutions(configs: &'a [Resolution]) -> Self

Create a new probing solver from resolutions directly.

pub fn probe_key(&mut self, path: &[&str], key: &str) -> ProbeResult<'a>

Report a key found at a path during probing.

• path: The ancestor keys (e.g., ["payload"] when inside the payload object)
• key: The key found at this level (e.g., "content")

Returns what to do next.

pub fn candidates(&self) -> &[&'a Resolution]

Get the current candidate resolutions.

pub fn finish(&self) -> ProbeResult<'a>

Finish probing - returns Solved if exactly one candidate remains.

Trait Implementations

impl<'a> Debug for ProbingSolver<'a>

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

Formats the value using the given formatter.