pub trait IdOrdItem {
type Key<'a>: Ord + Hash
where Self: 'a;
// Required methods
fn key(&self) -> Self::Key<'_>;
fn upcast_key<'short, 'long: 'short>(
long: Self::Key<'long>,
) -> Self::Key<'short>;
}Expand description
An element stored in an IdOrdMap.
This trait is used to define the key type for the map.
§Examples
use iddqd::{IdOrdItem, IdOrdMap, id_upcast};
// Define a struct with a key.
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
struct MyItem {
id: String,
value: u32,
}
// Implement IdOrdItem for the struct.
impl IdOrdItem for MyItem {
// Keys can borrow from the item.
type Key<'a> = &'a str;
fn key(&self) -> Self::Key<'_> {
&self.id
}
id_upcast!();
}
// Create an IdOrdMap and insert items.
let mut map = IdOrdMap::new();
map.insert_unique(MyItem { id: "foo".to_string(), value: 42 }).unwrap();
map.insert_unique(MyItem { id: "bar".to_string(), value: 20 }).unwrap();Required Associated Types§
Sourcetype Key<'a>: Ord + Hash
where
Self: 'a
type Key<'a>: Ord + Hash where Self: 'a
The key type.
The Ord implementation is used for ordered comparisons, while the
Hash implementation is used for RefMut’s change detection.
Ideally Hash would only be required on the methods that need it, but
we require it here due to limitations in current versions of Rust.
As required by Rust, the Hash and Ord (and Eq, which is
required by Ord) implementations must agree with each other. In
particular, if two keys A and B return
Ordering::Equal, then Hash::hash must
return the same value for both A and B. (Strictly speaking, the converse
is not required, but it’s always best to try and match the two up to
hash collisions.)
Required Methods§
Sourcefn upcast_key<'short, 'long: 'short>(
long: Self::Key<'long>,
) -> Self::Key<'short>
fn upcast_key<'short, 'long: 'short>( long: Self::Key<'long>, ) -> Self::Key<'short>
Upcasts the key to a shorter lifetime, in effect asserting that the
lifetime 'a on IdOrdItem::Key is covariant.
Typically implemented via the id_upcast macro.
Dyn Compatibility§
This trait is not dyn compatible.
In older versions of Rust, dyn compatibility was called "object safety".