Struct DirChildren

Source

pub struct DirChildren<T, F: Filter = NoFilter>where
    T: DirStructureItem,{
    pub self_path: PathBuf,
    pub children: Vec<DirChild<T>>,
    /* private fields */
}

Expand description

A directory structure where we don’t know the names of the folders at compile-time, and as such we cannot use the derive macro.

Instead we know that all the entries in the directory are folders, and that they all have the same structure inside (defined by the T type parameter), or they are all files (which can be read with DirChildren<String> for example).

In either case, ReadFrom::read_from must be able to read all the entries in the directory.

The WriteTo implementation will directly write the children to the directory it is passed, with no regards to the path stored in self_path.

Fields§

§self_path: PathBuf

The path to the root directory.

This path doesn’t influence writing in any way, it is only to point out the directory after it has been read and parsed.

§children: Vec<DirChild<T>>

The children of the root directory.

Implementations§

Source §

impl<T, F> DirChildren<T, F>
where T: DirStructureItem, F: Filter,

Source

pub fn new() -> Self

Creates an empty DirChildren, with no children.

Source

pub fn with_children_from_iter( self_path: impl Into<PathBuf>, children: impl IntoIterator<Item = DirChild<T>>, ) -> Self

Creates a DirChildren with the given path and children.

Source

pub fn map<U, MapF>(self, f: MapF) -> DirChildren<U, F>
where MapF: FnMut(DirChild<T>) -> DirChild, U: DirStructureItem,

Maps the children of this DirChildren to a new type.

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

This is a convenience method that allows you to use the map method on the children of this DirChildren.

§Examples

use std::path::Path;
use std::path::PathBuf;
use dir_structure::{DirStructure, DirStructureItem, DirChildren, DirChild, ReadFrom, WriteTo};

#[derive(Debug, PartialEq, Eq)]
struct NewType(String);

impl ReadFrom for NewType {
    fn read_from(path: &Path) -> dir_structure::Result<Self> {
        String::read_from(path).map(Self)
    }
}

impl WriteTo for NewType {
    fn write_to(&self, path: &Path) -> dir_structure::Result<()> {
        self.0.write_to(path)
    }
}

let d = PathBuf::from("dir");
let dir = DirChildren::<_, dir_structure::NoFilter>::with_children_from_iter(
    d.clone(),
    vec![
        DirChild::new("file1.txt", "file1".to_owned()),
        DirChild::new("file2.txt", "file2".to_owned()),
        DirChild::new("file3.txt", "file3".to_owned()),
    ],
);
let dir = dir.map(|child| child.map_value(NewType));
assert_eq!(
    dir,
    DirChildren::with_children_from_iter(
        d.clone(),
        vec![
            DirChild::new("file1.txt", NewType("file1".to_owned())),
            DirChild::new("file2.txt", NewType("file2".to_owned())),
            DirChild::new("file3.txt", NewType("file3".to_owned())),
        ],
    )
);

Source

pub fn map_filter<NewF>(self) -> DirChildren<T, NewF>
where NewF: Filter,

Maps the filter type. The children remain unchanged.

This is useful if you are trying to pass a DirChildren<T, F1> to a function requiring a DirChildren<T, F2>, where F1 and F2 are two distinct types implementing Filter.

§Examples

use std::path::Path;
use dir_structure::{Filter, DirChildren};

struct NewFilter;

impl Filter for NewFilter {
    fn make_filter() -> Self {
        Self
    }

    fn allows(&self, _path: &Path) -> bool {
        true
    }
}

let d = DirChildren::<String, dir_structure::NoFilter>::new();
let d2: DirChildren<String, NewFilter> = d.map_filter::<NewFilter>();

Source

pub fn len(&self) -> usize

Returns the number of children.

§Examples

use std::path::{Path, PathBuf};
use dir_structure::{DirStructure, DirStructureItem, DirChildren, DirChild};

let d = DirChildren::<String, dir_structure::NoFilter>::new();
assert_eq!(d.len(), 0);

let d = DirChildren::<String, dir_structure::NoFilter>::with_children_from_iter(
    PathBuf::new(),
    vec![
        DirChild::new("file1.txt", "file1".to_owned()),
        DirChild::new("file2.txt", "file2".to_owned()),
    ],
);
assert_eq!(d.len(), 2);

