DeCarabas/oden
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Vendor things

Browse source
This commit is contained in:
John Doty 2024-03-08 11:03:01 -08:00
parent 5deceec006
commit 977e3c17e5
19434 changed files with 10682014 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

1
third-party/vendor/phf/.cargo-checksum.json vendored Normal file
View file

@ -0,0 +1 @@
{"files":{"Cargo.toml":"29149d1a0e11a422264675eb6229a7827acf187d1c5f8cc4b9c1cb2bf4ac9ae4","src/lib.rs":"a4d7dede221bdc3d69939a066a058e1a627e57777f7beab1baa93e452eb8fe67","src/map.rs":"755c39145d701560be45c731e81f9e3e60c884d00d1b6dea8e4614f9278a9d88","src/ordered_map.rs":"0b18597047bd5c782ccd4b2f54122e88cd020f930aa6f1436c3c5819d729decf","src/ordered_set.rs":"0ed66947623c8a79b1ad2c206ef5a13af701f95c0f36544ab986c9617e2a24a3","src/set.rs":"065a501930c4667877168b99aeca00007dd222865bafc26451cbc9fdf08ad7e6"},"package":"fabbf1ead8a5bcbc20f5f8b939ee3f5b0f6f281b6ad3468b84656b658b455259"}

49
third-party/vendor/phf/Cargo.toml vendored Normal file
View file

@ -0,0 +1,49 @@
# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
#
# When uploading crates to the registry Cargo will automatically
# "normalize" Cargo.toml files for maximal compatibility
# with all versions of Cargo and also rewrite `path` dependencies
# to registry (e.g., crates.io) dependencies.
#
# If you are reading this file be aware that the original Cargo.toml
# will likely look very different (and much more reasonable).
# See Cargo.toml.orig for the original contents.
[package]
edition = "2018"
name = "phf"
version = "0.10.1"
authors = ["Steven Fackler <sfackler@gmail.com>"]
description = "Runtime support for perfect hash function data structures"
readme = "../README.md"
license = "MIT"
repository = "https://github.com/sfackler/rust-phf"
[package.metadata.docs.rs]
features = ["macros"]
[lib]
name = "phf"
path = "src/lib.rs"
test = false
[dependencies.phf_macros]
version = "0.10.0"
optional = true
[dependencies.phf_shared]
version = "0.10.0"
default-features = false
[dependencies.proc-macro-hack]
version = "0.5.4"
optional = true
[dependencies.serde]
version = "1.0"
optional = true
[features]
default = ["std"]
macros = ["phf_macros", "proc-macro-hack"]
std = ["phf_shared/std"]
uncased = ["phf_shared/uncased"]
unicase = ["phf_shared/unicase"]

157
third-party/vendor/phf/src/lib.rs vendored Normal file
View file

