Struct Path 

pub struct Path {
    pub root: PathRoot,
    pub projection: Projection,
}

A rooted field traversal path through the application schema.

A Path starts at a PathRoot (a model or an enum variant) and navigates through fields via a Projection. It is used by the query engine to identify which field or nested field is being referenced.

Examples

use toasty_core::stmt::Path;
use toasty_core::schema::app::ModelId;

// Path pointing to the root of model 0
let p = Path::model(ModelId::from_index(0));
assert!(p.is_empty()); // no field steps

Fields

root: PathRoot

Where the path originates from.

projection: Projection

Traversal through the fields.

Implementations

impl Path

pub fn model(root: impl Into<ModelId>) -> Path

Creates a path rooted at a model with an identity projection (no field steps).

pub fn field(root: impl Into<ModelId>, field: usize) -> Path

Creates a path rooted at a model that navigates to a single field by index.

pub const fn from_index(root: ModelId, index: usize) -> Path

Creates a path rooted at a model with a single field step (const-compatible).

pub fn from_variant(parent: Path, variant_id: VariantId) -> Path

Creates a path rooted at a specific enum variant.

parent is the path that navigates to the enum field. Subsequent projection steps (appended via chain) index into the variant’s fields using 0-based local indices.

pub fn is_empty(&self) -> bool

Returns true if the path has no field steps (identity projection).

pub fn len(&self) -> usize

Returns the number of field steps in the path.

pub fn chain(&mut self, other: &Path)

Appends all field steps from other onto this path’s projection.

pub fn into_stmt(self) -> Expr

Converts this path into an Expr that references the path’s field.

Trait Implementations

impl Clone for Path

fn clone(&self) -> Path

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Path

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

Formats the value using the given formatter.

impl PartialEq for Path

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