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 72 73 74 75 76 77 78 79 80 81 82 83 84
//! Case-preserving, ASCII case-insensitive `no_std` string types.
//!
//! An _uncased_ string is case-preserving. That is, the string itself contains
//! cased characters, but comparison (including ordering, equality, and hashing)
//! is ASCII case-insensitive.
//!
//! ```rust
//! use uncased::UncasedStr;
//!
//! let x: &UncasedStr = "hello!".into();
//! let y: &UncasedStr = "HelLo!".into();
//!
//! assert_eq!(x, y);
//! assert_eq!(x.as_str(), "hello!");
//! assert_eq!(y.as_str(), "HelLo!");
//!
//! let x_sub = &x[..4];
//! let y_sub = &y[..4];
//! assert_eq!(x_sub, y_sub);
//! assert_eq!(x_sub.as_str(), "hell");
//! assert_eq!(y_sub.as_str(), "HelL");
//! ```
//!
//! ## Unicode
//!
//! This crate _does not_ perform Unicode case-folding. For Unicode
//! case-folding, see [`unicase`](https://crates.io/crates/unicase).
//!
//! ## Features and `no_std`
//!
//! Crate features:
//!
//! * `alloc` (_default_) - enables the [`Uncased`] type
//! * `with-serde` - enables (de)serializing of [`UncasedStr`] via `serde`
//! * `with-serde-alloc` - enables `alloc`, (de)serializing of [`UncasedStr`]
//! and [`Uncased`] via `serde`
//!
//! This crate is `#![no_std]` compatible. By default, the `alloc` feature is
//! enabled, which enables the [`Uncased`] type but requires `alloc` support. To
//! disable the feature, disable this crate's default features:
//!
//! ```toml
//! [dependencies]
//! uncased = { version = "0.9", default-features = false }
//! ```
//!
//! In addition to the `alloc` feature, support for (de)serializing `UncasedStr`
//! with `serde` can be enabled via the `with-serde` feature. Support for
//! (de)serserializing both `UncasedStr` and `Uncased` can be enabled via the
//! `with-serde-alloc` feature, which implicitly enables the `alloc` feature.
#![no_std]
#![cfg_attr(nightly, feature(doc_cfg))]
#[cfg(feature = "alloc")] extern crate alloc;
#[cfg(feature = "serde")] mod serde;
#[cfg(feature = "alloc")] mod owned;
#[cfg(test)] mod tests;
mod borrowed;
mod as_uncased;
#[cfg(feature = "alloc")] pub use owned::Uncased;
pub use borrowed::UncasedStr;
pub use as_uncased::AsUncased;
/// Returns true if `s1` and `s2` are equal without considering case.
///
/// That is, this function returns `s1.to_ascii_lowercase() ==
/// s2.to_ascii_lowercase()`, but does it in a much faster way. This is also
/// equivalent to `UncasedStr::new(s1) == UncasedStr::new(s2)`.
///
/// # Example
///
/// ```rust
/// assert!(uncased::eq("ENV", "env"));
/// assert!(uncased::eq("bRoWN", "BROWN"));
/// assert!(uncased::eq("hi", "HI"));
/// assert!(uncased::eq("dogs are COOL!", "DOGS are cool!"));
/// ```
#[inline(always)]
pub fn eq<S1: AsRef<str>, S2: AsRef<str>>(s1: S1, s2: S2) -> bool {
UncasedStr::new(s1.as_ref()) == UncasedStr::new(s2.as_ref())
}