Struct Storage 

pub struct Storage<'a> { /* private fields */ }

A storage of the device.

Implementations

impl<'a> Storage<'a>

pub fn id(&self) -> u32

Retrieves the ID of the storage.

pub fn name(&self) -> Option<&str>

Retrieves the friendly name of the storage.

Panics

Panics if the friendly name of the storage is not a valid UTF-8.

pub fn kind(&self) -> Option<StorageKind>

Retrieves the kind of the storage.

pub fn fs(&self) -> Option<Filesystem>

Retrieves the filesystem of the storage.

pub fn access(&self) -> Option<StorageAccess>

Retrieves the access capability over the storage.

pub fn total_space(&self) -> u64

Retrieves the total space in bytes of the storage.

pub fn free_space(&self) -> u64

Retrieves the free space in bytes of the storage.

pub fn format(&self) -> Result<()>

Erases all data on the storage and formats it.

This function will permanently erase all data from the storage!

Errors

Returns an error if the device doesn’t have a support for storage formatting or if the operation has failed.

pub fn iter(&self) -> ObjectIter<'_>

Retrieves an iterator over the objects in the root of the storage.

pub fn iter_recursive(&self) -> ObjectRecursiveIter<'_>

Retrieves a recursive iterator over the objects of the storage.

Examples found in repository

examples/list-objects.rs (line 7)

fn main() -> libmtp::Result<()> {
	for device in search_raw_devices()?.filter_map(RawDevice::open_uncached) {
		for storage in &device {
			for object in storage.iter_recursive() {
				println!("{object:?}");
			}
		}
	}
	Ok(())
}

examples/copy-from-host.rs (line 8)

fn main() -> libmtp::Result<()> {
	let device = Device::from_serial("GVEV4I3E0WU1")?.expect("Device should exist");
	let storage = device.find_storage(65537).expect("Storage should exist");
	for object in storage.iter_recursive() {
		if let Object::Folder(folder) = object {
			folder.copy_file_from_host("/tmp/hello.txt", FileKind::Text)?;
			break;
		}
	}
	Ok(())
}

examples/copy-to-host.rs (line 7)

fn main() -> libmtp::Result<()> {
	let device = Device::from_serial("GVEV4I3E0WU1")?.expect("Device should exist");
	let storage = device.find_storage(65537).expect("Storage should exist");
	for object in storage.iter_recursive() {
		if let Object::File(file) = object {
			let path = format!("/tmp/libmtp-{}", file.name());
			file.copy_to_host(path)?;
			break;
		}
	}
	Ok(())
}

Trait Implementations

impl<'a> Clone for Storage<'a>

fn clone(&self) -> Storage<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Storage<'_>

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

Formats the value using the given formatter.

impl Display for Storage<'_>

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

Formats the value using the given formatter.

impl<'a> Hash for Storage<'a>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a> IntoIterator for &'a Storage<'a>

type Item = Object<'a>

The type of the elements being iterated over.

type IntoIter = ObjectIter<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a> Copy for Storage<'a>