Source

pub fn get(&self, index: usize) -> Option<&DirChild<T>>

Gets the child at the specified index.

§Examples

use std::path::{Path, PathBuf};
use dir_structure::{DirStructure, DirStructureItem, DirChildren, DirChild};

let d = DirChildren::<String, dir_structure::NoFilter>::new();
assert_eq!(d.get(0), None);
assert_eq!(d.get(1), None);
assert_eq!(d.get(100), None);

let d = DirChildren::<String, dir_structure::NoFilter>::with_children_from_iter(
    PathBuf::new(),
    vec![
        DirChild::new("file1.txt", "file1".to_owned()),
        DirChild::new("file2.txt", "file2".to_owned()),
    ],
);
assert_eq!(d.get(0), Some(&DirChild::new("file1.txt", "file1".to_owned())));
assert_eq!(d.get(1), Some(&DirChild::new("file2.txt", "file2".to_owned())));
assert_eq!(d.get(2), None);
assert_eq!(d.get(100), None);

Source

pub fn get_name(&self, name: impl AsRef<OsStr>) -> Option<&DirChild<T>>

Gets the child with the specified “file” name (last segment of path).

§Examples

use std::path::{Path, PathBuf};
use dir_structure::{DirStructure, DirStructureItem, DirChildren, DirChild};

let d = DirChildren::<String, dir_structure::NoFilter>::new();
assert_eq!(d.get_name(""), None);
assert_eq!(d.get_name("any_name"), None);
assert_eq!(d.get_name("aaaa"), None);

let d = DirChildren::<String, dir_structure::NoFilter>::with_children_from_iter(
    PathBuf::new(),
    vec![
        DirChild::new("file1.txt", "file1".to_owned()),
        DirChild::new("file2.txt", "file2".to_owned()),
    ],
);
assert_eq!(d.get_name("file1.txt"), Some(&DirChild::new("file1.txt", "file1".to_owned())));
assert_eq!(d.get_name("file2.txt"), Some(&DirChild::new("file2.txt", "file2".to_owned())));
assert_eq!(d.get_name("any_name"), None);
assert_eq!(d.get_name("aaaa"), None);

Source

pub fn get_value_by_name(&self, name: impl AsRef<OsStr>) -> Option<&T>

Gets the value of the child with the specified “file” name (last segment of path).

§Examples

use std::path::{Path, PathBuf};
use dir_structure::{DirStructure, DirStructureItem, DirChildren, DirChild};

let d = DirChildren::<String, dir_structure::NoFilter>::new();
assert_eq!(d.get_value_by_name(""), None);
assert_eq!(d.get_value_by_name("any_name"), None);
assert_eq!(d.get_value_by_name("aaaa"), None);

let d = DirChildren::<String, dir_structure::NoFilter>::with_children_from_iter(
    PathBuf::new(),
    vec![
        DirChild::new("file1.txt", "file1".to_owned()),
        DirChild::new("file2.txt", "file2".to_owned()),
    ],
);
assert_eq!(d.get_value_by_name("file1.txt"), Some(&"file1".to_owned()));
assert_eq!(d.get_value_by_name("file2.txt"), Some(&"file2".to_owned()));
assert_eq!(d.get_value_by_name("any_name"), None);
assert_eq!(d.get_value_by_name("aaaa"), None);

Source

pub fn iter(&self) -> DirChildrenIter<'_, T> ⓘ

Returns an iterator over the children.

§Examples

use std::path::{Path, PathBuf};
use dir_structure::{DirStructure, DirStructureItem, DirChildren, DirChild};

let d = DirChildren::<String, dir_structure::NoFilter>::new();
let mut i = d.iter();
assert_eq!(i.next(), None);

let d = DirChildren::<String, dir_structure::NoFilter>::with_children_from_iter(
    PathBuf::new(),
    vec![
        DirChild::new("file1.txt", "file1".to_owned()),
        DirChild::new("file2.txt", "file2".to_owned()),
    ],
);
let mut i = d.iter();
assert_eq!(i.next(), Some(&DirChild::new("file1.txt", "file1".to_owned())));
assert_eq!(i.next(), Some(&DirChild::new("file2.txt", "file2".to_owned())));
assert_eq!(i.next(), None);