Struct MappedOption 

pub struct MappedOption<'a, T: MemoryMapped<'a>> { /* private fields */ }

An optional immutable memory-mapped structure.

This is compatible with the serialization format of Option of the same type.

Examples

use simple_sds_sbwt::serialize::{MappedOption, MappedSlice, MappingMode, MemoryMap, MemoryMapped, Serialize};
use simple_sds_sbwt::serialize;
use std::fs;

let some: Option<Vec<u64>> = Some(vec![123, 456, 789]);
let filename = serialize::temp_file_name("mapped-option");
serialize::serialize_to(&some, &filename);

let map = MemoryMap::new(&filename, MappingMode::ReadOnly).unwrap();
let mapped = MappedOption::<MappedSlice<u64>>::new(&map, 0).unwrap();
assert_eq!(mapped.unwrap().as_ref(), some.unwrap().as_slice());
drop(mapped); drop(map);

fs::remove_file(&filename).unwrap();

Implementations

impl<'a, T: MemoryMapped<'a>> MappedOption<'a, T>

pub fn is_some(&self) -> bool

Returns true if the option is a Some value.

pub fn is_none(&self) -> bool

Returns true if the option is a None value.

pub fn unwrap(&self) -> &T

Returns an immutable reference to the possibly contained value.

Panics

Panics if the option is a None value.

pub fn as_ref(&self) -> Option<&T>

Returns Option<&T> referencing the possibly contained value.

Trait Implementations

impl<'a, T: Debug + MemoryMapped<'a>> Debug for MappedOption<'a, T>

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

Formats the value using the given formatter.

impl<'a, T: MemoryMapped<'a>> MemoryMapped<'a> for MappedOption<'a, T>

Available on non-target_family=wasm only.

fn new(map: &'a MemoryMap, offset: usize) -> Result<Self>

Returns an immutable memory-mapped structure corresponding to an interval in the file.

fn map_offset(&self) -> usize

Returns the starting offset in the file.

fn map_len(&self) -> usize

Returns the length of the interval corresponding to the structure.

impl<'a, T: PartialEq + MemoryMapped<'a>> PartialEq for MappedOption<'a, T>

fn eq(&self, other: &MappedOption<'a, T>) -> 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<'a, T: Eq + MemoryMapped<'a>> Eq for MappedOption<'a, T>

impl<'a, T: MemoryMapped<'a>> StructuralPartialEq for MappedOption<'a, T>