Struct CMapConf

pub struct CMapConf<CB = BuildMinimumRedundancy, LSC = OptimalLevelSize, CSB = LoMemAcceptEquals, S = BuildWyHash>where
    CSB: CollisionSolverBuilder,
    S: BuildSeededHasher,{
    pub coding: CB,
    pub level_size_chooser: LSC,
    pub collision_solver: CSB,
    pub hash: S,
}

Expand description

Configuration accepted by fp::CMap constructors.

Fields§

§coding: CB§level_size_chooser: LSC§collision_solver: CSB§hash: S

The family of hash functions used by the constructed fp::CMap. (default: BuildDefaultSeededHasher)

Implementations§

Trait Implementations§

Returns a duplicate of the value. Read more

Performs copy-assignment from source. Read more

Returns the “default value” for a type. Read more

Converts to this type from the input type.

Auto Trait Implementations§

Blanket Implementations§

Gets the TypeId of self. Read more

Immutably borrows from an owned value. Read more

Mutably borrows from an owned value. Read more

🔬This is a nightly-only experimental API. (clone_to_uninit)

Performs copy-assignment from self to dest. Read more

Returns the argument unchanged.

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

The alignment of pointer.

The type for initializers.

Initializes a with the given initializer. Read more

Dereferences the given pointer. Read more

Mutably dereferences the given pointer. Read more

Drops the object pointed to by the given pointer. Read more

The resulting type after obtaining ownership.

Creates owned data from borrowed data, usually by cloning. Read more

Uses borrowed data to replace owned data, usually by cloning. Read more

The type returned in the event of a conversion error.

Performs the conversion.

The type returned in the event of a conversion error.

Performs the conversion.

Struct CMapConf Copy item path

Fields§

Implementations§

impl CMapConf

pub fn bpf(bits_per_fragment: u8) -> CMapConf

impl<BC> CMapConf<BC>

pub fn coding(coding: BC) -> CMapConf<BC>

impl<CS> CMapConf<BuildMinimumRedundancy, OptimalLevelSize, CS>where CS: CollisionSolverBuilder,

pub fn cs( collision_solver: CS, ) -> CMapConf<BuildMinimumRedundancy, OptimalLevelSize, CS>

impl<BC, CS> CMapConf<BC, OptimalLevelSize, CS>where CS: CollisionSolverBuilder,

pub fn cs_coding( collision_solver: CS, coding: BC, ) -> CMapConf<BC, OptimalLevelSize, CS>

impl<LSC> CMapConf<BuildMinimumRedundancy, LSC>

pub fn lsize(level_size_chooser: LSC) -> CMapConf<BuildMinimumRedundancy, LSC>

pub fn lsize_bpf( level_size_chooser: LSC, bits_per_fragment: u8, ) -> CMapConf<BuildMinimumRedundancy, LSC>

impl<BC, LSC> CMapConf<BC, LSC>

pub fn lsize_coding(level_size_chooser: LSC, coding: BC) -> CMapConf<BC, LSC>

impl<LSC, CS> CMapConf<BuildMinimumRedundancy, LSC, CS>where CS: CollisionSolverBuilder,

pub fn lsize_cs( level_size_chooser: LSC, collision_solver: CS, ) -> CMapConf<BuildMinimumRedundancy, LSC, CS>

impl<BC, LSC, CS> CMapConf<BC, LSC, CS>where CS: CollisionSolverBuilder,

pub fn lsize_cs_coding( level_size_chooser: LSC, collision_solver: CS, coding: BC, ) -> CMapConf<BC, LSC, CS>

impl<S> CMapConf<BuildMinimumRedundancy, OptimalLevelSize, LoMemAcceptEquals, S>where S: BuildSeededHasher,

pub fn hash( hash: S, ) -> CMapConf<BuildMinimumRedundancy, OptimalLevelSize, LoMemAcceptEquals, S>

impl<BC, S> CMapConf<BC, OptimalLevelSize, LoMemAcceptEquals, S>where S: BuildSeededHasher,

pub fn hash_coding( hash: S, coding: BC, ) -> CMapConf<BC, OptimalLevelSize, LoMemAcceptEquals, S>

impl<S, CS> CMapConf<BuildMinimumRedundancy, OptimalLevelSize, CS, S>where S: BuildSeededHasher, CS: CollisionSolverBuilder,

pub fn cs_hash( collision_solver: CS, hash: S, ) -> CMapConf<BuildMinimumRedundancy, OptimalLevelSize, CS, S>

impl<BC, S, CS> CMapConf<BC, OptimalLevelSize, CS, S>where S: BuildSeededHasher, CS: CollisionSolverBuilder,

