Struct sn_client::Files

pub struct Files { /* private fields */ }

File APIs.

Implementations

impl Files

pub fn new(client: Client) -> Self

Create file apis instance.

pub async fn read_bytes(&self, address: ChunkAddress) -> Result<Bytes, Error>

Reads Bytes from the network, whose contents are contained within one or more chunks.

pub async fn read_from( &self, address: ChunkAddress, position: usize, length: usize ) -> Result<Bytes, Error>where Self: Sized,

Read bytes from the network. The contents are spread across multiple chunks in the network. This function invokes the self-encryptor and returns the data that was initially stored.

Takes position and length arguments which specify the start position and the length of bytes to be read. Passing 0 to position reads the data from the beginning, and the length is just an upper limit.

pub async fn upload_with_proof( &self, bytes: Bytes, payment_proofs: &PaymentProofsMap, verify_store: bool ) -> Result<ChunkAddress, Error>

Directly writes Bytes to the network in the form of immutable chunks, without any batching.

pub async fn upload_and_verify( &self, bytes: Bytes, payment_proofs: &PaymentProofsMap ) -> Result<ChunkAddress, Error>

Directly writes Bytes to the network in the form of immutable chunks, without any batching. It also attempts to verify that all the data was uploaded to the network before returning. It does this via running read_bytes with each chunk with query_timeout set.

pub fn calculate_address(&self, bytes: Bytes) -> Result<XorName, Error>

Calculates a LargeFile’s/SmallFile’s address from self encrypted chunks, without storing them onto the network.

pub fn chunk_bytes(&self, bytes: Bytes) -> Result<(XorName, Vec<Chunk>), Error>

Tries to chunk the bytes, returning the data-map address and chunks, without storing anything to network.

pub async fn upload_chunks_in_batches( &self, chunks: impl Iterator<Item = Chunk>, payment_proofs: &PaymentProofsMap, verify_store: bool ) -> Result<(), Error>

Directly writes Chunks to the network in the form of immutable self encrypted chunks.