Struct DirChild 

pub struct DirChild<T, P: PathType + ?Sized = Path> { /* private fields */ }

A single child of a DirChildren structure.

Implementations

impl<T, P: PathType + ?Sized> DirChild<T, P>

pub fn new(file_name: impl Into<P::PathSegmentOwned>, value: T) -> Self

Creates a new DirChild with the specified file name and value.

Examples

use std::ffi::OsString;
use std::path::Path;
use dir_structure::dir_children::DirChild;

let d = DirChild::<_, Path>::new("file.txt".to_owned(), "file".to_owned());
assert_eq!(d.file_name(), &OsString::from("file.txt"));
assert_eq!(d.value(), &"file".to_owned());

pub fn file_name(&self) -> &P::PathSegmentOwned

Gets the file name of the child (or the name of the directory; the last segment in the path).

Examples

use std::ffi::OsString;
use std::path::Path;
use dir_structure::dir_children::DirChild;

let d = DirChild::<_, Path>::new("file.txt".to_owned(), "file".to_owned());
assert_eq!(d.file_name(), &OsString::from("file.txt"));

pub fn file_name_mut(&mut self) -> &mut P::PathSegmentOwned

Gets the file name of the child (or the name of the directory; the last segment in the path).

Mutable reference version of Self::file_name.

Examples

use std::ffi::OsString;
use std::path::Path;
use dir_structure::dir_children::DirChild;

let mut d = DirChild::<_, Path>::new("file.txt".to_owned(), "file".to_owned());
assert_eq!(d.file_name(), &OsString::from("file.txt"));
*d.file_name_mut() = OsString::from("new_file.txt");
assert_eq!(d.file_name(), &OsString::from("new_file.txt"));

pub fn value(&self) -> &T

Gets the value of the child.

This is the parsed value of the file / directory.

Examples

use std::ffi::OsString;
use std::path::Path;
use dir_structure::dir_children::DirChild;

let d = DirChild::<_, Path>::new("file.txt".to_owned(), "file".to_owned());
assert_eq!(d.value(), &"file".to_owned());

pub fn value_mut(&mut self) -> &mut T

Gets the value of the child.

This is the parsed value of the file / directory.

Mutable reference version of Self::value.

Examples

use std::ffi::OsString;
use std::path::Path;
use dir_structure::dir_children::DirChild;

let mut d = DirChild::<_, Path>::new("file.txt".to_owned(), "file".to_owned());
assert_eq!(d.value(), &"file".to_owned());
*d.value_mut() = "new_file".to_owned();
assert_eq!(d.value(), &"new_file".to_owned());

pub fn map_file_name<F, O>(self, f: F) -> Self

where F: FnOnce(P::PathSegmentOwned) -> O, O: Into<P::PathSegmentOwned>,

Maps the file name of this DirChild to a new value.

Examples

use std::ffi::OsString;
use std::path::Path;
use dir_structure::dir_children::DirChild;

let d = DirChild::<_, Path>::new("file.txt".to_owned(), "file".to_owned());
assert_eq!(d.map_file_name(|s| s.to_str().unwrap().to_uppercase()), DirChild::new("FILE.TXT", "file".to_owned()));

pub fn map_value<U, F>(self, f: F) -> DirChild<U, P>

where F: FnOnce(T) -> U,

Maps the value of this DirChild to a new type.

This is useful for converting the value to a different type, for example, if you want to convert the value to a different type of DirStructureItem.

Examples

use std::ffi::OsString;
use std::path::Path;
use dir_structure::dir_children::DirChild;
use dir_structure::std_types::FileString;

let d = DirChild::<_, Path>::new("file.txt".to_owned(), "file".to_owned());
assert_eq!(d.map_value(|v| FileString(v)), DirChild::new("file.txt".to_owned(), FileString("file".to_owned())));

Trait Implementations

impl<T, P: PathType + ?Sized> AssertEq for DirChild<T, P>

where for<'__trivial> P::PathSegmentOwned: AssertEq<P::PathSegmentOwned> + Debug, for<'__trivial> T: AssertEq<T> + Debug,

fn assert_eq( &self, other: &Self, path: &mut AssertPath, init_left: &impl Display, init_right: &impl Display, )

Asserts that self is equal to other, panicking if they are not equal.

impl<T, P: PathType + ?Sized> Clone for DirChild<T, P>

where T: Clone, P::PathSegmentOwned: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, P: PathType + ?Sized> Debug for DirChild<T, P>

where T: Debug, P::PathSegmentOwned: Debug,

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

Formats the value using the given formatter.

impl<T, P: PathType + ?Sized> Deref for DirChild<T, P>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T, P: PathType + ?Sized> DerefMut for DirChild<T, P>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T, P: PathType + ?Sized, F> Extend<DirChild<T, P>> for DirChildren<T, F, P>

where F: Filter<P>,

fn extend<I: IntoIterator<Item = DirChild<T, P>>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<T, P: PathType + ?Sized, F> FromIterator<DirChild<T, P>> for DirChildren<T, F, P>

where F: Filter<P>,

fn from_iter<I: IntoIterator<Item = DirChild<T, P>>>(iter: I) -> Self

Creates a value from an iterator.

impl<T, F, P: PathType + ?Sized> FromIterator<DirChild<T, P>> for ForceCreateDirChildren<T, F, P>

where F: Filter<P>,

fn from_iter<I: IntoIterator<Item = DirChild<T, P>>>(iter: I) -> Self

Creates a value from an iterator.

impl<T: PartialEq, P: PartialEq + PathType + ?Sized> PartialEq for DirChild<T, P>

where P::PathSegmentOwned: PartialEq,

fn eq(&self, other: &DirChild<T, P>) -> 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<T: Eq, P: Eq + PathType + ?Sized> Eq for DirChild<T, P>

where P::PathSegmentOwned: Eq,

impl<T, P: PathType + ?Sized> StructuralPartialEq for DirChild<T, P>