Struct Reflection 

pub struct Reflection<Name, Size: Size> {
    pub name: Name,
    pub size: Size,
    pub children: Vec<Self>,
}

Intermediate format used for construction and inspection of DataTree’s internal content.

Unlike DataTree where the fields are all private, the fields of Reflection are all public to allow construction in tests.

Conversion between DataTree and Reflection:

• Any DataTree can be safely transmuted to a valid Reflection.
• Any Reflection can be safely transmuted to a potentially invalid DataTree.
• To safely convert a DataTree into a Reflection without the unsafe keyword, use DataTree::into_reflection (it would be slower than using transmute).
• To safely convert a Reflection into a valid DataTree, use par_try_into_tree.

Serialization and deserialization: (feature: json) Reflection implements Serialize and Deserialize traits, this allows functions in serde_json to convert a Reflection into/from JSON.

Fields

name: Name

Name of the tree.

size: Size

Disk usage of a file or total disk usage of a folder.

children: Vec<Self>

Data of children filesystem subtrees.

Implementations

impl<Name, Size> Reflection<Name, Size>

where Name: Send, Size: Size + Send,

pub fn par_try_into_tree( self, ) -> Result<DataTree<Name, Size>, ConversionError<Name, Size>>

Attempting to convert a Reflection into a valid DataTree.

pub fn par_try_map<TargetName, TargetSize, Error, Transform>( self, transform: Transform, ) -> Result<Reflection<TargetName, TargetSize>, Error>

where TargetName: Send, TargetSize: Size + Send + Sync, Error: Send, Transform: Fn(Name, Size) -> Result<(TargetName, TargetSize), Error> + Copy + Sync,

Attempt to transform names and sizes.

pub fn par_convert_names_to_utf8(self) -> Result<Reflection<String, Size>, Name>

where Name: AsRef<OsStr>, Size: Sync,

Attempt to convert all names from OsString to String.

Trait Implementations

impl<Name: Clone, Size: Clone + Size> Clone for Reflection<Name, Size>

fn clone(&self) -> Reflection<Name, Size>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Name: Debug, Size: Debug + Size> Debug for Reflection<Name, Size>

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

Formats the value using the given formatter.

impl<'de, Name, Size> Deserialize<'de> for Reflection<Name, Size>

where Name: Deserialize<'de>, Size: Deserialize<'de> + Size,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<Name, Size: Size> From<DataTree<Name, Size>> for Reflection<Name, Size>

fn from(source: DataTree<Name, Size>) -> Self

Converts to this type from the input type.

impl<Name: PartialEq, Size: PartialEq + Size> PartialEq for Reflection<Name, Size>

fn eq(&self, other: &Reflection<Name, Size>) -> 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<Name, Size> Serialize for Reflection<Name, Size>

where Name: Serialize, Size: Serialize + Size,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<Name: Eq, Size: Eq + Size> Eq for Reflection<Name, Size>

impl<Name, Size: Size> StructuralPartialEq for Reflection<Name, Size>