@ -0,0 +1,157 @@
//! Rust-PHF is a library to generate efficient lookup tables at compile time using
//! [perfect hash functions](http://en.wikipedia.org/wiki/Perfect_hash_function).
//!
//! It currently uses the
//! [CHD algorithm](http://cmph.sourceforge.net/papers/esa09.pdf) and can generate
//! a 100,000 entry map in roughly .4 seconds. By default statistics are not
//! produced, but if you set the environment variable `PHF_STATS` it will issue
//! a compiler note about how long it took.
//!
//! MSRV (minimum supported rust version) is Rust 1.46.
//!
//! ## Usage
//!
//! PHF data structures can be constructed via either the procedural
//! macros in the `phf_macros` crate or code generation supported by the
//! `phf_codegen` crate. If you prefer macros, you can easily use them by
//! enabling the `macros` feature of the `phf` crate, like:
//!
//!```toml
//! [dependencies]
//! phf = { version = "0.10", features = ["macros"] }
//! ```
//!
//! To compile the `phf` crate with a dependency on
//! libcore instead of libstd, enabling use in environments where libstd
//! will not work, set `default-features = false` for the dependency:
//!
//! ```toml
//! [dependencies]
//! # to use `phf` in `no_std` environments
//! phf = { version = "0.10", default-features = false }
//! ```
//!
//! ## Example (with the `macros` feature enabled)
//!
//! ```rust
//! use phf::phf_map;
//!
//! #[derive(Clone)]
//! pub enum Keyword {
//! Loop,
//! Continue,
//! Break,
//! Fn,
//! Extern,
//! }
//!
//! static KEYWORDS: phf::Map<&'static str, Keyword> = phf_map! {
//! "loop" => Keyword::Loop,
//! "continue" => Keyword::Continue,
//! "break" => Keyword::Break,
//! "fn" => Keyword::Fn,
//! "extern" => Keyword::Extern,
//! };
//!
//! pub fn parse_keyword(keyword: &str) -> Option<Keyword> {
//! KEYWORDS.get(keyword).cloned()
//! }
//! ```
//!
//! Alternatively, you can use the [`phf_codegen`] crate to generate PHF datatypes
//! in a build script.
//!
//! [`phf_codegen`]: https://docs.rs/phf_codegen
//!
//! ## Note
//!
//! Currently, the macro syntax has some limitations and may not
//! work as you want. See [#183] or [#196] for example.
//!
//! [#183]: https://github.com/rust-phf/rust-phf/issues/183
//! [#196]: https://github.com/rust-phf/rust-phf/issues/196
#![doc(html_root_url = "https://docs.rs/phf/0.10")]
#![warn(missing_docs)]
#![cfg_attr(not(feature = "std"), no_std)]
#[cfg(feature = "std")]
extern crate std as core;
#[cfg(feature = "macros")]
/// Macro to create a `static` (compile-time) [`Map`].
///
/// Requires the `macros` feature.
///
/// Supported key expressions are:
/// - literals: bools, (byte) strings, bytes, chars, and integers (these must have a type suffix)
/// - arrays of `u8` integers
/// - `UniCase::unicode(string)` or `UniCase::ascii(string)` if the `unicase` feature is enabled
///
/// # Example
///
/// ```
/// use phf::{phf_map, Map};
///
/// static MY_MAP: Map<&'static str, u32> = phf_map! {
/// "hello" => 1,
/// "world" => 2,
/// };
///
/// fn main () {
/// assert_eq!(MY_MAP["hello"], 1);
/// }
/// ```
#[proc_macro_hack::proc_macro_hack]
pub use phf_macros::phf_map;
#[cfg(feature = "macros")]
/// Macro to create a `static` (compile-time) [`OrderedMap`].
///
/// Requires the `macros` feature. Same usage as [`phf_map`].
#[proc_macro_hack::proc_macro_hack]
pub use phf_macros::phf_ordered_map;
#[cfg(feature = "macros")]
/// Macro to create a `static` (compile-time) [`Set`].
///
/// Requires the `macros` feature.
///
/// # Example
///
/// ```
/// use phf::{phf_set, Set};
///
/// static MY_SET: Set<&'static str> = phf_set! {
/// "hello world",
/// "hola mundo",
/// };
///
/// fn main () {
/// assert!(MY_SET.contains("hello world"));
/// }
/// ```
#[proc_macro_hack::proc_macro_hack]
pub use phf_macros::phf_set;
#[cfg(feature = "macros")]
/// Macro to create a `static` (compile-time) [`OrderedSet`].
///
/// Requires the `macros` feature. Same usage as [`phf_set`].
#[proc_macro_hack::proc_macro_hack]
pub use phf_macros::phf_ordered_set;
#[doc(inline)]
pub use self::map::Map;
#[doc(inline)]
pub use self::ordered_map::OrderedMap;
#[doc(inline)]
pub use self::ordered_set::OrderedSet;
#[doc(inline)]
pub use self::set::Set;
pub use phf_shared::PhfHash;
pub mod map;
pub mod ordered_map;
pub mod ordered_set;
pub mod set;

301
third-party/vendor/phf/src/map.rs vendored Normal file
View file

