use super::{fmt, hashbrown, Borrow, BuildHasher, Debug, Hash};
use crate::vecmap;
use hashbrown::hash_map;
pub struct RawEntryBuilderMut<'map, K, V, S>(RawEntryBuilderMutInt<'map, K, V, S>);
impl<'map, K, V, S> From<hash_map::RawEntryBuilderMut<'map, K, V, S>>
for RawEntryBuilderMut<'map, K, V, S>
{
fn from(m: hash_map::RawEntryBuilderMut<'map, K, V, S>) -> Self {
Self(RawEntryBuilderMutInt::Map(m))
}
}
impl<'map, K, V, S> From<vecmap::RawEntryBuilderMut<'map, K, V, S>>
for RawEntryBuilderMut<'map, K, V, S>
where
S: BuildHasher,
{
fn from(m: vecmap::RawEntryBuilderMut<'map, K, V, S>) -> Self {
Self(RawEntryBuilderMutInt::Vec(m))
}
}
enum RawEntryBuilderMutInt<'map, K, V, S> {
Vec(vecmap::RawEntryBuilderMut<'map, K, V, S>),
Map(hash_map::RawEntryBuilderMut<'map, K, V, S>),
}
pub enum RawEntryMut<'map, K, V, S> {
Occupied(RawOccupiedEntryMut<'map, K, V, S>),
Vacant(RawVacantEntryMut<'map, K, V, S>),
}
impl<'map, K, V, S> From<vecmap::RawEntryMut<'map, K, V, S>> for RawEntryMut<'map, K, V, S> {
fn from(e: vecmap::RawEntryMut<'map, K, V, S>) -> Self {
match e {
vecmap::RawEntryMut::Occupied(o) => Self::Occupied(o.into()),
vecmap::RawEntryMut::Vacant(v) => Self::Vacant(v.into()),
}
}
}
impl<'map, K, V, S> From<hash_map::RawEntryMut<'map, K, V, S>> for RawEntryMut<'map, K, V, S> {
fn from(e: hash_map::RawEntryMut<'map, K, V, S>) -> Self {
match e {
hash_map::RawEntryMut::Occupied(o) => Self::Occupied(o.into()),
hash_map::RawEntryMut::Vacant(v) => Self::Vacant(v.into()),
}
}
}
pub struct RawOccupiedEntryMut<'map, K, V, S>(RawOccupiedEntryMutInt<'map, K, V, S>);
impl<'map, K, V, S> From<vecmap::RawOccupiedEntryMut<'map, K, V, S>>
for RawOccupiedEntryMut<'map, K, V, S>
{
fn from(m: vecmap::RawOccupiedEntryMut<'map, K, V, S>) -> Self {
Self(RawOccupiedEntryMutInt::Vec(m))
}
}
impl<'map, K, V, S> From<hash_map::RawOccupiedEntryMut<'map, K, V, S>>
for RawOccupiedEntryMut<'map, K, V, S>
{
fn from(m: hash_map::RawOccupiedEntryMut<'map, K, V, S>) -> Self {
Self(RawOccupiedEntryMutInt::Map(m))
}
}
unsafe impl<K, V, S> Send for RawOccupiedEntryMut<'_, K, V, S>
where
K: Send,
V: Send,
S: Send,
{
}
unsafe impl<K, V, S> Sync for RawOccupiedEntryMut<'_, K, V, S>
where
K: Sync,
V: Sync,
S: Sync,
{
}
enum RawOccupiedEntryMutInt<'map, K, V, S> {
Vec(vecmap::RawOccupiedEntryMut<'map, K, V, S>),
Map(hash_map::RawOccupiedEntryMut<'map, K, V, S>),
}
unsafe impl<K, V, S> Send for RawOccupiedEntryMutInt<'_, K, V, S>
where
K: Send,
V: Send,
S: Send,
{
}
unsafe impl<K, V, S> Sync for RawOccupiedEntryMutInt<'_, K, V, S>
where
K: Sync,
V: Sync,
S: Sync,
{
}
pub struct RawVacantEntryMut<'map, K, V, S>(RawVacantEntryMutInt<'map, K, V, S>);
impl<'map, K, V, S> From<vecmap::RawVacantEntryMut<'map, K, V, S>>
for RawVacantEntryMut<'map, K, V, S>
{
fn from(m: vecmap::RawVacantEntryMut<'map, K, V, S>) -> Self {
Self(RawVacantEntryMutInt::Vec(m))
}
}
impl<'map, K, V, S> From<hash_map::RawVacantEntryMut<'map, K, V, S>>
for RawVacantEntryMut<'map, K, V, S>
{
fn from(m: hash_map::RawVacantEntryMut<'map, K, V, S>) -> Self {
Self(RawVacantEntryMutInt::Map(m))
}
}
enum RawVacantEntryMutInt<'map, K, V, S> {
Vec(vecmap::RawVacantEntryMut<'map, K, V, S>),
Map(hash_map::RawVacantEntryMut<'map, K, V, S>),
}
pub struct RawEntryBuilder<'map, K, V, S>(RawEntryBuilderInt<'map, K, V, S>);
impl<'map, K, V, S> From<hash_map::RawEntryBuilder<'map, K, V, S>>
for RawEntryBuilder<'map, K, V, S>
{
fn from(m: hash_map::RawEntryBuilder<'map, K, V, S>) -> Self {
Self(RawEntryBuilderInt::Map(m))
}
}
impl<'map, K, V, S> From<vecmap::RawEntryBuilder<'map, K, V, S>>
for RawEntryBuilder<'map, K, V, S>
{
fn from(m: vecmap::RawEntryBuilder<'map, K, V, S>) -> Self {
Self(RawEntryBuilderInt::Vec(m))
}
}
enum RawEntryBuilderInt<'map, K, V, S> {
Vec(vecmap::RawEntryBuilder<'map, K, V, S>),
Map(hash_map::RawEntryBuilder<'map, K, V, S>),
}
impl<'map, K, V, S> RawEntryBuilderMut<'map, K, V, S>
where
S: BuildHasher,
{
#[inline]
#[allow(clippy::wrong_self_convention)]
pub fn from_key<Q: ?Sized>(self, k: &Q) -> RawEntryMut<'map, K, V, S>
where
K: Borrow<Q>,
Q: Hash + Eq,
{
match self.0 {
RawEntryBuilderMutInt::Vec(m) => m.from_key(k).into(),
RawEntryBuilderMutInt::Map(m) => m.from_key(k).into(),
}
}
#[inline]
#[allow(clippy::wrong_self_convention)]
pub fn from_key_hashed_nocheck<Q: ?Sized>(self, hash: u64, k: &Q) -> RawEntryMut<'map, K, V, S>
where
K: Borrow<Q>,
Q: Eq,
{
match self.0 {
RawEntryBuilderMutInt::Vec(m) => m.from_key_hashed_nocheck(hash, k).into(),
RawEntryBuilderMutInt::Map(m) => m.from_key_hashed_nocheck(hash, k).into(),
}
}
}
impl<'map, K, V, S> RawEntryBuilderMut<'map, K, V, S>
where
S: BuildHasher,
{
#[inline]
#[allow(clippy::wrong_self_convention)]
pub fn from_hash<F>(self, hash: u64, is_match: F) -> RawEntryMut<'map, K, V, S>
where
for<'b> F: FnMut(&'b K) -> bool,
{
match self.0 {
RawEntryBuilderMutInt::Vec(m) => m.from_hash(hash, is_match).into(),
RawEntryBuilderMutInt::Map(m) => m.from_hash(hash, is_match).into(),
}
}
}
impl<'map, K, V, S> RawEntryBuilder<'map, K, V, S>
where
S: BuildHasher,
{
#[inline]
#[allow(clippy::wrong_self_convention)]
pub fn from_key<Q: ?Sized>(self, k: &Q) -> Option<(&'map K, &'map V)>
where
K: Borrow<Q>,
Q: Hash + Eq,
{
match self.0 {
RawEntryBuilderInt::Vec(m) => m.from_key(k),
RawEntryBuilderInt::Map(m) => m.from_key(k),
}
}
#[inline]
#[allow(clippy::wrong_self_convention)]
pub fn from_key_hashed_nocheck<Q: ?Sized>(self, hash: u64, k: &Q) -> Option<(&'map K, &'map V)>
where
K: Borrow<Q>,
Q: Hash + Eq,
{
match self.0 {
RawEntryBuilderInt::Vec(m) => m.from_key_hashed_nocheck(hash, k),
RawEntryBuilderInt::Map(m) => m.from_key_hashed_nocheck(hash, k),
}
}
#[inline]
#[allow(clippy::wrong_self_convention)]
pub fn from_hash<F>(self, hash: u64, is_match: F) -> Option<(&'map K, &'map V)>
where
F: FnMut(&K) -> bool,
{
match self.0 {
RawEntryBuilderInt::Vec(m) => m.from_hash(hash, is_match),
RawEntryBuilderInt::Map(m) => m.from_hash(hash, is_match),
}
}
}
impl<'map, K, V, S> RawEntryMut<'map, K, V, S>
where
S: BuildHasher,
{
#[inline]
pub fn insert(self, key: K, value: V) -> RawOccupiedEntryMut<'map, K, V, S>
where
K: Hash,
S: BuildHasher,
{
match self {
RawEntryMut::Occupied(mut entry) => {
entry.insert(value);
entry
}
RawEntryMut::Vacant(entry) => {
match entry.0 {
RawVacantEntryMutInt::Vec(e) => {
vecmap::RawEntryMut::Vacant(e).insert(key, value).into()
}
RawVacantEntryMutInt::Map(e) => {
hash_map::RawEntryMut::Vacant(e).insert(key, value).into()
}
}
}
}
}
#[inline]
pub fn or_insert(self, default_key: K, default_val: V) -> (&'map mut K, &'map mut V)
where
K: Hash,
S: BuildHasher,
{
match self {
RawEntryMut::Occupied(entry) => entry.into_key_value(),
RawEntryMut::Vacant(entry) => entry.insert(default_key, default_val),
}
}
#[inline]
pub fn or_insert_with<F>(self, default: F) -> (&'map mut K, &'map mut V)
where
F: FnOnce() -> (K, V),
K: Hash,
S: BuildHasher,
{
match self {
RawEntryMut::Occupied(entry) => entry.into_key_value(),
RawEntryMut::Vacant(entry) => {
let (k, v) = default();
entry.insert(k, v)
}
}
}
#[inline]
pub fn and_modify<F>(self, f: F) -> Self
where
F: FnOnce(&mut K, &mut V),
{
match self {
RawEntryMut::Occupied(mut entry) => {
{
let (k, v) = entry.get_key_value_mut();
f(k, v);
}
RawEntryMut::Occupied(entry)
}
RawEntryMut::Vacant(entry) => RawEntryMut::Vacant(entry),
}
}
}
impl<'map, K, V, S> RawOccupiedEntryMut<'map, K, V, S>
where
S: BuildHasher,
{
#[inline]
#[must_use]
pub fn key(&self) -> &K {
match &self.0 {
RawOccupiedEntryMutInt::Vec(e) => e.key(),
RawOccupiedEntryMutInt::Map(e) => e.key(),
}
}
#[inline]
pub fn key_mut(&mut self) -> &mut K {
match &mut self.0 {
RawOccupiedEntryMutInt::Vec(e) => e.key_mut(),
RawOccupiedEntryMutInt::Map(e) => e.key_mut(),
}
}
#[inline]
#[must_use]
pub fn into_key(self) -> &'map mut K {
match self.0 {
RawOccupiedEntryMutInt::Vec(e) => e.into_key(),
RawOccupiedEntryMutInt::Map(e) => e.into_key(),
}
}
#[inline]
#[must_use]
pub fn get(&self) -> &V {
match &self.0 {
RawOccupiedEntryMutInt::Vec(e) => e.get(),
RawOccupiedEntryMutInt::Map(e) => e.get(),
}
}
#[inline]
#[must_use]
pub fn into_mut(self) -> &'map mut V {
match self.0 {
RawOccupiedEntryMutInt::Vec(e) => e.into_mut(),
RawOccupiedEntryMutInt::Map(e) => e.into_mut(),
}
}
#[inline]
pub fn get_mut(&mut self) -> &mut V {
match &mut self.0 {
RawOccupiedEntryMutInt::Vec(e) => e.get_mut(),
RawOccupiedEntryMutInt::Map(e) => e.get_mut(),
}
}
#[inline]
pub fn get_key_value(&mut self) -> (&K, &V) {
match &mut self.0 {
RawOccupiedEntryMutInt::Vec(e) => e.get_key_value(),
RawOccupiedEntryMutInt::Map(e) => e.get_key_value(),
}
}
#[inline]
pub fn get_key_value_mut(&mut self) -> (&mut K, &mut V) {
match &mut self.0 {
RawOccupiedEntryMutInt::Vec(e) => e.get_key_value_mut(),
RawOccupiedEntryMutInt::Map(e) => e.get_key_value_mut(),
}
}
#[inline]
#[must_use]
pub fn into_key_value(self) -> (&'map mut K, &'map mut V) {
match self.0 {
RawOccupiedEntryMutInt::Vec(e) => e.into_key_value(),
RawOccupiedEntryMutInt::Map(e) => e.into_key_value(),
}
}
#[inline]
pub fn insert(&mut self, value: V) -> V {
match &mut self.0 {
RawOccupiedEntryMutInt::Vec(e) => e.insert(value),
RawOccupiedEntryMutInt::Map(e) => e.insert(value),
}
}
#[inline]
pub fn insert_key(&mut self, key: K) -> K {
match &mut self.0 {
RawOccupiedEntryMutInt::Vec(e) => e.insert_key(key),
RawOccupiedEntryMutInt::Map(e) => e.insert_key(key),
}
}
#[inline]
#[must_use]
pub fn remove(self) -> V {
match self.0 {
RawOccupiedEntryMutInt::Vec(e) => e.remove(),
RawOccupiedEntryMutInt::Map(e) => e.remove(),
}
}
#[inline]
#[must_use]
pub fn remove_entry(self) -> (K, V) {
match self.0 {
RawOccupiedEntryMutInt::Vec(e) => e.remove_entry(),
RawOccupiedEntryMutInt::Map(e) => e.remove_entry(),
}
}
}
impl<'map, K, V, S> RawVacantEntryMut<'map, K, V, S>
where
S: BuildHasher,
{
#[inline]
pub fn insert(self, key: K, value: V) -> (&'map mut K, &'map mut V)
where
K: Hash,
S: BuildHasher,
{
match self.0 {
RawVacantEntryMutInt::Vec(e) => e.insert(key, value),
RawVacantEntryMutInt::Map(e) => e.insert(key, value),
}
}
#[inline]
#[allow(clippy::shadow_unrelated)]
pub fn insert_hashed_nocheck(self, hash: u64, key: K, value: V) -> (&'map mut K, &'map mut V)
where
K: Hash,
S: BuildHasher,
{
match self.0 {
RawVacantEntryMutInt::Vec(e) => e.insert_hashed_nocheck(hash, key, value),
RawVacantEntryMutInt::Map(e) => e.insert_hashed_nocheck(hash, key, value),
}
}
#[inline]
pub fn insert_with_hasher<H>(
self,
hash: u64,
key: K,
value: V,
hasher: H,
) -> (&'map mut K, &'map mut V)
where
S: BuildHasher,
H: Fn(&K) -> u64,
{
match self.0 {
RawVacantEntryMutInt::Vec(e) => e.insert_with_hasher(hash, key, value, hasher),
RawVacantEntryMutInt::Map(e) => e.insert_with_hasher(hash, key, value, hasher),
}
}
}
impl<K, V, S> Debug for RawEntryBuilderMut<'_, K, V, S> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("RawEntryBuilder").finish()
}
}
impl<K: Debug, V: Debug, S> Debug for RawEntryMut<'_, K, V, S>
where
S: BuildHasher,
{
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match *self {
RawEntryMut::Vacant(ref v) => f.debug_tuple("RawEntry").field(v).finish(),
RawEntryMut::Occupied(ref o) => f.debug_tuple("RawEntry").field(o).finish(),
}
}
}
impl<K: Debug, V: Debug, S> Debug for RawOccupiedEntryMut<'_, K, V, S>
where
S: BuildHasher,
{
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("RawOccupiedEntryMut")
.field("key", self.key())
.field("value", self.get())
.finish()
}
}
impl<K, V, S> Debug for RawVacantEntryMut<'_, K, V, S> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("RawVacantEntryMut").finish()
}
}
impl<K, V, S> Debug for RawEntryBuilder<'_, K, V, S> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("RawEntryBuilder").finish()
}
}