Struct Path

pub struct Path<'a, 'b> { /* private fields */ }

A Path can be used to represent a path.

A path is a sequence of parts that are joined together by a joiner. The joiner is a string that is used to split the path into parts and into a PathBuf.

Example

use postcard_bindgen_core::path::Path;

let path = Path::new("foo/bar/baz", "/");

assert_eq!(path.parts().collect::<Vec<&str>>(), vec!["foo", "bar", "baz"]);

Implementations

impl<'a, 'b> Path<'a, 'b>

pub fn new( path: impl Into<FullPath<'a>>, joiner: impl Into<Cow<'b, str>>, ) -> Self

Create a new path from something which can be converted into a FullPath and a joiner which is either str or String.

pub fn parts(&self) -> impl Iterator<Item = &str>

Gives an iterator over the parts of the path.

pub fn flatten(&mut self)

Flatten the path to the root by simply removing all parts.

pub fn into_buf(self) -> PathBuf<'a>

Convert the path into a PathBuf by consuming the path and splitting it into parts.

pub fn is_empty(&self) -> bool

Check if the path is empty.

pub fn into_owned(self) -> Path<'static, 'static>

Convert the path into an owned path by consuming the path.

Trait Implementations

impl<'a, 'b> Clone for Path<'a, 'b>

fn clone(&self) -> Path<'a, 'b>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, 'b> Debug for Path<'a, 'b>

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

Formats the value using the given formatter.

impl Display for Path<'_, '_>

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

Formats the value using the given formatter.

impl<L: Lang> FormatInto<L> for Path<'_, '_>

fn format_into(self, t: &mut Tokens<L>)

Convert the type into tokens in-place.

impl<'a, 'b> From<Path<'a, 'b>> for String

fn from(value: Path<'a, 'b>) -> Self

Converts to this type from the input type.

impl<'a, 'b> PartialEq for Path<'a, 'b>

fn eq(&self, other: &Path<'a, 'b>) -> 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<'a, 'b> Eq for Path<'a, 'b>

impl<'a, 'b> StructuralPartialEq for Path<'a, 'b>