@ -0,0 +1,301 @@
//! An immutable map constructed at compile time.
use core::fmt;
use core::iter::FusedIterator;
use core::iter::IntoIterator;
use core::ops::Index;
use core::slice;
use phf_shared::{self, HashKey, PhfBorrow, PhfHash};
#[cfg(feature = "serde")]
use serde::ser::{Serialize, SerializeMap, Serializer};
/// An immutable map constructed at compile time.
///
/// ## Note
///
/// The fields of this struct are public so that they may be initialized by the
/// `phf_map!` macro and code generation. They are subject to change at any
/// time and should never be accessed directly.
pub struct Map<K: 'static, V: 'static> {
#[doc(hidden)]
pub key: HashKey,
#[doc(hidden)]
pub disps: &'static [(u32, u32)],
#[doc(hidden)]
pub entries: &'static [(K, V)],
}
impl<K, V> fmt::Debug for Map<K, V>
where
K: fmt::Debug,
V: fmt::Debug,
{
fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt.debug_map().entries(self.entries()).finish()
}
}
impl<'a, K, V, T: ?Sized> Index<&'a T> for Map<K, V>
where
T: Eq + PhfHash,
K: PhfBorrow<T>,
{
type Output = V;
fn index(&self, k: &'a T) -> &V {
self.get(k).expect("invalid key")
}
}
impl<K, V> Map<K, V> {
/// Returns the number of entries in the `Map`.
#[inline]
pub const fn len(&self) -> usize {
self.entries.len()
}
/// Returns true if the `Map` is empty.
#[inline]
pub const fn is_empty(&self) -> bool {
self.len() == 0
}
/// Determines if `key` is in the `Map`.
pub fn contains_key<T: ?Sized>(&self, key: &T) -> bool
where
T: Eq + PhfHash,
K: PhfBorrow<T>,
{
self.get(key).is_some()
}
/// Returns a reference to the value that `key` maps to.
pub fn get<T: ?Sized>(&self, key: &T) -> Option<&V>
where
T: Eq + PhfHash,
K: PhfBorrow<T>,
{
self.get_entry(key).map(|e| e.1)
}
/// Returns a reference to the map's internal static instance of the given
/// key.
///
/// This can be useful for interning schemes.
pub fn get_key<T: ?Sized>(&self, key: &T) -> Option<&K>
where
T: Eq + PhfHash,
K: PhfBorrow<T>,
{
self.get_entry(key).map(|e| e.0)
}
/// Like `get`, but returns both the key and the value.
pub fn get_entry<T: ?Sized>(&self, key: &T) -> Option<(&K, &V)>
where
T: Eq + PhfHash,
K: PhfBorrow<T>,
{
if self.disps.is_empty() {
return None;
} //Prevent panic on empty map
let hashes = phf_shared::hash(key, &self.key);
let index = phf_shared::get_index(&hashes, &*self.disps, self.entries.len());
let entry = &self.entries[index as usize];
let b: &T = entry.0.borrow();
if b == key {
Some((&entry.0, &entry.1))
} else {
None
}
}
/// Returns an iterator over the key/value pairs in the map.
///
/// Entries are returned in an arbitrary but fixed order.
pub fn entries(&self) -> Entries<'_, K, V> {
Entries {
iter: self.entries.iter(),
}
}
/// Returns an iterator over the keys in the map.
///
/// Keys are returned in an arbitrary but fixed order.
pub fn keys(&self) -> Keys<'_, K, V> {
Keys {
iter: self.entries(),
}
}
/// Returns an iterator over the values in the map.
///
/// Values are returned in an arbitrary but fixed order.
pub fn values(&self) -> Values<'_, K, V> {
Values {
iter: self.entries(),
}
}
}
impl<'a, K, V> IntoIterator for &'a Map<K, V> {
type Item = (&'a K, &'a V);
type IntoIter = Entries<'a, K, V>;
fn into_iter(self) -> Entries<'a, K, V> {
self.entries()
}
}
/// An iterator over the key/value pairs in a `Map`.
pub struct Entries<'a, K, V> {
iter: slice::Iter<'a, (K, V)>,
}
impl<'a, K, V> Clone for Entries<'a, K, V> {
#[inline]
fn clone(&self) -> Self {
Self {
iter: self.iter.clone(),
}
}
}
impl<'a, K, V> fmt::Debug for Entries<'a, K, V>
where
K: fmt::Debug,
V: fmt::Debug,
{
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_list().entries(self.clone()).finish()
}
}
impl<'a, K, V> Iterator for Entries<'a, K, V> {
type Item = (&'a K, &'a V);
fn next(&mut self) -> Option<(&'a K, &'a V)> {
self.iter.next().map(|&(ref k, ref v)| (k, v))
}
fn size_hint(&self) -> (usize, Option<usize>) {
self.iter.size_hint()
}
}
impl<'a, K, V> DoubleEndedIterator for Entries<'a, K, V> {
fn next_back(&mut self) -> Option<(&'a K, &'a V)> {
self.iter.next_back().map(|e| (&e.0, &e.1))
}
}
impl<'a, K, V> ExactSizeIterator for Entries<'a, K, V> {}
impl<'a, K, V> FusedIterator for Entries<'a, K, V> {}
/// An iterator over the keys in a `Map`.
pub struct Keys<'a, K, V> {
iter: Entries<'a, K, V>,
}
impl<'a, K, V> Clone for Keys<'a, K, V> {
#[inline]
fn clone(&self) -> Self {
Self {
iter: self.iter.clone(),
}
}
}
impl<'a, K, V> fmt::Debug for Keys<'a, K, V>
where
K: fmt::Debug,
{
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_list().entries(self.clone()).finish()
}
}
impl<'a, K, V> Iterator for Keys<'a, K, V> {
type Item = &'a K;
fn next(&mut self) -> Option<&'a K> {
self.iter.next().map(|e| e.0)
}
fn size_hint(&self) -> (usize, Option<usize>) {
self.iter.size_hint()
}
}
impl<'a, K, V> DoubleEndedIterator for Keys<'a, K, V> {
fn next_back(&mut self) -> Option<&'a K> {
self.iter.next_back().map(|e| e.0)
}
}
impl<'a, K, V> ExactSizeIterator for Keys<'a, K, V> {}
impl<'a, K, V> FusedIterator for Keys<'a, K, V> {}
/// An iterator over the values in a `Map`.
pub struct Values<'a, K, V> {
iter: Entries<'a, K, V>,
}
impl<'a, K, V> Clone for Values<'a, K, V> {
#[inline]
fn clone(&self) -> Self {
Self {
iter: self.iter.clone(),
}
}
}
impl<'a, K, V> fmt::Debug for Values<'a, K, V>
where
V: fmt::Debug,
{
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_list().entries(self.clone()).finish()
}
}
impl<'a, K, V> Iterator for Values<'a, K, V> {
type Item = &'a V;
fn next(&mut self) -> Option<&'a V> {
self.iter.next().map(|e| e.1)
}
fn size_hint(&self) -> (usize, Option<usize>) {
self.iter.size_hint()
}
}
impl<'a, K, V> DoubleEndedIterator for Values<'a, K, V> {
fn next_back(&mut self) -> Option<&'a V> {
self.iter.next_back().map(|e| e.1)
}
}
impl<'a, K, V> ExactSizeIterator for Values<'a, K, V> {}
impl<'a, K, V> FusedIterator for Values<'a, K, V> {}
#[cfg(feature = "serde")]
impl<K, V> Serialize for Map<K, V>
where
K: Serialize,
V: Serialize,
{
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
let mut map = serializer.serialize_map(Some(self.len()))?;
for (k, v) in self.entries() {
map.serialize_entry(k, v)?;
}
map.end()
}
}

