Struct Props

pub struct Props { /* private fields */ }

This struct is the one that gives you the desired behaviour.

It implements the following traits:

1. Display for Props
2. From for Props
3. From for u32
4. TryFrom for Props
5. TryFrom<&Pathbuf> for Props
6. TryFrom<&str> for Props
   (The TryFrom ones won’t appear in the documentation because they use Windows specific behaviour and it is put behind a conditional flag because docs.rs only uses a Linux container)

Implementations

impl Props

pub fn is_read_only(&self) -> Result<bool>

Returns true if the element is read_only. Not available on folders.

use keypropdecode::props::*;
let mut props = Props::default();
props.change_element_type(ArcDir::Archive(ArchiveProps::default()));
props.read_only(true).unwrap();

assert_eq!(props.is_read_only(), Ok(true));

pub fn read_only(&mut self, read_only: bool) -> Result<()>

Allows to change the read_only state. Not available on folder.

pub fn is_hidden(&self) -> bool

Returns true if the element is hidden.

use keypropdecode::props::*;
let mut props = Props::default();
props.hidden(true);

assert_eq!(props.is_hidden(), true);

pub fn hidden(&mut self, hidden: bool)

Allows to change the hidden state.

pub fn is_system(&self) -> bool

Returns true if the element is used for system purposes.

use keypropdecode::props::*;
let mut props = Props::from(0x4);

assert_eq!(props.is_system(), true);

pub fn is_archive(&self) -> bool

Returns true if the element is a file.

use keypropdecode::props::*;
let mut props = Props::default();
props.change_element_type(ArcDir::Archive(ArchiveProps::default()));

assert_eq!(props.is_archive(), true);

pub fn is_directory(&self) -> bool

Returns true if the element is a folder.

use keypropdecode::props::*;
let mut props = Props::default();
props.change_element_type(ArcDir::Directory);

assert_eq!(props.is_directory(), true);

pub fn change_element_type(&mut self, element_type: ArcDir)

Allows to change the state archive state. You give the enum with the properties neccesary, no error checking neccesary.

pub fn is_device(&self) -> bool

Returns true if the element represents a physical device in the file system. Reserved for system use

use keypropdecode::props::*;
let mut props = Props::from(0x40);

assert_eq!(props.is_device(), true);

pub fn is_normal(&self) -> Result<bool>

Returns true if the element represents a normal file (a file that doesn’t have any properties except being a file(check docs for more info)).

use keypropdecode::props::*;
let mut props = Props::default();
props.change_element_type(ArcDir::Archive(ArchiveProps::default()));
props.normal(true);

assert_eq!(props.is_normal(), Ok(true));

pub fn normal(&mut self, normal: bool) -> Result<()>

Allows to change the normal state.

pub fn is_temporary(&self) -> Result<bool>

Returns true if the element represents a temporary file.

use keypropdecode::props::*;
let mut props = Props::default();
props.change_element_type(ArcDir::Archive(ArchiveProps::default()));
props.temporary(true).unwrap();

assert_eq!(props.is_temporary(), Ok(true));

pub fn temporary(&mut self, temporary: bool) -> Result<()>

Allows to change the temporary state

pub fn is_sparse(&self) -> Result<bool>

Returns true if the element represents a sparse file (made small for space saving purposes).

use keypropdecode::props::*;
let mut props = Props::default();
props.change_element_type(ArcDir::Archive(ArchiveProps::default()));
props.sparse(true).unwrap();

assert_eq!(props.is_sparse(), Ok(true));

pub fn sparse(&mut self, sparse: bool) -> Result<()>

Allows to change the sparse state.

pub fn is_reparse(&self) -> bool

Returns true if the element represents a reparse point in the file system (e.g. a symbolic link).

use keypropdecode::props::*;
let mut props = Props::default();
props.reparse(true);

assert_eq!(props.is_reparse(), true);

pub fn reparse(&mut self, reparse: bool)

Allows to change the reparse state.

pub fn is_compressed(&self) -> bool

Returns true if the element represents a compressed file

use keypropdecode::props::*;
let mut props = Props::default();
props.compressed(true);

assert_eq!(props.is_compressed(), true);

pub fn compressed(&mut self, compressed: bool)

Allows to change the compressed state

pub fn is_offline(&self) -> Result<bool>

Returns true if the element is not available inmediately. Aplications should not change this value in an arbitrary way.

