1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

//! # keyed
//!
//! Make implementing key-based comparison a little bit easier. Usage:
//!
//! 1. Implement [`Key`](`Key`) trait for your type.
//! 2. Wrap your value in a [`Keyed`](`Keyed`) structure.
//!
//! Example:
//!
//! ```rust
//! use keyed::{Key, Keyed};
//!
//! #[derive(Debug)]
//! struct Item<T> {
//!     key: i32,
//!     value: T,
//! }
//!
//! impl<T> Key for Item<T> {
//!     type Output = i32;
//!
//!     fn key(&self) -> Self::Output {
//!         self.key
//!     }
//! }
//!
//! let lhs = Keyed(Item { key: 4, value: 3 });
//! let rhs = Keyed(Item { key: 4, value: 7 });
//!
//! assert_eq!(lhs, rhs);
//! ```
//!
//! If your key is a reference to internal data, you can use [`RefKey`](`RefKey`) trait and [`RefKeyed`](`RefKeyed`)
//! wrapper:
//!
//! ```rust
//! use keyed::{RefKey, RefKeyed};
//!
//! #[derive(Debug)]
//! struct Item<T> {
//!     key: i32,
//!     value: T,
//! }
//!
//! impl<T> RefKey for Item<T> {
//!     type Output = i32;
//!
//!     fn key(&self) -> &Self::Output {
//!         &self.key
//!     }
//! }
//!
//! let lhs = RefKeyed(Item { key: 4, value: 3 });
//! let rhs = RefKeyed(Item { key: 4, value: 7 });
//!
//! assert_eq!(lhs, rhs);
//! ```

#![no_std]
#![warn(clippy::cargo, clippy::pedantic)]

mod keyed;
mod ref_keyed;

pub use crate::keyed::Key;
pub use crate::keyed::Keyed;
pub use crate::ref_keyed::RefKey;
pub use crate::ref_keyed::RefKeyed;

#[cfg(test)]
mod tests;