312
third-party/vendor/phf/src/ordered_map.rs vendored Normal file
View file

@ -0,0 +1,312 @@
//! An order-preserving immutable map constructed at compile time.
use core::fmt;
use core::iter::FusedIterator;
use core::iter::IntoIterator;
use core::ops::Index;
use core::slice;
use phf_shared::{self, HashKey, PhfBorrow, PhfHash};
/// An order-preserving immutable map constructed at compile time.
///
/// Unlike a `Map`, iteration order is guaranteed to match the definition
/// order.
///
/// ## Note
///
/// The fields of this struct are public so that they may be initialized by the
/// `phf_ordered_map!` macro and code generation. They are subject to change at
/// any time and should never be accessed directly.
pub struct OrderedMap<K: 'static, V: 'static> {
#[doc(hidden)]
pub key: HashKey,
#[doc(hidden)]
pub disps: &'static [(u32, u32)],
#[doc(hidden)]
pub idxs: &'static [usize],
#[doc(hidden)]
pub entries: &'static [(K, V)],
}
impl<K, V> fmt::Debug for OrderedMap<K, V>
where
K: fmt::Debug,
V: fmt::Debug,
{
fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt.debug_map().entries(self.entries()).finish()
}
}
impl<'a, K, V, T: ?Sized> Index<&'a T> for OrderedMap<K, V>
where
T: Eq + PhfHash,
K: PhfBorrow<T>,
{
type Output = V;
fn index(&self, k: &'a T) -> &V {
self.get(k).expect("invalid key")
}
}
impl<K, V> OrderedMap<K, V> {
/// Returns the number of entries in the `OrderedMap`.
#[inline]
pub const fn len(&self) -> usize {
self.entries.len()
}
/// Returns true if the `OrderedMap` is empty.
#[inline]
pub const fn is_empty(&self) -> bool {
self.len() == 0
}
/// Returns a reference to the value that `key` maps to.
pub fn get<T: ?Sized>(&self, key: &T) -> Option<&V>
where
T: Eq + PhfHash,
K: PhfBorrow<T>,
{
self.get_entry(key).map(|e| e.1)
}
/// Returns a reference to the map's internal static instance of the given
/// key.
///
/// This can be useful for interning schemes.
pub fn get_key<T: ?Sized>(&self, key: &T) -> Option<&K>
where
T: Eq + PhfHash,
K: PhfBorrow<T>,
{
self.get_entry(key).map(|e| e.0)
}
/// Determines if `key` is in the `OrderedMap`.
pub fn contains_key<T: ?Sized>(&self, key: &T) -> bool
where
T: Eq + PhfHash,
K: PhfBorrow<T>,
{
self.get(key).is_some()
}
/// Returns the index of the key within the list used to initialize
/// the ordered map.
pub fn get_index<T: ?Sized>(&self, key: &T) -> Option<usize>
where
T: Eq + PhfHash,
K: PhfBorrow<T>,
{
self.get_internal(key).map(|(i, _)| i)
}
/// Returns references to both the key and values at an index
/// within the list used to initialize the ordered map. See `.get_index(key)`.
pub fn index(&self, index: usize) -> Option<(&K, &V)> {
self.entries.get(index).map(|&(ref k, ref v)| (k, v))
}
/// Like `get`, but returns both the key and the value.
pub fn get_entry<T: ?Sized>(&self, key: &T) -> Option<(&K, &V)>
where
T: Eq + PhfHash,
K: PhfBorrow<T>,
{
self.get_internal(key).map(|(_, e)| e)
}
fn get_internal<T: ?Sized>(&self, key: &T) -> Option<(usize, (&K, &V))>
where
T: Eq + PhfHash,
K: PhfBorrow<T>,
{
if self.disps.is_empty() {
return None;
} //Prevent panic on empty map
let hashes = phf_shared::hash(key, &self.key);
let idx_index = phf_shared::get_index(&hashes, &*self.disps, self.idxs.len());
let idx = self.idxs[idx_index as usize];
let entry = &self.entries[idx];
let b: &T = entry.0.borrow();
if b == key {
Some((idx, (&entry.0, &entry.1)))
} else {
None
}
}
/// Returns an iterator over the key/value pairs in the map.
///
/// Entries are returned in the same order in which they were defined.
pub fn entries(&self) -> Entries<'_, K, V> {
Entries {
iter: self.entries.iter(),
}
}
/// Returns an iterator over the keys in the map.
///
/// Keys are returned in the same order in which they were defined.
pub fn keys(&self) -> Keys<'_, K, V> {
Keys {
iter: self.entries(),
}
}
/// Returns an iterator over the values in the map.
///
/// Values are returned in the same order in which they were defined.
pub fn values(&self) -> Values<'_, K, V> {
Values {
iter: self.entries(),
}
}
}
impl<'a, K, V> IntoIterator for &'a OrderedMap<K, V> {
type Item = (&'a K, &'a V);
type IntoIter = Entries<'a, K, V>;
fn into_iter(self) -> Entries<'a, K, V> {
self.entries()
}
}
/// An iterator over the entries in a `OrderedMap`.
pub struct Entries<'a, K, V> {
iter: slice::Iter<'a, (K, V)>,
}
impl<'a, K, V> Clone for Entries<'a, K, V> {
#[inline]
fn clone(&self) -> Self {
Self {
iter: self.iter.clone(),
}
}
}
impl<'a, K, V> fmt::Debug for Entries<'a, K, V>
where
K: fmt::Debug,
V: fmt::Debug,
{
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_list().entries(self.clone()).finish()
}
}
impl<'a, K, V> Iterator for Entries<'a, K, V> {
type Item = (&'a K, &'a V);
fn next(&mut self) -> Option<(&'a K, &'a V)> {
self.iter.next().map(|e| (&e.0, &e.1))
}
fn size_hint(&self) -> (usize, Option<usize>) {
self.iter.size_hint()
}
}
impl<'a, K, V> DoubleEndedIterator for Entries<'a, K, V> {
fn next_back(&mut self) -> Option<(&'a K, &'a V)> {
self.iter.next_back().map(|e| (&e.0, &e.1))
}
}
impl<'a, K, V> ExactSizeIterator for Entries<'a, K, V> {}
impl<'a, K, V> FusedIterator for Entries<'a, K, V> {}
/// An iterator over the keys in a `OrderedMap`.
pub struct Keys<'a, K, V> {
iter: Entries<'a, K, V>,
}
impl<'a, K, V> Clone for Keys<'a, K, V> {
#[inline]
fn clone(&self) -> Self {
Self {
iter: self.iter.clone(),
}
}
}
impl<'a, K, V> fmt::Debug for Keys<'a, K, V>
where
K: fmt::Debug,
{
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_list().entries(self.clone()).finish()
}
}
impl<'a, K, V> Iterator for Keys<'a, K, V> {
type Item = &'a K;
fn next(&mut self) -> Option<&'a K> {
self.iter.next().map(|e| e.0)
}
fn size_hint(&self) -> (usize, Option<usize>) {
self.iter.size_hint()
}
}
impl<'a, K, V> DoubleEndedIterator for Keys<'a, K, V> {
fn next_back(&mut self) -> Option<&'a K> {
self.iter.next_back().map(|e| e.0)
}
}
impl<'a, K, V> ExactSizeIterator for Keys<'a, K, V> {}
impl<'a, K, V> FusedIterator for Keys<'a, K, V> {}
/// An iterator over the values in a `OrderedMap`.
pub struct Values<'a, K, V> {
iter: Entries<'a, K, V>,
}
impl<'a, K, V> Clone for Values<'a, K, V> {
#[inline]
fn clone(&self) -> Self {
Self {
iter: self.iter.clone(),
}
}
}
impl<'a, K, V> fmt::Debug for Values<'a, K, V>
where
V: fmt::Debug,
{
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_list().entries(self.clone()).finish()
}
}
impl<'a, K, V> Iterator for Values<'a, K, V> {
type Item = &'a V;
fn next(&mut self) -> Option<&'a V> {
self.iter.next().map(|e| e.1)
}
fn size_hint(&self) -> (usize, Option<usize>) {
self.iter.size_hint()
}
}
impl<'a, K, V> DoubleEndedIterator for Values<'a, K, V> {
fn next_back(&mut self) -> Option<&'a V> {
self.iter.next_back().map(|e| e.1)
}
}
impl<'a, K, V> ExactSizeIterator for Values<'a, K, V> {}
impl<'a, K, V> FusedIterator for Values<'a, K, V> {}