use keypropdecode::props::*;
let mut props = Props::default();
props.change_element_type(ArcDir::Archive(ArchiveProps::default()));
props.offline(true).unwrap();

assert_eq!(props.is_offline(), Ok(true));

pub fn offline(&mut self, offline: bool) -> Result<()>

Allows to change the offline state

pub fn is_not_content_indexed(&self) -> bool

Returns true if the element isn’t indexed by the content indexing service

use keypropdecode::props::*;
let mut props = Props::default();
props.not_content_indexed(true);

assert_eq!(props.is_not_content_indexed(), true);

pub fn not_content_indexed(&mut self, not_content_indexed: bool)

Allows to change the not_content_indexed state

pub fn is_encrypted(&self) -> bool

Returns true if the element is encrypted

use keypropdecode::props::*;
let mut props = Props::default();
props.encrypted(true);

assert_eq!(props.is_encrypted(), true);

pub fn encrypted(&mut self, encrypted: bool)

Allows to change the encrypted state

pub fn is_integrity_stream(&self) -> bool

Returns true if the directory or user data stream is configured with integrity

use keypropdecode::props::*;
let mut props = Props::default();
props.integrity_stream(true);

assert_eq!(props.is_integrity_stream(), true);

pub fn integrity_stream(&mut self, integrity_stream: bool)

Allows to change the integrity_stream state

pub fn is_virtual_file(&self) -> bool

Returns true if the element is a virtual file. This value is reserver for system use

use keypropdecode::props::*;
let mut props = Props::from(0x10000);

assert_eq!(props.is_virtual_file(), true);

pub fn is_no_scrub_data(&self) -> bool

Returns true if the user data stream not to be read by the background data integrity scanner (AKA scrubber)

use keypropdecode::props::*;
let mut props = Props::default();
props.no_scrub_data(true);

assert_eq!(props.is_no_scrub_data(), true);

pub fn no_scrub_data(&mut self, no_scrub_data: bool)

Allows to change the virtual_file state

pub fn is_extended_attributes(&self) -> bool

Returns true if the element has got extended attributes. System internal use only.

use keypropdecode::props::*;
let mut props = Props::from(0x40000);

assert_eq!(props.is_extended_attributes(), true);

pub fn is_pinned(&self) -> bool

Returns true if the element is indicated user intent that the file or directory should be kept fully present locally even when not being actively accessed.

use keypropdecode::props::*;
let mut props = Props::default();
props.pinned(true);

assert_eq!(props.is_pinned(), true);

pub fn pinned(&mut self, pinned: bool)

Allows to change the pinned state

pub fn is_unpinned(&self) -> bool

Returns true if the element is indicated user intent that the file or directory shouldn’t be kept fully present locally except when being actively accessed.

use keypropdecode::props::*;
let mut props = Props::default();
props.unpinned(true);

assert_eq!(props.is_unpinned(), true);

pub fn unpinned(&mut self, unpinned: bool)

Allows to change the unpinned state

pub fn is_recall_on_open(&self) -> bool

Returns true if the element hasn’t got any physical representation on the local system; the item is vitual. Opening the item will be more expensive than normal, e.g., a file in a remote storage

use keypropdecode::props::*;
let mut props = Props::default();
props.recall_on_open(true);

assert_eq!(props.is_recall_on_open(), true);

pub fn recall_on_open(&mut self, recall_on_open: bool)

Allows to change the recall_on_open state

pub fn is_recall_on_data_access(&self) -> bool

Returns true if the element isn’t fully present locally.

use keypropdecode::props::*;
let mut props = Props::default();
props.recall_on_data_access(true);

assert_eq!(props.is_recall_on_data_access(), true);

pub fn recall_on_data_access(&mut self, recall_on_data_access: bool)

Allows to change the recall_on_data_access state

Trait Implementations

impl Clone for Props

fn clone(&self) -> Props

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Props

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

Formats the value using the given formatter.

impl Default for Props

fn default() -> Props

Returns the “default value” for a type.

impl Display for Props

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

Formats the value using the given formatter.

impl From<Props> for u32

fn from(value: Props) -> Self

Converts to this type from the input type.

impl From<u32> for Props

fn from(value: u32) -> Self

Converts to this type from the input type.

impl Ord for Props

fn cmp(&self, other: &Props) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Props

fn eq(&self, other: &Props) -> 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 PartialOrd for Props

fn partial_cmp(&self, other: &Props) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Copy for Props

impl Eq for Props

impl StructuralPartialEq for Props