Trait PhfEq 

pub trait PhfEq<B>
where
    B: ?Sized,
{
    // Required method
    fn phf_eq(&self, other: &B) -> bool;
}

Trait for comparing stored PHF keys with runtime lookup keys.

Lookup keys must hash the same way as the stored key they compare equal to. Most borrowed key forms use the blanket implementation based on PhfBorrow. Tuples are implemented separately so references inside a tuple can use shorter lifetimes at lookup time. Tuple impls are provided up to 12 elements.

Required Methods

fn phf_eq(&self, other: &B) -> bool

Returns true if self and other are equivalent PHF keys.

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<A, AT, B, BT, C, CT, D, DT, E, ET, F, FT, G, GT, H, HT, I, IT, J, JT, K, KT, L, LT> PhfEq<(AT, BT, CT, DT, ET, FT, GT, HT, IT, JT, KT, LT)> for (A, B, C, D, E, F, G, H, I, J, K, L)

where A: PartialEq<AT>, B: PartialEq<BT>, C: PartialEq<CT>, D: PartialEq<DT>, E: PartialEq<ET>, F: PartialEq<FT>, G: PartialEq<GT>, H: PartialEq<HT>, I: PartialEq<IT>, J: PartialEq<JT>, K: PartialEq<KT>, L: PartialEq<LT>,

fn phf_eq( &self, other: &(AT, BT, CT, DT, ET, FT, GT, HT, IT, JT, KT, LT), ) -> bool

impl<A, AT, B, BT, C, CT, D, DT, E, ET, F, FT, G, GT, H, HT, I, IT, J, JT, K, KT> PhfEq<(AT, BT, CT, DT, ET, FT, GT, HT, IT, JT, KT)> for (A, B, C, D, E, F, G, H, I, J, K)

where A: PartialEq<AT>, B: PartialEq<BT>, C: PartialEq<CT>, D: PartialEq<DT>, E: PartialEq<ET>, F: PartialEq<FT>, G: PartialEq<GT>, H: PartialEq<HT>, I: PartialEq<IT>, J: PartialEq<JT>, K: PartialEq<KT>,

fn phf_eq(&self, other: &(AT, BT, CT, DT, ET, FT, GT, HT, IT, JT, KT)) -> bool

impl<A, AT, B, BT, C, CT, D, DT, E, ET, F, FT, G, GT, H, HT, I, IT, J, JT> PhfEq<(AT, BT, CT, DT, ET, FT, GT, HT, IT, JT)> for (A, B, C, D, E, F, G, H, I, J)

where A: PartialEq<AT>, B: PartialEq<BT>, C: PartialEq<CT>, D: PartialEq<DT>, E: PartialEq<ET>, F: PartialEq<FT>, G: PartialEq<GT>, H: PartialEq<HT>, I: PartialEq<IT>, J: PartialEq<JT>,

fn phf_eq(&self, other: &(AT, BT, CT, DT, ET, FT, GT, HT, IT, JT)) -> bool

impl<A, AT, B, BT, C, CT, D, DT, E, ET, F, FT, G, GT, H, HT, I, IT> PhfEq<(AT, BT, CT, DT, ET, FT, GT, HT, IT)> for (A, B, C, D, E, F, G, H, I)

where A: PartialEq<AT>, B: PartialEq<BT>, C: PartialEq<CT>, D: PartialEq<DT>, E: PartialEq<ET>, F: PartialEq<FT>, G: PartialEq<GT>, H: PartialEq<HT>, I: PartialEq<IT>,

fn phf_eq(&self, other: &(AT, BT, CT, DT, ET, FT, GT, HT, IT)) -> bool

impl<A, AT, B, BT, C, CT, D, DT, E, ET, F, FT, G, GT, H, HT> PhfEq<(AT, BT, CT, DT, ET, FT, GT, HT)> for (A, B, C, D, E, F, G, H)

where A: PartialEq<AT>, B: PartialEq<BT>, C: PartialEq<CT>, D: PartialEq<DT>, E: PartialEq<ET>, F: PartialEq<FT>, G: PartialEq<GT>, H: PartialEq<HT>,

fn phf_eq(&self, other: &(AT, BT, CT, DT, ET, FT, GT, HT)) -> bool

impl<A, AT, B, BT, C, CT, D, DT, E, ET, F, FT, G, GT> PhfEq<(AT, BT, CT, DT, ET, FT, GT)> for (A, B, C, D, E, F, G)

where A: PartialEq<AT>, B: PartialEq<BT>, C: PartialEq<CT>, D: PartialEq<DT>, E: PartialEq<ET>, F: PartialEq<FT>, G: PartialEq<GT>,

fn phf_eq(&self, other: &(AT, BT, CT, DT, ET, FT, GT)) -> bool

impl<A, AT, B, BT, C, CT, D, DT, E, ET, F, FT> PhfEq<(AT, BT, CT, DT, ET, FT)> for (A, B, C, D, E, F)

where A: PartialEq<AT>, B: PartialEq<BT>, C: PartialEq<CT>, D: PartialEq<DT>, E: PartialEq<ET>, F: PartialEq<FT>,

fn phf_eq(&self, other: &(AT, BT, CT, DT, ET, FT)) -> bool

impl<A, AT, B, BT, C, CT, D, DT, E, ET> PhfEq<(AT, BT, CT, DT, ET)> for (A, B, C, D, E)

where A: PartialEq<AT>, B: PartialEq<BT>, C: PartialEq<CT>, D: PartialEq<DT>, E: PartialEq<ET>,

fn phf_eq(&self, other: &(AT, BT, CT, DT, ET)) -> bool

impl<A, AT, B, BT, C, CT, D, DT> PhfEq<(AT, BT, CT, DT)> for (A, B, C, D)

where A: PartialEq<AT>, B: PartialEq<BT>, C: PartialEq<CT>, D: PartialEq<DT>,

fn phf_eq(&self, other: &(AT, BT, CT, DT)) -> bool

impl<A, AT, B, BT, C, CT> PhfEq<(AT, BT, CT)> for (A, B, C)

where A: PartialEq<AT>, B: PartialEq<BT>, C: PartialEq<CT>,

fn phf_eq(&self, other: &(AT, BT, CT)) -> bool

impl<A, AT, B, BT> PhfEq<(AT, BT)> for (A, B)

where A: PartialEq<AT>, B: PartialEq<BT>,

fn phf_eq(&self, other: &(AT, BT)) -> bool

impl<A, AT> PhfEq<(AT,)> for (A,)

where A: PartialEq<AT>,

fn phf_eq(&self, other: &(AT,)) -> bool

Implementors

impl<K, B> PhfEq<B> for K

where B: Eq + ?Sized, K: PhfBorrow<B>,