170
third-party/vendor/phf/src/ordered_set.rs vendored Normal file
View file

@ -0,0 +1,170 @@
//! An order-preserving immutable set constructed at compile time.
use crate::{ordered_map, OrderedMap, PhfHash};
use core::fmt;
use core::iter::FusedIterator;
use core::iter::IntoIterator;
use phf_shared::PhfBorrow;
/// An order-preserving immutable set constructed at compile time.
///
/// Unlike a `Set`, iteration order is guaranteed to match the definition
/// order.
///
/// ## Note
///
/// The fields of this struct are public so that they may be initialized by the
/// `phf_ordered_set!` macro and code generation. They are subject to change at
/// any time and should never be accessed directly.
pub struct OrderedSet<T: 'static> {
#[doc(hidden)]
pub map: OrderedMap<T, ()>,
}
impl<T> fmt::Debug for OrderedSet<T>
where
T: fmt::Debug,
{
fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt.debug_set().entries(self).finish()
}
}
impl<T> OrderedSet<T> {
/// Returns the number of elements in the `OrderedSet`.
#[inline]
pub const fn len(&self) -> usize {
self.map.len()
}
/// Returns true if the `OrderedSet` contains no elements.
#[inline]
pub const fn is_empty(&self) -> bool {
self.len() == 0
}
/// Returns a reference to the set's internal static instance of the given
/// key.
///
/// This can be useful for interning schemes.
pub fn get_key<U: ?Sized>(&self, key: &U) -> Option<&T>
where
U: Eq + PhfHash,
T: PhfBorrow<U>,
{
self.map.get_key(key)
}
/// Returns the index of the key within the list used to initialize
/// the ordered set.
pub fn get_index<U: ?Sized>(&self, key: &U) -> Option<usize>
where
U: Eq + PhfHash,
T: PhfBorrow<U>,
{
self.map.get_index(key)
}
/// Returns a reference to the key at an index
/// within the list used to initialize the ordered set. See `.get_index(key)`.
pub fn index(&self, index: usize) -> Option<&T> {
self.map.index(index).map(|(k, &())| k)
}
/// Returns true if `value` is in the `OrderedSet`.
pub fn contains<U: ?Sized>(&self, value: &U) -> bool
where
U: Eq + PhfHash,
T: PhfBorrow<U>,
{
self.map.contains_key(value)
}
/// Returns an iterator over the values in the set.
///
/// Values are returned in the same order in which they were defined.
pub fn iter(&self) -> Iter<'_, T> {
Iter {
iter: self.map.keys(),
}
}
}
impl<T> OrderedSet<T>
where
T: Eq + PhfHash + PhfBorrow<T>,
{
/// Returns true if `other` shares no elements with `self`.
#[inline]
pub fn is_disjoint(&self, other: &OrderedSet<T>) -> bool {
!self.iter().any(|value| other.contains(value))
}
/// Returns true if `other` contains all values in `self`.
#[inline]
pub fn is_subset(&self, other: &OrderedSet<T>) -> bool {
self.iter().all(|value| other.contains(value))
}
/// Returns true if `self` contains all values in `other`.
#[inline]
pub fn is_superset(&self, other: &OrderedSet<T>) -> bool {
other.is_subset(self)
}
}
impl<'a, T> IntoIterator for &'a OrderedSet<T> {
type Item = &'a T;
type IntoIter = Iter<'a, T>;
fn into_iter(self) -> Iter<'a, T> {
self.iter()
}
}
/// An iterator over the values in a `OrderedSet`.
pub struct Iter<'a, T> {
iter: ordered_map::Keys<'a, T, ()>,
}
impl<'a, T> Clone for Iter<'a, T> {
#[inline]
fn clone(&self) -> Self {
Self {
iter: self.iter.clone(),
}
}
}
impl<'a, T> fmt::Debug for Iter<'a, T>
where
T: fmt::Debug,
{
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_list().entries(self.clone()).finish()
}
}
impl<'a, T> Iterator for Iter<'a, T> {
type Item = &'a T;
#[inline]
fn next(&mut self) -> Option<&'a T> {
self.iter.next()
}
#[inline]
fn size_hint(&self) -> (usize, Option<usize>) {
self.iter.size_hint()
}
}
impl<'a, T> DoubleEndedIterator for Iter<'a, T> {
#[inline]
fn next_back(&mut self) -> Option<&'a T> {
self.iter.next_back()
}
}
impl<'a, T> ExactSizeIterator for Iter<'a, T> {}
impl<'a, T> FusedIterator for Iter<'a, T> {}