pub fn cs_hash_coding( collision_solver: CS, hash: S, coding: BC, ) -> CMapConf<BC, OptimalLevelSize, CS, S>

impl<LSC, S> CMapConf<BuildMinimumRedundancy, LSC, LoMemAcceptEquals, S>where S: BuildSeededHasher,

pub fn lsize_hash( level_size_chooser: LSC, hash: S, ) -> CMapConf<BuildMinimumRedundancy, LSC, LoMemAcceptEquals, S>

impl<BC, LSC, S> CMapConf<BC, LSC, LoMemAcceptEquals, S>where S: BuildSeededHasher,

pub fn lsize_hash_coding( level_size_chooser: LSC, hash: S, coding: BC, ) -> CMapConf<BC, LSC, LoMemAcceptEquals, S>

impl<LSC, CS, S> CMapConf<BuildMinimumRedundancy, LSC, CS, S>where CS: CollisionSolverBuilder, S: BuildSeededHasher,

pub fn lsize_cs_hash( level_size_chooser: LSC, collision_solver: CS, hash: S, ) -> CMapConf<BuildMinimumRedundancy, LSC, CS, S>

impl<BC, LSC, CS, S> CMapConf<BC, LSC, CS, S>where CS: CollisionSolverBuilder, S: BuildSeededHasher,

pub fn lsize_cs_hash_coding( level_size_chooser: LSC, collision_solver: CS, hash: S, coding: BC, ) -> CMapConf<BC, LSC, CS, S>

Trait Implementations§

impl<CB, LSC, CSB, S> Clone for CMapConf<CB, LSC, CSB, S>where CB: Clone, LSC: Clone, CSB: Clone + CollisionSolverBuilder, S: Clone + BuildSeededHasher,

fn clone(&self) -> CMapConf<CB, LSC, CSB, S>

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

impl<CB, LSC, CSB, S> Copy for CMapConf<CB, LSC, CSB, S>where CB: Copy, LSC: Copy, CSB: Copy + CollisionSolverBuilder, S: Copy + BuildSeededHasher,

impl Default for CMapConf

fn default() -> CMapConf

impl<BC, LSC, CSB, S> From<CMapConf<BC, LSC, CSB, S>> for FPCMapBuilder<BC, LSC, CSB, S>where LSC: LevelSizeChooser, CSB: CollisionSolverBuilder, S: BuildSeededHasher,

fn from(conf: CMapConf<BC, LSC, CSB, S>) -> Self

Auto Trait Implementations§

impl<CB, LSC, CSB, S> Freeze for CMapConf<CB, LSC, CSB, S>where CB: Freeze, LSC: Freeze, CSB: Freeze, S: Freeze,

impl<CB, LSC, CSB, S> RefUnwindSafe for CMapConf<CB, LSC, CSB, S>where CB: RefUnwindSafe, LSC: RefUnwindSafe, CSB: RefUnwindSafe, S: RefUnwindSafe,

impl<CB, LSC, CSB, S> Send for CMapConf<CB, LSC, CSB, S>where CB: Send, LSC: Send, CSB: Send, S: Send,

impl<CB, LSC, CSB, S> Sync for CMapConf<CB, LSC, CSB, S>where CB: Sync, LSC: Sync, CSB: Sync, S: Sync,

impl<CB, LSC, CSB, S> Unpin for CMapConf<CB, LSC, CSB, S>where CB: Unpin, LSC: Unpin, CSB: Unpin, S: Unpin,

impl<CB, LSC, CSB, S> UnsafeUnpin for CMapConf<CB, LSC, CSB, S>where CB: UnsafeUnpin, LSC: UnsafeUnpin, CSB: UnsafeUnpin, S: UnsafeUnpin,

impl<CB, LSC, CSB, S> UnwindSafe for CMapConf<CB, LSC, CSB, S>where CB: UnwindSafe, LSC: UnwindSafe, CSB: UnwindSafe, S: UnwindSafe,

Blanket Implementations§

impl<T> Any for Twhere T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Twhere T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Twhere T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T> CloneToUninit for Twhere T: Clone,

unsafe fn clone_to_uninit(&self, dest: *mut u8)

impl<T> From<T> for T

fn from(t: T) -> T

impl<T, U> Into<U> for Twhere U: From<T>,

fn into(self) -> U

impl<T> IntoEither for T

fn into_either(self, into_left: bool) -> Either<Self, Self>

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>where F: FnOnce(&Self) -> bool,

impl<T> Pointable for T

const ALIGN: usize

type Init = T

unsafe fn init(init: <T as Pointable>::Init) -> usize

unsafe fn deref<'a>(ptr: usize) -> &'a T

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

