Struct BytesHash

pub struct BytesHash<'a> { /* private fields */ }

Contains a byte slice and a precomputed hash for that string. During rehashes, we will rehash the hash instead of the string, that makes rehashing cheap and allows cache coherent small hash tables.

Implementations

impl<'a> BytesHash<'a>

pub fn new(s: Option<&'a [u8]>, hash: u64) -> Self

Trait Implementations

impl<'a> Clone for BytesHash<'a>

fn clone(&self) -> BytesHash<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for BytesHash<'a>

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

Formats the value using the given formatter.

impl DirtyHash for BytesHash<'_>

fn dirty_hash(&self) -> u64

impl Hash for BytesHash<'_>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a> IsNull for BytesHash<'a>

const HAS_NULLS: bool = true

type Inner = BytesHash<'a>

fn is_null(&self) -> bool

fn unwrap_inner(self) -> Self::Inner

impl PartialEq for BytesHash<'_>

fn eq(&self, other: &Self) -> 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> ToTotalOrd for BytesHash<'a>

type TotalOrdItem = BytesHash<'a>

type SourceItem = BytesHash<'a>

fn to_total_ord(&self) -> Self::TotalOrdItem

fn peel_total_ord(ord_item: Self::TotalOrdItem) -> Self::SourceItem

impl TotalEq for BytesHash<'_>

fn tot_eq(&self, other: &Self) -> bool

fn tot_ne(&self, other: &Self) -> bool

impl TotalHash for BytesHash<'_>

fn tot_hash<H>(&self, state: &mut H)

where H: Hasher,

fn tot_hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

impl<'a> Copy for BytesHash<'a>

impl<'a> Eq for BytesHash<'a>