147
third-party/vendor/phf/src/set.rs vendored Normal file
View file

@ -0,0 +1,147 @@
//! An immutable set constructed at compile time.
use core::fmt;
use core::iter::FusedIterator;
use core::iter::IntoIterator;
use phf_shared::{PhfBorrow, PhfHash};
use crate::{map, Map};
/// An immutable set constructed at compile time.
///
/// ## Note
///
/// The fields of this struct are public so that they may be initialized by the
/// `phf_set!` macro and code generation. They are subject to change at any
/// time and should never be accessed directly.
pub struct Set<T: 'static> {
#[doc(hidden)]
pub map: Map<T, ()>,
}
impl<T> fmt::Debug for Set<T>
where
T: fmt::Debug,
{
fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt.debug_set().entries(self).finish()
}
}
impl<T> Set<T> {
/// Returns the number of elements in the `Set`.
#[inline]
pub const fn len(&self) -> usize {
self.map.len()
}
/// Returns true if the `Set` contains no elements.
#[inline]
pub const fn is_empty(&self) -> bool {
self.len() == 0
}
/// Returns a reference to the set's internal static instance of the given
/// key.
///
/// This can be useful for interning schemes.
pub fn get_key<U: ?Sized>(&self, key: &U) -> Option<&T>
where
U: Eq + PhfHash,
T: PhfBorrow<U>,
{
self.map.get_key(key)
}
/// Returns true if `value` is in the `Set`.
pub fn contains<U: ?Sized>(&self, value: &U) -> bool
where
U: Eq + PhfHash,
T: PhfBorrow<U>,
{
self.map.contains_key(value)
}
/// Returns an iterator over the values in the set.
///
/// Values are returned in an arbitrary but fixed order.
pub fn iter(&self) -> Iter<'_, T> {
Iter {
iter: self.map.keys(),
}
}
}
impl<T> Set<T>
where
T: Eq + PhfHash + PhfBorrow<T>,
{
/// Returns true if `other` shares no elements with `self`.
pub fn is_disjoint(&self, other: &Set<T>) -> bool {
!self.iter().any(|value| other.contains(value))
}
/// Returns true if `other` contains all values in `self`.
pub fn is_subset(&self, other: &Set<T>) -> bool {
self.iter().all(|value| other.contains(value))
}
/// Returns true if `self` contains all values in `other`.
pub fn is_superset(&self, other: &Set<T>) -> bool {
other.is_subset(self)
}
}
impl<'a, T> IntoIterator for &'a Set<T> {
type Item = &'a T;
type IntoIter = Iter<'a, T>;
fn into_iter(self) -> Iter<'a, T> {
self.iter()
}
}
/// An iterator over the values in a `Set`.
pub struct Iter<'a, T: 'static> {
iter: map::Keys<'a, T, ()>,
}
impl<'a, T> Clone for Iter<'a, T> {
#[inline]
fn clone(&self) -> Self {
Self {
iter: self.iter.clone(),
}
}
}
impl<'a, T> fmt::Debug for Iter<'a, T>
where
T: fmt::Debug,
{
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_list().entries(self.clone()).finish()
}
}
impl<'a, T> Iterator for Iter<'a, T> {
type Item = &'a T;
fn next(&mut self) -> Option<&'a T> {
self.iter.next()
}
fn size_hint(&self) -> (usize, Option<usize>) {
self.iter.size_hint()
}
}
impl<'a, T> DoubleEndedIterator for Iter<'a, T> {
fn next_back(&mut self) -> Option<&'a T> {
self.iter.next_back()
}
}
impl<'a, T> ExactSizeIterator for Iter<'a, T> {}
impl<'a, T> FusedIterator for Iter<'a, T> {}