Struct cyfs_bdt::utils::MemChunkStore

pub struct MemChunkStore(_);

Implementations

impl MemChunkStore

pub fn new() -> Self

Examples found in repository

examples/utils.rs (line 55)

pub async fn local_stack_pair_with_config(
    ln_ep: &[&str],
    rn_ep: &[&str],
    ln_config: Option<StackConfig>,
    rn_config: Option<StackConfig>,
) -> BuckyResult<((StackGuard, MemChunkStore), (StackGuard, MemChunkStore))> {
    let (ln_dev, ln_secret) = create_device("5aSixgLuJjfrNKn9D4z66TEM6oxL3uNmWCWHk52cJDKR", ln_ep)?;
    let (rn_dev, rn_secret) = create_device("5aSixgLuJjfrNKn9D4z66TEM6oxL3uNmWCWHk52cJDKR", rn_ep)?;

    let mut ln_params = StackOpenParams::new("");
    let ln_store = MemChunkStore::new();
    ln_params.chunk_store = Some(ln_store.clone_as_reader());
    let mut ln_config = ln_config;
    if ln_config.is_some() {
        std::mem::swap(&mut ln_params.config, ln_config.as_mut().unwrap());
    }

    ln_params.known_device = Some(vec![rn_dev.clone()]);
    let ln_stack = Stack::open(ln_dev.clone(), ln_secret, ln_params).await?;

    let mut rn_params = StackOpenParams::new("");
    let rn_store = MemChunkStore::new();
    rn_params.chunk_store = Some(rn_store.clone_as_reader());
    let mut rn_config = rn_config;
    if rn_config.is_some() {
        std::mem::swap(&mut rn_params.config, rn_config.as_mut().unwrap());
    }

    let rn_stack = Stack::open(rn_dev, rn_secret, rn_params).await?;

    Ok(((ln_stack, ln_store), (rn_stack, rn_store)))
}

pub async fn add(&self, id: ChunkId, chunk: Arc<Vec<u8>>) -> BuckyResult<()>

pub async fn write_chunk<R: Read + Unpin>( &self, id: &ChunkId, reader: R ) -> BuckyResult<()>

Examples found in repository

examples/upload_download.rs (line 102)

            async fn on_newly_interest(
                &self, 
                stack: &Stack, 
                interest: &Interest, 
                from: &Channel
            ) -> BuckyResult<()> {
                let (_, reader) = download_chunk(
                    stack,
                    interest.chunk.clone(), 
                    None, 
                    SampleDownloadContext::desc_streams("".to_owned(), vec![self.src_dev.desc().clone()]),
                ).await.unwrap();
                {
                    let store = self.store.clone();
                    let chunk = interest.chunk.clone();
                    task::spawn(async move {
                        store.write_chunk(&chunk, reader).await.unwrap();
                    });
                }
                self.default.on_newly_interest(stack, interest, from).await
            }

Trait Implementations

impl ChunkReader for MemChunkStore

fn clone_as_reader(&self) -> Box<dyn ChunkReader>

fn exists<'life0, 'life1, 'async_trait>( &'life0 self, chunk: &'life1 ChunkId ) -> Pin<Box<dyn Future<Output = bool> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn get<'life0, 'life1, 'async_trait>( &'life0 self, chunk: &'life1 ChunkId ) -> Pin<Box<dyn Future<Output = BuckyResult<Box<dyn AsyncReadWithSeek + Unpin + Send + Sync>>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl Clone for MemChunkStore

fn clone(&self) -> MemChunkStore

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Display for MemChunkStore

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

Formats the value using the given formatter.