Struct InterleavedTempFile 

pub struct InterleavedTempFile { /* private fields */ }

Implementations

impl InterleavedTempFile

pub fn new_temp() -> Result<Self, VirtualFileError>

Examples found in repository

examples/interleaved_temp_storage.rs (line 9)

fn main() {
    let storage = InterleavedTempFile::new_temp().unwrap();
    let mut handles = Vec::new();

    for stream_index in 0..4 {
        let mut writer = storage.spawn_stream();
        handles.push(thread::spawn(move || {
            let stream_id = writer.stream_id();
            let chunks = [
                format!("track-{stream_index}:header|"),
                format!("track-{stream_index}:events|"),
                format!("track-{stream_index}:tail"),
            ];

            let mut expected = String::new();
            for chunk in chunks {
                writer.write_all(chunk.as_bytes()).unwrap();
                expected.push_str(&chunk);
            }

            writer.flush().unwrap();
            (stream_id, expected)
        }));
    }

    let mut expected_streams = Vec::new();
    for handle in handles {
        expected_streams.push(handle.join().unwrap());
    }
    expected_streams.sort_unstable_by_key(|(stream_id, _)| *stream_id);

    println!("Backing file: {}", storage.path().display());
    for (stream_id, expected) in expected_streams {
        let mut reader = storage.open_reader(stream_id).unwrap();
        let mut actual = String::new();
        reader.read_to_string(&mut actual).unwrap();

        assert_eq!(actual, expected);
        println!("stream {stream_id}: {actual}");
    }
}

pub fn new_at_path(path: impl AsRef<Path>) -> Result<Self, VirtualFileError>

pub fn new_temp_at_path( path: impl AsRef<Path>, ) -> Result<Self, VirtualFileError>

pub fn path(&self) -> &Path

Examples found in repository

examples/interleaved_temp_storage.rs (line 39)

fn main() {
    let storage = InterleavedTempFile::new_temp().unwrap();
    let mut handles = Vec::new();

    for stream_index in 0..4 {
        let mut writer = storage.spawn_stream();
        handles.push(thread::spawn(move || {
            let stream_id = writer.stream_id();
            let chunks = [
                format!("track-{stream_index}:header|"),
                format!("track-{stream_index}:events|"),
                format!("track-{stream_index}:tail"),
            ];

            let mut expected = String::new();
            for chunk in chunks {
                writer.write_all(chunk.as_bytes()).unwrap();
                expected.push_str(&chunk);
            }

            writer.flush().unwrap();
            (stream_id, expected)
        }));
    }

    let mut expected_streams = Vec::new();
    for handle in handles {
        expected_streams.push(handle.join().unwrap());
    }
    expected_streams.sort_unstable_by_key(|(stream_id, _)| *stream_id);

    println!("Backing file: {}", storage.path().display());
    for (stream_id, expected) in expected_streams {
        let mut reader = storage.open_reader(stream_id).unwrap();
        let mut actual = String::new();
        reader.read_to_string(&mut actual).unwrap();

        assert_eq!(actual, expected);
        println!("stream {stream_id}: {actual}");
    }
}

pub fn spawn_stream(&self) -> VirtualStreamWriter

Examples found in repository

examples/interleaved_temp_storage.rs (line 13)

fn main() {
    let storage = InterleavedTempFile::new_temp().unwrap();
    let mut handles = Vec::new();

    for stream_index in 0..4 {
        let mut writer = storage.spawn_stream();
        handles.push(thread::spawn(move || {
            let stream_id = writer.stream_id();
            let chunks = [
                format!("track-{stream_index}:header|"),
                format!("track-{stream_index}:events|"),
                format!("track-{stream_index}:tail"),
            ];

            let mut expected = String::new();
            for chunk in chunks {
                writer.write_all(chunk.as_bytes()).unwrap();
                expected.push_str(&chunk);
            }

            writer.flush().unwrap();
            (stream_id, expected)
        }));
    }

    let mut expected_streams = Vec::new();
    for handle in handles {
        expected_streams.push(handle.join().unwrap());
    }
    expected_streams.sort_unstable_by_key(|(stream_id, _)| *stream_id);

    println!("Backing file: {}", storage.path().display());
    for (stream_id, expected) in expected_streams {
        let mut reader = storage.open_reader(stream_id).unwrap();
        let mut actual = String::new();
        reader.read_to_string(&mut actual).unwrap();

        assert_eq!(actual, expected);
        println!("stream {stream_id}: {actual}");
    }
}

pub fn stream_ids(&self) -> Vec<u64>

pub fn open_reader( &self, stream_id: u64, ) -> Result<VirtualStreamReader, VirtualFileError>

Examples found in repository

examples/interleaved_temp_storage.rs (line 41)

fn main() {
    let storage = InterleavedTempFile::new_temp().unwrap();
    let mut handles = Vec::new();

    for stream_index in 0..4 {
        let mut writer = storage.spawn_stream();
        handles.push(thread::spawn(move || {
            let stream_id = writer.stream_id();
            let chunks = [
                format!("track-{stream_index}:header|"),
                format!("track-{stream_index}:events|"),
                format!("track-{stream_index}:tail"),
            ];

            let mut expected = String::new();
            for chunk in chunks {
                writer.write_all(chunk.as_bytes()).unwrap();
                expected.push_str(&chunk);
            }

            writer.flush().unwrap();
            (stream_id, expected)
        }));
    }

    let mut expected_streams = Vec::new();
    for handle in handles {
        expected_streams.push(handle.join().unwrap());
    }
    expected_streams.sort_unstable_by_key(|(stream_id, _)| *stream_id);

    println!("Backing file: {}", storage.path().display());
    for (stream_id, expected) in expected_streams {
        let mut reader = storage.open_reader(stream_id).unwrap();
        let mut actual = String::new();
        reader.read_to_string(&mut actual).unwrap();

        assert_eq!(actual, expected);
        println!("stream {stream_id}: {actual}");
    }
}

pub fn flush(&self) -> Result<(), VirtualFileError>

pub fn remove_backing_file(&self) -> Result<(), VirtualFileError>

Trait Implementations

impl Clone for InterleavedTempFile

fn clone(&self) -> InterleavedTempFile

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for InterleavedTempFile

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

Formats the value using the given formatter.