Struct sux::func::VFunc

pub struct VFunc<T: ?Sized + ToSig, O: ZeroCopy + SerializeInner + DeserializeInner + Word + IntoAtomic = usize, S: BitFieldSlice<O> = BitFieldVec<O>> { /* private fields */ }

Static functions with 10%-11% space overhead for large key sets, fast parallel construction, and fast queries.

Instances of this structure are immutable; they are built using a VFuncBuilder, and can be serialized using ε-serde.

Implementations

impl<T: ?Sized + ToSig, O: ZeroCopy + SerializeInner + DeserializeInner + Word + IntoAtomic, S: BitFieldSlice<O>> VFunc<T, O, S>

where O::AtomicType: AtomicUnsignedInt + AsBytes, BitFieldVec<O>: From<AtomicBitFieldVec<O, Vec<O::AtomicType>>>,

pub fn get_by_sig(&self, sig: &[u64; 2]) -> O

Return the value associated with the given signature.

This method is mainly useful in the construction of compound functions.

pub fn get(&self, key: &T) -> O

Return the value associated with the given key, or a random value if the key is not present.

Examples found in repository

examples/bench_vfunc.rs (line 45)

fn main() -> Result<()> {
    env_logger::builder()
        .filter_level(log::LevelFilter::Info)
        .try_init()?;

    let mut pl = ProgressLogger::default();

    let args = Args::parse();

    if let Some(filename) = args.filename {
        let func = VFunc::<_>::load_mem(&args.func)?;
        let keys: Vec<_> = LineLender::from_path(filename)?
            .map_into_iter(|x| x.unwrap().to_owned())
            .take(args.n)
            .collect();
        pl.start("Querying...");
        for (i, key) in keys.iter().enumerate() {
            assert_eq!(i, func.get(key));
        }
        pl.done_with_count(keys.len());
    } else {
        let func = VFunc::<_>::load_mem(&args.func)?;
        pl.start("Querying...");
        for i in 0..args.n {
            assert_eq!(i, func.get(&i));
        }
        pl.done_with_count(args.n);
    }

    Ok(())
}

pub fn len(&self) -> usize

Return the number of keys in the function.

pub fn is_empty(&self) -> bool

Return whether the function has no keys.

Trait Implementations

impl<T: ?Sized + ToSig, O: ZeroCopy + SerializeInner + DeserializeInner + Word + IntoAtomic, S: BitFieldSlice<O>> CopyType for VFunc<T, O, S>

type Copy = Deep

impl<T: ?Sized + ToSig, O: ZeroCopy + SerializeInner + DeserializeInner + Word + IntoAtomic, S> CopyType for VFunc<T, O, S>

where u64: MemSize, u32: MemSize, usize: MemSize, S: MemSize + BitFieldSlice<O>, PhantomData<T>: MemSize, PhantomData<O>: MemSize,

type Copy = False

impl<T: Debug + ?Sized + ToSig, O: Debug + ZeroCopy + SerializeInner + DeserializeInner + Word + IntoAtomic, S: Debug + BitFieldSlice<O>> Debug for VFunc<T, O, S>

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

Formats the value using the given formatter.

impl<T: ?Sized + ToSig, O: ZeroCopy + SerializeInner + DeserializeInner + Word + IntoAtomic, S> DeserializeInner for VFunc<T, O, S>

where u64: DeserializeInner, u32: DeserializeInner, usize: DeserializeInner, S: DeserializeInner + BitFieldSlice<O>, PhantomData<T>: DeserializeInner, PhantomData<O>: DeserializeInner, for<'epserde_desertype> <S as DeserializeInner>::DeserType<'epserde_desertype>: BitFieldSlice<O>,

fn _deserialize_full_inner( backend: &mut impl ReadWithPos ) -> Result<Self, Error>

type DeserType<'epserde_desertype> = VFunc<T, O, <S as DeserializeInner>::DeserType<'epserde_desertype>>

The deserialization type associated with this type. It can be retrieved conveniently with the alias DeserType.

fn _deserialize_eps_inner<'a>( backend: &mut SliceWithPos<'a> ) -> Result<Self::DeserType<'a>, Error>

impl<T: ?Sized + ToSig, O: ZeroCopy + SerializeInner + DeserializeInner + Word + IntoAtomic, S> MemDbgImpl for VFunc<T, O, S>

where u64: MemDbgImpl, u32: MemDbgImpl, usize: MemDbgImpl, S: MemDbgImpl + BitFieldSlice<O>, PhantomData<T>: MemDbgImpl, PhantomData<O>: MemDbgImpl,

fn _mem_dbg_rec_on( &self, _memdbg_writer: &mut impl Write, _memdbg_total_size: usize, _memdbg_max_depth: usize, _memdbg_prefix: &mut String, _memdbg_is_last: bool, _memdbg_flags: DbgFlags ) -> Result

impl<T: ?Sized + ToSig, O: ZeroCopy + SerializeInner + DeserializeInner + Word + IntoAtomic, S> MemSize for VFunc<T, O, S>

where u64: MemSize, u32: MemSize, usize: MemSize, S: MemSize + BitFieldSlice<O>, PhantomData<T>: MemSize, PhantomData<O>: MemSize,

fn mem_size(&self, _memsize_flags: SizeFlags) -> usize

Return the (recursively computed) overall memory size of the structure in bytes.

impl<T: ?Sized + ToSig + ReprHash, O: ZeroCopy + SerializeInner + DeserializeInner + Word + IntoAtomic + ReprHash, S: BitFieldSlice<O> + ReprHash> ReprHash for VFunc<T, O, S>

fn repr_hash(hasher: &mut impl Hasher, offset_of: &mut usize)

Accumulate representional information in hasher assuming to be positioned at offset_of.

fn repr_hash_val(&self, hasher: &mut impl Hasher, offset_of: &mut usize)

Call ReprHash::repr_hash on a value.

impl<T: ?Sized + ToSig, O: ZeroCopy + SerializeInner + DeserializeInner + Word + IntoAtomic, S> SerializeInner for VFunc<T, O, S>

where u64: SerializeInner, u32: SerializeInner, usize: SerializeInner, S: SerializeInner + BitFieldSlice<O>, PhantomData<T>: SerializeInner, PhantomData<O>: SerializeInner,

const IS_ZERO_COPY: bool = _

Inner constant used by the derive macros to keep track recursively of whether the type satisfies the conditions for being zero-copy. It is checked at runtime against the trait implemented by the type, and if a ZeroCopy type has this constant set to false serialization will panic.

const ZERO_COPY_MISMATCH: bool = _

Inner constant used by the derive macros to keep track of whether all fields of a type are zero-copy but neither the attribute #[zero_copy] nor the attribute #[deep_copy] was specified. It is checked at runtime, and if it is true a warning will be issued, as the type could be zero-copy, which would be more efficient.

fn _serialize_inner(&self, backend: &mut impl WriteWithNames) -> Result<()>

Serialize this structure using the given backend.

impl<T: ?Sized + ToSig + TypeHash, O: ZeroCopy + SerializeInner + DeserializeInner + Word + IntoAtomic + TypeHash, S: BitFieldSlice<O> + TypeHash> TypeHash for VFunc<T, O, S>

fn type_hash(hasher: &mut impl Hasher)

Accumulate type information in hasher.

fn type_hash_val(&self, hasher: &mut impl Hasher)

Call TypeHash::type_hash on a value.