Struct parallel_disk_usage::data_tree::reflection::Reflection

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

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

Unlike Tree where the fields are all private, the fields of TreeReflection 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.

data: Data

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

children: Vec<Self>

Data of children filesystem subtrees.

Implementations

impl<Name, Data> Reflection<Name, Data>

where Name: Send, Data: Size + Send,

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

Attempting to convert a Reflection into a valid DataTree.

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

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

Attempt to transform names and data.

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

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

Attempt to convert all names from OsString to String.

Trait Implementations

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

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

where Name: Deserialize<'de>, Data: 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, Data: Size> From<DataTree<Name, Data>> for Reflection<Name, Data>

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

Converts to this type from the input type.

impl From<Reflection<String, Blocks>> for UnitAndTree

fn from(original: Reflection<String, Blocks>) -> UnitAndTree

Converts to this type from the input type.

impl From<Reflection<String, Bytes>> for UnitAndTree

fn from(original: Reflection<String, Bytes>) -> UnitAndTree

Converts to this type from the input type.

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

fn eq(&self, other: &Reflection<Name, Data>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Name, Data> Serialize for Reflection<Name, Data>

where Name: Serialize, Data: 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 TryFrom<UnitAndTree> for Reflection<String, Blocks>

type Error = &'static str

The type returned in the event of a conversion error.

fn try_from(value: UnitAndTree) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<UnitAndTree> for Reflection<String, Bytes>

type Error = &'static str

The type returned in the event of a conversion error.

fn try_from(value: UnitAndTree) -> Result<Self, Self::Error>

Performs the conversion.

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

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