unsafe fn drop(ptr: usize)

impl<T> ToOwned for Twhere T: Clone,

type Owned = T

fn to_owned(&self) -> T

fn clone_into(&self, target: &mut T)

Struct CMapConf

impl<CS> CMapConf<BuildMinimumRedundancy, OptimalLevelSize, CS>
where CS: CollisionSolverBuilder,

impl<BC, CS> CMapConf<BC, OptimalLevelSize, CS>
where CS: CollisionSolverBuilder,

impl<LSC, CS> CMapConf<BuildMinimumRedundancy, LSC, CS>
where CS: CollisionSolverBuilder,

impl<BC, LSC, CS> CMapConf<BC, LSC, CS>
where CS: CollisionSolverBuilder,

impl<S> CMapConf<BuildMinimumRedundancy, OptimalLevelSize, LoMemAcceptEquals, S>
where S: BuildSeededHasher,

impl<BC, S> CMapConf<BC, OptimalLevelSize, LoMemAcceptEquals, S>
where S: BuildSeededHasher,

impl<S, CS> CMapConf<BuildMinimumRedundancy, OptimalLevelSize, CS, S>
where S: BuildSeededHasher, CS: CollisionSolverBuilder,

impl<BC, S, CS> CMapConf<BC, OptimalLevelSize, CS, S>
where S: BuildSeededHasher, CS: CollisionSolverBuilder,

impl<LSC, S> CMapConf<BuildMinimumRedundancy, LSC, LoMemAcceptEquals, S>
where S: BuildSeededHasher,

impl<BC, LSC, S> CMapConf<BC, LSC, LoMemAcceptEquals, S>
where S: BuildSeededHasher,

impl<LSC, CS, S> CMapConf<BuildMinimumRedundancy, LSC, CS, S>
where CS: CollisionSolverBuilder, S: BuildSeededHasher,

impl<BC, LSC, CS, S> CMapConf<BC, LSC, CS, S>
where CS: CollisionSolverBuilder, S: BuildSeededHasher,

impl<CB, LSC, CSB, S> Clone for CMapConf<CB, LSC, CSB, S>
where CB: Clone, LSC: Clone, CSB: Clone + CollisionSolverBuilder, S: Clone + BuildSeededHasher,

impl<CB, LSC, CSB, S> Copy for CMapConf<CB, LSC, CSB, S>
where CB: Copy, LSC: Copy, CSB: Copy + CollisionSolverBuilder, S: Copy + BuildSeededHasher,

impl<BC, LSC, CSB, S> From<CMapConf<BC, LSC, CSB, S>> for FPCMapBuilder<BC, LSC, CSB, S>
where LSC: LevelSizeChooser, CSB: CollisionSolverBuilder, S: BuildSeededHasher,

impl<CB, LSC, CSB, S> Freeze for CMapConf<CB, LSC, CSB, S>
where CB: Freeze, LSC: Freeze, CSB: Freeze, S: Freeze,

impl<CB, LSC, CSB, S> RefUnwindSafe for CMapConf<CB, LSC, CSB, S>
where CB: RefUnwindSafe, LSC: RefUnwindSafe, CSB: RefUnwindSafe, S: RefUnwindSafe,

impl<CB, LSC, CSB, S> Send for CMapConf<CB, LSC, CSB, S>
where CB: Send, LSC: Send, CSB: Send, S: Send,

impl<CB, LSC, CSB, S> Sync for CMapConf<CB, LSC, CSB, S>
where CB: Sync, LSC: Sync, CSB: Sync, S: Sync,

impl<CB, LSC, CSB, S> Unpin for CMapConf<CB, LSC, CSB, S>
where CB: Unpin, LSC: Unpin, CSB: Unpin, S: Unpin,

impl<CB, LSC, CSB, S> UnsafeUnpin for CMapConf<CB, LSC, CSB, S>
where CB: UnsafeUnpin, LSC: UnsafeUnpin, CSB: UnsafeUnpin, S: UnsafeUnpin,

impl<CB, LSC, CSB, S> UnwindSafe for CMapConf<CB, LSC, CSB, S>
where CB: UnwindSafe, LSC: UnwindSafe, CSB: UnwindSafe, S: UnwindSafe,

impl<T> Any for T
where T: 'static + ?Sized,

impl<T> Borrow<T> for T
where T: ?Sized,

impl<T> BorrowMut<T> for T
where T: ?Sized,

impl<T> CloneToUninit for T
where T: Clone,

impl<T, U> Into<U> for T
where U: From<T>,

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

impl<T> ToOwned for T
where T: Clone,

impl<T, U> TryFrom<U> for T
where U: Into<T>,

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,