Add files using upload-large-folder tool

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/ascii-1.1.0/.github/workflows/ci.yml

@@ -0,0 +1,57 @@
+name: CI
+
+on:
+  pull_request:
+  push:
+    branches:
+      - master
+
+jobs:
+  test:
+    name: Test with Rust ${{ matrix.rust }}
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        rust: [1.41.1, stable, beta, nightly]
+    steps:
+      - uses: actions/checkout@v2
+      - uses: hecrj/setup-rust-action@v1
+        with:
+          rust-version: ${{ matrix.rust }}
+      - run: cargo test --verbose --all-features
+      - run: cargo test --verbose --no-default-features --features alloc
+      - run: cargo test --verbose --no-default-features
+
+  clippy:
+    name: Lint with Clippy
+    runs-on: ubuntu-latest
+    env:
+      RUSTFLAGS: -Dwarnings
+    steps:
+      - uses: actions/checkout@v2
+      - uses: hecrj/setup-rust-action@v1
+        with:
+          components: clippy
+      - run: cargo clippy --all-targets --verbose --no-default-features
+      - run: cargo clippy --all-targets --verbose --all-features
+
+  test-minimal:
+    name: Test minimal dependency version with Rust nightly
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: hecrj/setup-rust-action@v1
+        with:
+          rust-version: nightly
+      - run: cargo test -Zminimal-versions --verbose --all-features
+
+  miri:
+    name: Run tests under `miri` to check for UB
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: dtolnay/rust-toolchain@nightly
+        with:
+          components: miri
+      - run: cargo miri test --all-features

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/ascii-1.1.0/src/ascii_char.rs

@@ -0,0 +1,1069 @@
+use core::cmp::Ordering;
+use core::mem;
+use core::{char, fmt};
+#[cfg(feature = "std")]
+use std::error::Error;
+
+#[allow(non_camel_case_types)]
+/// An ASCII character. It wraps a `u8`, with the highest bit always zero.
+#[derive(Clone, PartialEq, PartialOrd, Ord, Eq, Hash, Copy)]
+#[repr(u8)]
+pub enum AsciiChar {
+    /// `'\0'`
+    Null = 0,
+    /// [Start Of Heading](http://en.wikipedia.org/wiki/Start_of_Heading)
+    SOH = 1,
+    /// [Start Of teXt](http://en.wikipedia.org/wiki/Start_of_Text)
+    SOX = 2,
+    /// [End of TeXt](http://en.wikipedia.org/wiki/End-of-Text_character)
+    ETX = 3,
+    /// [End Of Transmission](http://en.wikipedia.org/wiki/End-of-Transmission_character)
+    EOT = 4,
+    /// [Enquiry](http://en.wikipedia.org/wiki/Enquiry_character)
+    ENQ = 5,
+    /// [Acknowledgement](http://en.wikipedia.org/wiki/Acknowledge_character)
+    ACK = 6,
+    /// [bell / alarm / audible](http://en.wikipedia.org/wiki/Bell_character)
+    ///
+    /// `'\a'` is not recognized by Rust.
+    Bell = 7,
+    /// [Backspace](http://en.wikipedia.org/wiki/Backspace)
+    ///
+    /// `'\b'` is not recognized by Rust.
+    BackSpace = 8,
+    /// `'\t'`
+    Tab = 9,
+    /// `'\n'`
+    LineFeed = 10,
+    /// [Vertical tab](http://en.wikipedia.org/wiki/Vertical_Tab)
+    ///
+    /// `'\v'` is not recognized by Rust.
+    VT = 11,
+    /// [Form Feed](http://en.wikipedia.org/wiki/Form_Feed)
+    ///
+    /// `'\f'` is not recognized by Rust.
+    FF = 12,
+    /// `'\r'`
+    CarriageReturn = 13,
+    /// [Shift In](http://en.wikipedia.org/wiki/Shift_Out_and_Shift_In_characters)
+    SI = 14,
+    /// [Shift Out](http://en.wikipedia.org/wiki/Shift_Out_and_Shift_In_characters)
+    SO = 15,
+    /// [Data Link Escape](http://en.wikipedia.org/wiki/Data_Link_Escape)
+    DLE = 16,
+    /// [Device control 1, often XON](http://en.wikipedia.org/wiki/Device_Control_1)
+    DC1 = 17,
+    /// Device control 2
+    DC2 = 18,
+    /// Device control 3, Often XOFF
+    DC3 = 19,
+    /// Device control 4
+    DC4 = 20,
+    /// [Negative AcKnowledgement](http://en.wikipedia.org/wiki/Negative-acknowledge_character)
+    NAK = 21,
+    /// [Synchronous idle](http://en.wikipedia.org/wiki/Synchronous_Idle)
+    SYN = 22,
+    /// [End of Transmission Block](http://en.wikipedia.org/wiki/End-of-Transmission-Block_character)
+    ETB = 23,
+    /// [Cancel](http://en.wikipedia.org/wiki/Cancel_character)
+    CAN = 24,
+    /// [End of Medium](http://en.wikipedia.org/wiki/End_of_Medium)
+    EM = 25,
+    /// [Substitute](http://en.wikipedia.org/wiki/Substitute_character)
+    SUB = 26,
+    /// [Escape](http://en.wikipedia.org/wiki/Escape_character)
+    ///
+    /// `'\e'` is not recognized by Rust.
+    ESC = 27,
+    /// [File Separator](http://en.wikipedia.org/wiki/File_separator)
+    FS = 28,
+    /// [Group Separator](http://en.wikipedia.org/wiki/Group_separator)
+    GS = 29,
+    /// [Record Separator](http://en.wikipedia.org/wiki/Record_separator)
+    RS = 30,
+    /// [Unit Separator](http://en.wikipedia.org/wiki/Unit_separator)
+    US = 31,
+    /// `' '`
+    Space = 32,
+    /// `'!'`
+    Exclamation = 33,
+    /// `'"'`
+    Quotation = 34,
+    /// `'#'`
+    Hash = 35,
+    /// `'$'`
+    Dollar = 36,
+    /// `'%'`
+    Percent = 37,
+    /// `'&'`
+    Ampersand = 38,
+    /// `'\''`
+    Apostrophe = 39,
+    /// `'('`
+    ParenOpen = 40,
+    /// `')'`
+    ParenClose = 41,
+    /// `'*'`
+    Asterisk = 42,
+    /// `'+'`
+    Plus = 43,
+    /// `','`
+    Comma = 44,
+    /// `'-'`
+    Minus = 45,
+    /// `'.'`
+    Dot = 46,
+    /// `'/'`
+    Slash = 47,
+    /// `'0'`
+    _0 = 48,
+    /// `'1'`
+    _1 = 49,
+    /// `'2'`
+    _2 = 50,
+    /// `'3'`
+    _3 = 51,
+    /// `'4'`
+    _4 = 52,
+    /// `'5'`
+    _5 = 53,
+    /// `'6'`
+    _6 = 54,
+    /// `'7'`
+    _7 = 55,
+    /// `'8'`
+    _8 = 56,
+    /// `'9'`
+    _9 = 57,
+    /// `':'`
+    Colon = 58,
+    /// `';'`
+    Semicolon = 59,
+    /// `'<'`
+    LessThan = 60,
+    /// `'='`
+    Equal = 61,
+    /// `'>'`
+    GreaterThan = 62,
+    /// `'?'`
+    Question = 63,
+    /// `'@'`
+    At = 64,
+    /// `'A'`
+    A = 65,
+    /// `'B'`
+    B = 66,
+    /// `'C'`
+    C = 67,
+    /// `'D'`
+    D = 68,
+    /// `'E'`
+    E = 69,
+    /// `'F'`
+    F = 70,
+    /// `'G'`
+    G = 71,
+    /// `'H'`
+    H = 72,
+    /// `'I'`
+    I = 73,
+    /// `'J'`
+    J = 74,
+    /// `'K'`
+    K = 75,
+    /// `'L'`
+    L = 76,
+    /// `'M'`
+    M = 77,
+    /// `'N'`
+    N = 78,
+    /// `'O'`
+    O = 79,
+    /// `'P'`
+    P = 80,
+    /// `'Q'`
+    Q = 81,
+    /// `'R'`
+    R = 82,
+    /// `'S'`
+    S = 83,
+    /// `'T'`
+    T = 84,
+    /// `'U'`
+    U = 85,
+    /// `'V'`
+    V = 86,
+    /// `'W'`
+    W = 87,
+    /// `'X'`
+    X = 88,
+    /// `'Y'`
+    Y = 89,
+    /// `'Z'`
+    Z = 90,
+    /// `'['`
+    BracketOpen = 91,
+    /// `'\'`
+    BackSlash = 92,
+    /// `']'`
+    BracketClose = 93,
+    /// `'^'`
+    Caret = 94,
+    /// `'_'`
+    UnderScore = 95,
+    /// `'`'`
+    Grave = 96,
+    /// `'a'`
+    a = 97,
+    /// `'b'`
+    b = 98,
+    /// `'c'`
+    c = 99,
+    /// `'d'`
+    d = 100,
+    /// `'e'`
+    e = 101,
+    /// `'f'`
+    f = 102,
+    /// `'g'`
+    g = 103,
+    /// `'h'`
+    h = 104,
+    /// `'i'`
+    i = 105,
+    /// `'j'`
+    j = 106,
+    /// `'k'`
+    k = 107,
+    /// `'l'`
+    l = 108,
+    /// `'m'`
+    m = 109,
+    /// `'n'`
+    n = 110,
+    /// `'o'`
+    o = 111,
+    /// `'p'`
+    p = 112,
+    /// `'q'`
+    q = 113,
+    /// `'r'`
+    r = 114,
+    /// `'s'`
+    s = 115,
+    /// `'t'`
+    t = 116,
+    /// `'u'`
+    u = 117,
+    /// `'v'`
+    v = 118,
+    /// `'w'`
+    w = 119,
+    /// `'x'`
+    x = 120,
+    /// `'y'`
+    y = 121,
+    /// `'z'`
+    z = 122,
+    /// `'{'`
+    CurlyBraceOpen = 123,
+    /// `'|'`
+    VerticalBar = 124,
+    /// `'}'`
+    CurlyBraceClose = 125,
+    /// `'~'`
+    Tilde = 126,
+    /// [Delete](http://en.wikipedia.org/wiki/Delete_character)
+    DEL = 127,
+}
+
+impl AsciiChar {
+    /// Constructs an ASCII character from a `u8`, `char` or other character type.
+    ///
+    /// # Errors
+    /// Returns `Err(())` if the character can't be ASCII encoded.
+    ///
+    /// # Example
+    /// ```
+    /// # use ascii::AsciiChar;
+    /// let a = AsciiChar::from_ascii('g').unwrap();
+    /// assert_eq!(a.as_char(), 'g');
+    /// ```
+    #[inline]
+    pub fn from_ascii<C: ToAsciiChar>(ch: C) -> Result<Self, ToAsciiCharError> {
+        ch.to_ascii_char()
+    }
+
+    /// Create an `AsciiChar` from a `char`, panicking if it's not ASCII.
+    ///
+    /// This function is intended for creating `AsciiChar` values from
+    /// hardcoded known-good character literals such as `'K'`, `'-'` or `'\0'`,
+    /// and for use in `const` contexts.
+    /// Use [`from_ascii()`](#method.from_ascii) instead when you're not
+    /// certain the character is ASCII.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use ascii::AsciiChar;
+    /// assert_eq!(AsciiChar::new('@'), AsciiChar::At);
+    /// assert_eq!(AsciiChar::new('C').as_char(), 'C');
+    /// ```
+    ///
+    /// In a constant:
+    /// ```
+    /// # use ascii::AsciiChar;
+    /// const SPLIT_ON: AsciiChar = AsciiChar::new(',');
+    /// ```
+    ///
+    /// This will not compile:
+    /// ```compile_fail
+    /// # use ascii::AsciiChar;
+    /// const BAD: AsciiChar = AsciiChar::new('Ø');
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// This function will panic if passed a non-ASCII character.
+    ///
+    /// The panic message might not be the most descriptive due to the
+    /// current limitations of `const fn`.
+    #[must_use]
+    pub const fn new(ch: char) -> AsciiChar {
+        // It's restricted to this function, and without it
+        // we'd need to specify `AsciiChar::` or `Self::` 128 times.
+        #[allow(clippy::enum_glob_use)]
+        use AsciiChar::*;
+
+        #[rustfmt::skip]
+        const ALL: [AsciiChar; 128] = [
+            Null, SOH, SOX, ETX, EOT, ENQ, ACK, Bell,
+            BackSpace, Tab, LineFeed, VT, FF, CarriageReturn, SI, SO,
+            DLE, DC1, DC2, DC3, DC4, NAK, SYN, ETB,
+            CAN, EM, SUB, ESC, FS, GS, RS, US,
+            Space, Exclamation, Quotation, Hash, Dollar, Percent, Ampersand, Apostrophe,
+            ParenOpen, ParenClose, Asterisk, Plus, Comma, Minus, Dot, Slash,
+            _0, _1, _2, _3, _4, _5, _6, _7,
+            _8, _9, Colon, Semicolon, LessThan, Equal, GreaterThan, Question,
+            At, A, B, C, D, E, F, G,
+            H, I, J, K, L, M, N, O,
+            P, Q, R, S, T, U, V, W,
+            X, Y, Z, BracketOpen, BackSlash, BracketClose, Caret, UnderScore,
+            Grave, a, b, c, d, e, f, g,
+            h, i, j, k, l, m, n, o,
+            p, q, r, s, t, u, v, w,
+            x, y, z, CurlyBraceOpen, VerticalBar, CurlyBraceClose, Tilde, DEL,
+		];
+
+        // We want to slice here and detect `const_err` from rustc if the slice is invalid
+        #[allow(clippy::indexing_slicing)]
+        ALL[ch as usize]
+    }
+
+    /// Constructs an ASCII character from a `u8`, `char` or other character
+    /// type without any checks.
+    ///
+    /// # Safety
+    ///
+    /// This function is very unsafe as it can create invalid enum
+    /// discriminants, which instantly creates undefined behavior.
+    /// (`let _ = AsciiChar::from_ascii_unchecked(200);` alone is UB).
+    ///
+    /// The undefined behavior is not just theoretical either:
+    /// For example, `[0; 128][AsciiChar::from_ascii_unchecked(255) as u8 as usize] = 0`
+    /// might not panic, creating a buffer overflow,
+    /// and `Some(AsciiChar::from_ascii_unchecked(128))` might be `None`.
+    #[inline]
+    #[must_use]
+    pub unsafe fn from_ascii_unchecked(ch: u8) -> Self {
+        // SAFETY: Caller guarantees `ch` is within bounds of ascii.
+        unsafe { ch.to_ascii_char_unchecked() }
+    }
+
+    /// Converts an ASCII character into a `u8`.
+    #[inline]
+    #[must_use]
+    pub const fn as_byte(self) -> u8 {
+        self as u8
+    }
+
+    /// Converts an ASCII character into a `char`.
+    #[inline]
+    #[must_use]
+    pub const fn as_char(self) -> char {
+        self as u8 as char
+    }
+
+    // the following methods are like ctype, and the implementation is inspired by musl.
+    // The ascii_ methods take self by reference for maximum compatibility
+    // with the corresponding methods on u8 and char.
+    // It is bad for both usability and performance, but marking those
+    // that doesn't have a non-ascii sibling #[inline] should
+    // make the compiler optimize away the indirection.
+
+    /// Turns uppercase into lowercase, but also modifies '@' and '<'..='_'
+    #[must_use]
+    const fn to_not_upper(self) -> u8 {
+        self as u8 | 0b010_0000
+    }
+
+    /// Check if the character is a letter (a-z, A-Z)
+    #[inline]
+    #[must_use]
+    pub const fn is_alphabetic(self) -> bool {
+        (self.to_not_upper() >= b'a') & (self.to_not_upper() <= b'z')
+    }
+
+    /// Check if the character is a letter (a-z, A-Z).
+    ///
+    /// This method is identical to [`is_alphabetic()`](#method.is_alphabetic)
+    #[inline]
+    #[must_use]
+    pub const fn is_ascii_alphabetic(&self) -> bool {
+        self.is_alphabetic()
+    }
+
+    /// Check if the character is a digit in the given radix.
+    ///
+    /// If the radix is always 10 or 16,
+    /// [`is_ascii_digit()`](#method.is_ascii_digit) and
+    /// [`is_ascii_hexdigit()`](#method.is_ascii_hexdigit()) will be faster.
+    ///
+    /// # Panics
+    ///
+    /// Radixes greater than 36 are not supported and will result in a panic.
+    #[must_use]
+    pub fn is_digit(self, radix: u32) -> bool {
+        match (self as u8, radix) {
+            (b'0'..=b'9', 0..=36) => u32::from(self as u8 - b'0') < radix,
+            (b'a'..=b'z', 11..=36) => u32::from(self as u8 - b'a') < radix - 10,
+            (b'A'..=b'Z', 11..=36) => u32::from(self as u8 - b'A') < radix - 10,
+            (_, 0..=36) => false,
+            (_, _) => panic!("radixes greater than 36 are not supported"),
+        }
+    }
+
+    /// Check if the character is a number (0-9)
+    ///
+    /// # Examples
+    /// ```
+    /// # use ascii::AsciiChar;
+    /// assert_eq!(AsciiChar::new('0').is_ascii_digit(), true);
+    /// assert_eq!(AsciiChar::new('9').is_ascii_digit(), true);
+    /// assert_eq!(AsciiChar::new('a').is_ascii_digit(), false);
+    /// assert_eq!(AsciiChar::new('A').is_ascii_digit(), false);
+    /// assert_eq!(AsciiChar::new('/').is_ascii_digit(), false);
+    /// ```
+    #[inline]
+    #[must_use]
+    pub const fn is_ascii_digit(&self) -> bool {
+        (*self as u8 >= b'0') & (*self as u8 <= b'9')
+    }
+
+    /// Check if the character is a letter or number
+    #[inline]
+    #[must_use]
+    pub const fn is_alphanumeric(self) -> bool {
+        self.is_alphabetic() | self.is_ascii_digit()
+    }
+
+    /// Check if the character is a letter or number
+    ///
+    /// This method is identical to [`is_alphanumeric()`](#method.is_alphanumeric)
+    #[inline]
+    #[must_use]
+    pub const fn is_ascii_alphanumeric(&self) -> bool {
+        self.is_alphanumeric()
+    }
+
+    /// Check if the character is a space or horizontal tab
+    ///
+    /// # Examples
+    /// ```
+    /// # use ascii::AsciiChar;
+    /// assert!(AsciiChar::Space.is_ascii_blank());
+    /// assert!(AsciiChar::Tab.is_ascii_blank());
+    /// assert!(!AsciiChar::VT.is_ascii_blank());
+    /// assert!(!AsciiChar::LineFeed.is_ascii_blank());
+    /// assert!(!AsciiChar::CarriageReturn.is_ascii_blank());
+    /// assert!(!AsciiChar::FF.is_ascii_blank());
+    /// ```
+    #[inline]
+    #[must_use]
+    pub const fn is_ascii_blank(&self) -> bool {
+        (*self as u8 == b' ') | (*self as u8 == b'\t')
+    }
+
+    /// Check if the character one of ' ', '\t', '\n', '\r',
+    /// '\0xb' (vertical tab) or '\0xc' (form feed).
+    #[inline]
+    #[must_use]
+    pub const fn is_whitespace(self) -> bool {
+        let b = self as u8;
+        self.is_ascii_blank() | (b == b'\n') | (b == b'\r') | (b == 0x0b) | (b == 0x0c)
+    }
+
+    /// Check if the character is a ' ', '\t', '\n', '\r' or '\0xc' (form feed).
+    ///
+    /// This method is NOT identical to `is_whitespace()`.
+    #[inline]
+    #[must_use]
+    pub const fn is_ascii_whitespace(&self) -> bool {
+        self.is_ascii_blank()
+            | (*self as u8 == b'\n')
+            | (*self as u8 == b'\r')
+            | (*self as u8 == 0x0c/*form feed*/)
+    }
+
+    /// Check if the character is a control character
+    ///
+    /// # Examples
+    /// ```
+    /// # use ascii::AsciiChar;
+    /// assert_eq!(AsciiChar::new('\0').is_ascii_control(), true);
+    /// assert_eq!(AsciiChar::new('n').is_ascii_control(), false);
+    /// assert_eq!(AsciiChar::new(' ').is_ascii_control(), false);
+    /// assert_eq!(AsciiChar::new('\n').is_ascii_control(), true);
+    /// assert_eq!(AsciiChar::new('\t').is_ascii_control(), true);
+    /// assert_eq!(AsciiChar::EOT.is_ascii_control(), true);
+    /// ```
+    #[inline]
+    #[must_use]
+    pub const fn is_ascii_control(&self) -> bool {
+        ((*self as u8) < b' ') | (*self as u8 == 127)
+    }
+
+    /// Checks if the character is printable (except space)
+    ///
+    /// # Examples
+    /// ```
+    /// # use ascii::AsciiChar;
+    /// assert_eq!(AsciiChar::new('n').is_ascii_graphic(), true);
+    /// assert_eq!(AsciiChar::new(' ').is_ascii_graphic(), false);
+    /// assert_eq!(AsciiChar::new('\n').is_ascii_graphic(), false);
+    /// ```
+    #[inline]
+    #[must_use]
+    pub const fn is_ascii_graphic(&self) -> bool {
+        self.as_byte().wrapping_sub(b' ' + 1) < 0x5E
+    }
+
+    /// Checks if the character is printable (including space)
+    ///
+    /// # Examples
+    /// ```
+    /// # use ascii::AsciiChar;
+    /// assert_eq!(AsciiChar::new('n').is_ascii_printable(), true);
+    /// assert_eq!(AsciiChar::new(' ').is_ascii_printable(), true);
+    /// assert_eq!(AsciiChar::new('\n').is_ascii_printable(), false);
+    /// ```
+    #[inline]
+    #[must_use]
+    pub const fn is_ascii_printable(&self) -> bool {
+        self.as_byte().wrapping_sub(b' ') < 0x5F
+    }
+
+    /// Checks if the character is alphabetic and lowercase (a-z).
+    ///
+    /// # Examples
+    /// ```
+    /// use ascii::AsciiChar;
+    /// assert_eq!(AsciiChar::new('a').is_lowercase(), true);
+    /// assert_eq!(AsciiChar::new('A').is_lowercase(), false);
+    /// assert_eq!(AsciiChar::new('@').is_lowercase(), false);
+    /// ```
+    #[inline]
+    #[must_use]
+    pub const fn is_lowercase(self) -> bool {
+        self.as_byte().wrapping_sub(b'a') < 26
+    }
+
+    /// Checks if the character is alphabetic and lowercase (a-z).
+    ///
+    /// This method is identical to [`is_lowercase()`](#method.is_lowercase)
+    #[inline]
+    #[must_use]
+    pub const fn is_ascii_lowercase(&self) -> bool {
+        self.is_lowercase()
+    }
+
+    /// Checks if the character is alphabetic and uppercase (A-Z).
+    ///
+    /// # Examples
+    /// ```
+    /// # use ascii::AsciiChar;
+    /// assert_eq!(AsciiChar::new('A').is_uppercase(), true);
+    /// assert_eq!(AsciiChar::new('a').is_uppercase(), false);
+    /// assert_eq!(AsciiChar::new('@').is_uppercase(), false);
+    /// ```
+    #[inline]
+    #[must_use]
+    pub const fn is_uppercase(self) -> bool {
+        self.as_byte().wrapping_sub(b'A') < 26
+    }
+
+    /// Checks if the character is alphabetic and uppercase (A-Z).
+    ///
+    /// This method is identical to [`is_uppercase()`](#method.is_uppercase)
+    #[inline]
+    #[must_use]
+    pub const fn is_ascii_uppercase(&self) -> bool {
+        self.is_uppercase()
+    }
+
+    /// Checks if the character is punctuation
+    ///
+    /// # Examples
+    /// ```
+    /// # use ascii::AsciiChar;
+    /// assert_eq!(AsciiChar::new('n').is_ascii_punctuation(), false);
+    /// assert_eq!(AsciiChar::new(' ').is_ascii_punctuation(), false);
+    /// assert_eq!(AsciiChar::new('_').is_ascii_punctuation(), true);
+    /// assert_eq!(AsciiChar::new('~').is_ascii_punctuation(), true);
+    /// ```
+    #[inline]
+    #[must_use]
+    pub const fn is_ascii_punctuation(&self) -> bool {
+        self.is_ascii_graphic() & !self.is_alphanumeric()
+    }
+
+    /// Checks if the character is a valid hex digit
+    ///
+    /// # Examples
+    /// ```
+    /// # use ascii::AsciiChar;
+    /// assert_eq!(AsciiChar::new('5').is_ascii_hexdigit(), true);
+    /// assert_eq!(AsciiChar::new('a').is_ascii_hexdigit(), true);
+    /// assert_eq!(AsciiChar::new('F').is_ascii_hexdigit(), true);
+    /// assert_eq!(AsciiChar::new('G').is_ascii_hexdigit(), false);
+    /// assert_eq!(AsciiChar::new(' ').is_ascii_hexdigit(), false);
+    /// ```
+    #[inline]
+    #[must_use]
+    pub const fn is_ascii_hexdigit(&self) -> bool {
+        self.is_ascii_digit() | ((*self as u8 | 0x20_u8).wrapping_sub(b'a') < 6)
+    }
+
+    /// Unicode has printable versions of the ASCII control codes, like '␛'.
+    ///
+    /// This function is identical with `.as_char()`
+    /// for all values `.is_printable()` returns true for,
+    /// but replaces the control codes with those unicodes printable versions.
+    ///
+    /// # Examples
+    /// ```
+    /// # use ascii::AsciiChar;
+    /// assert_eq!(AsciiChar::new('\0').as_printable_char(), '␀');
+    /// assert_eq!(AsciiChar::new('\n').as_printable_char(), '␊');
+    /// assert_eq!(AsciiChar::new(' ').as_printable_char(), ' ');
+    /// assert_eq!(AsciiChar::new('p').as_printable_char(), 'p');
+    /// ```
+    #[must_use]
+    pub fn as_printable_char(self) -> char {
+        match self as u8 {
+            // Non printable characters
+            // SAFETY: From codepoint 0x2400 ('␀') to 0x241f (`␟`), there are characters representing
+            //         the unprintable characters from 0x0 to 0x1f, ordered correctly.
+            //         As `b` is guaranteed to be within 0x0 to 0x1f, the conversion represents a
+            //         valid character.
+            b @ 0x0..=0x1f => unsafe { char::from_u32_unchecked(u32::from('␀') + u32::from(b)) },
+
+            // 0x7f (delete) has it's own character at codepoint 0x2420, not 0x247f, so it is special
+            // cased to return it's character
+            0x7f => '␡',
+
+            // All other characters are printable, and per function contract use `Self::as_char`
+            _ => self.as_char(),
+        }
+    }
+
+    /// Replaces letters `a` to `z` with `A` to `Z`
+    pub fn make_ascii_uppercase(&mut self) {
+        *self = self.to_ascii_uppercase();
+    }
+
+    /// Replaces letters `A` to `Z` with `a` to `z`
+    pub fn make_ascii_lowercase(&mut self) {
+        *self = self.to_ascii_lowercase();
+    }
+
+    /// Maps letters a-z to A-Z and returns any other character unchanged.
+    ///
+    /// # Examples
+    /// ```
+    /// # use ascii::AsciiChar;
+    /// assert_eq!(AsciiChar::new('u').to_ascii_uppercase().as_char(), 'U');
+    /// assert_eq!(AsciiChar::new('U').to_ascii_uppercase().as_char(), 'U');
+    /// assert_eq!(AsciiChar::new('2').to_ascii_uppercase().as_char(), '2');
+    /// assert_eq!(AsciiChar::new('=').to_ascii_uppercase().as_char(), '=');
+    /// assert_eq!(AsciiChar::new('[').to_ascii_uppercase().as_char(), '[');
+    /// ```
+    #[inline]
+    #[must_use]
+    #[allow(clippy::indexing_slicing)] // We're sure it'll either access one or the other, as `bool` is either `0` or `1`
+    pub const fn to_ascii_uppercase(&self) -> Self {
+        [*self, AsciiChar::new((*self as u8 & 0b101_1111) as char)][self.is_lowercase() as usize]
+    }
+
+    /// Maps letters A-Z to a-z and returns any other character unchanged.
+    ///
+    /// # Examples
+    /// ```
+    /// # use ascii::AsciiChar;
+    /// assert_eq!(AsciiChar::new('U').to_ascii_lowercase().as_char(), 'u');
+    /// assert_eq!(AsciiChar::new('u').to_ascii_lowercase().as_char(), 'u');
+    /// assert_eq!(AsciiChar::new('2').to_ascii_lowercase().as_char(), '2');
+    /// assert_eq!(AsciiChar::new('^').to_ascii_lowercase().as_char(), '^');
+    /// assert_eq!(AsciiChar::new('\x7f').to_ascii_lowercase().as_char(), '\x7f');
+    /// ```
+    #[inline]
+    #[must_use]
+    #[allow(clippy::indexing_slicing)] // We're sure it'll either access one or the other, as `bool` is either `0` or `1`
+    pub const fn to_ascii_lowercase(&self) -> Self {
+        [*self, AsciiChar::new(self.to_not_upper() as char)][self.is_uppercase() as usize]
+    }
+
+    /// Compares two characters case-insensitively.
+    #[inline]
+    #[must_use]
+    pub const fn eq_ignore_ascii_case(&self, other: &Self) -> bool {
+        (self.as_byte() == other.as_byte())
+            | (self.is_alphabetic() & (self.to_not_upper() == other.to_not_upper()))
+    }
+}
+
+impl fmt::Display for AsciiChar {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.as_char().fmt(f)
+    }
+}
+
+impl fmt::Debug for AsciiChar {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.as_char().fmt(f)
+    }
+}
+
+impl Default for AsciiChar {
+    fn default() -> AsciiChar {
+        AsciiChar::Null
+    }
+}
+
+macro_rules! impl_into_partial_eq_ord {
+    ($wider:ty, $to_wider:expr) => {
+        impl From<AsciiChar> for $wider {
+            #[inline]
+            fn from(a: AsciiChar) -> $wider {
+                $to_wider(a)
+            }
+        }
+        impl PartialEq<$wider> for AsciiChar {
+            #[inline]
+            fn eq(&self, rhs: &$wider) -> bool {
+                $to_wider(*self) == *rhs
+            }
+        }
+        impl PartialEq<AsciiChar> for $wider {
+            #[inline]
+            fn eq(&self, rhs: &AsciiChar) -> bool {
+                *self == $to_wider(*rhs)
+            }
+        }
+        impl PartialOrd<$wider> for AsciiChar {
+            #[inline]
+            fn partial_cmp(&self, rhs: &$wider) -> Option<Ordering> {
+                $to_wider(*self).partial_cmp(rhs)
+            }
+        }
+        impl PartialOrd<AsciiChar> for $wider {
+            #[inline]
+            fn partial_cmp(&self, rhs: &AsciiChar) -> Option<Ordering> {
+                self.partial_cmp(&$to_wider(*rhs))
+            }
+        }
+    };
+}
+impl_into_partial_eq_ord! {u8, AsciiChar::as_byte}
+impl_into_partial_eq_ord! {char, AsciiChar::as_char}
+
+/// Error returned by `ToAsciiChar`.
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub struct ToAsciiCharError(());
+
+const ERRORMSG_CHAR: &str = "not an ASCII character";
+
+#[cfg(not(feature = "std"))]
+impl ToAsciiCharError {
+    /// Returns a description for this error, like `std::error::Error::description`.
+    #[inline]
+    #[must_use]
+    #[allow(clippy::unused_self)]
+    pub const fn description(&self) -> &'static str {
+        ERRORMSG_CHAR
+    }
+}
+
+impl fmt::Debug for ToAsciiCharError {
+    fn fmt(&self, fmtr: &mut fmt::Formatter) -> fmt::Result {
+        write!(fmtr, "{}", ERRORMSG_CHAR)
+    }
+}
+
+impl fmt::Display for ToAsciiCharError {
+    fn fmt(&self, fmtr: &mut fmt::Formatter) -> fmt::Result {
+        write!(fmtr, "{}", ERRORMSG_CHAR)
+    }
+}
+
+#[cfg(feature = "std")]
+impl Error for ToAsciiCharError {
+    #[inline]
+    fn description(&self) -> &'static str {
+        ERRORMSG_CHAR
+    }
+}
+
+/// Convert `char`, `u8` and other character types to `AsciiChar`.
+pub trait ToAsciiChar {
+    /// Convert to `AsciiChar`.
+    ///
+    /// # Errors
+    /// If `self` is outside the valid ascii range, this returns `Err`
+    fn to_ascii_char(self) -> Result<AsciiChar, ToAsciiCharError>;
+
+    /// Convert to `AsciiChar` without checking that it is an ASCII character.
+    ///
+    /// # Safety
+    /// Calling this function with a value outside of the ascii range, `0x0` to `0x7f` inclusive,
+    /// is undefined behavior.
+    // TODO: Make sure this is the contract we want to express in this function.
+    //       It is ambigous if numbers such as `0xffffff20_u32` are valid ascii characters,
+    //       as this function returns `Ascii::Space` due to the cast to `u8`, even though
+    //       `to_ascii_char` returns `Err()`.
+    unsafe fn to_ascii_char_unchecked(self) -> AsciiChar;
+}
+
+impl ToAsciiChar for AsciiChar {
+    #[inline]
+    fn to_ascii_char(self) -> Result<AsciiChar, ToAsciiCharError> {
+        Ok(self)
+    }
+
+    #[inline]
+    unsafe fn to_ascii_char_unchecked(self) -> AsciiChar {
+        self
+    }
+}
+
+impl ToAsciiChar for u8 {
+    #[inline]
+    fn to_ascii_char(self) -> Result<AsciiChar, ToAsciiCharError> {
+        u32::from(self).to_ascii_char()
+    }
+    #[inline]
+    unsafe fn to_ascii_char_unchecked(self) -> AsciiChar {
+        // SAFETY: Caller guarantees `self` is within bounds of the enum
+        //         variants, so this cast successfully produces a valid ascii
+        //         variant
+        unsafe { mem::transmute::<u8, AsciiChar>(self) }
+    }
+}
+
+// Note: Casts to `u8` here does not cause problems, as the negative
+//       range is mapped outside of ascii bounds and we don't mind losing
+//       the sign, as long as negative numbers are mapped outside ascii range.
+#[allow(clippy::cast_sign_loss)]
+impl ToAsciiChar for i8 {
+    #[inline]
+    fn to_ascii_char(self) -> Result<AsciiChar, ToAsciiCharError> {
+        u32::from(self as u8).to_ascii_char()
+    }
+    #[inline]
+    unsafe fn to_ascii_char_unchecked(self) -> AsciiChar {
+        // SAFETY: Caller guarantees `self` is within bounds of the enum
+        //         variants, so this cast successfully produces a valid ascii
+        //         variant
+        unsafe { mem::transmute::<u8, AsciiChar>(self as u8) }
+    }
+}
+
+impl ToAsciiChar for char {
+    #[inline]
+    fn to_ascii_char(self) -> Result<AsciiChar, ToAsciiCharError> {
+        u32::from(self).to_ascii_char()
+    }
+    #[inline]
+    unsafe fn to_ascii_char_unchecked(self) -> AsciiChar {
+        // SAFETY: Caller guarantees we're within ascii range.
+        unsafe { u32::from(self).to_ascii_char_unchecked() }
+    }
+}
+
+impl ToAsciiChar for u32 {
+    fn to_ascii_char(self) -> Result<AsciiChar, ToAsciiCharError> {
+        match self {
+            // SAFETY: We're within the valid ascii range in this branch.
+            0x0..=0x7f => Ok(unsafe { self.to_ascii_char_unchecked() }),
+            _ => Err(ToAsciiCharError(())),
+        }
+    }
+
+    #[inline]
+    unsafe fn to_ascii_char_unchecked(self) -> AsciiChar {
+        // Note: This cast discards the top bytes, this may cause problems, see
+        //       the TODO on this method's documentation in the trait.
+        // SAFETY: Caller guarantees we're within ascii range.
+        #[allow(clippy::cast_possible_truncation)] // We want to truncate it
+        unsafe {
+            (self as u8).to_ascii_char_unchecked()
+        }
+    }
+}
+
+impl ToAsciiChar for u16 {
+    fn to_ascii_char(self) -> Result<AsciiChar, ToAsciiCharError> {
+        u32::from(self).to_ascii_char()
+    }
+    #[inline]
+    unsafe fn to_ascii_char_unchecked(self) -> AsciiChar {
+        // Note: This cast discards the top bytes, this may cause problems, see
+        //       the TODO on this method's documentation in the trait.
+        // SAFETY: Caller guarantees we're within ascii range.
+        #[allow(clippy::cast_possible_truncation)] // We want to truncate it
+        unsafe {
+            (self as u8).to_ascii_char_unchecked()
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{AsciiChar, ToAsciiChar, ToAsciiCharError};
+
+    #[test]
+    fn to_ascii_char() {
+        fn generic<C: ToAsciiChar>(ch: C) -> Result<AsciiChar, ToAsciiCharError> {
+            ch.to_ascii_char()
+        }
+        assert_eq!(generic(AsciiChar::A), Ok(AsciiChar::A));
+        assert_eq!(generic(b'A'), Ok(AsciiChar::A));
+        assert_eq!(generic('A'), Ok(AsciiChar::A));
+        assert!(generic(200_u16).is_err());
+        assert!(generic('λ').is_err());
+    }
+
+    #[test]
+    fn as_byte_and_char() {
+        assert_eq!(AsciiChar::A.as_byte(), b'A');
+        assert_eq!(AsciiChar::A.as_char(), 'A');
+    }
+
+    #[test]
+    fn new_array_is_correct() {
+        for byte in 0..128_u8 {
+            assert_eq!(AsciiChar::new(byte as char).as_byte(), byte);
+        }
+    }
+
+    #[test]
+    fn is_all() {
+        #![allow(clippy::is_digit_ascii_radix)] // testing it
+        for byte in 0..128_u8 {
+            let ch = byte as char;
+            let ascii = AsciiChar::new(ch);
+            assert_eq!(ascii.is_alphabetic(), ch.is_alphabetic());
+            assert_eq!(ascii.is_ascii_alphabetic(), ch.is_ascii_alphabetic());
+            assert_eq!(ascii.is_alphanumeric(), ch.is_alphanumeric());
+            assert_eq!(ascii.is_ascii_alphanumeric(), ch.is_ascii_alphanumeric());
+            assert_eq!(ascii.is_digit(8), ch.is_digit(8), "is_digit(8) {:?}", ch);
+            assert_eq!(ascii.is_digit(10), ch.is_digit(10), "is_digit(10) {:?}", ch);
+            assert_eq!(ascii.is_digit(16), ch.is_digit(16), "is_digit(16) {:?}", ch);
+            assert_eq!(ascii.is_digit(36), ch.is_digit(36), "is_digit(36) {:?}", ch);
+            assert_eq!(ascii.is_ascii_digit(), ch.is_ascii_digit());
+            assert_eq!(ascii.is_ascii_hexdigit(), ch.is_ascii_hexdigit());
+            assert_eq!(ascii.is_ascii_control(), ch.is_ascii_control());
+            assert_eq!(ascii.is_ascii_graphic(), ch.is_ascii_graphic());
+            assert_eq!(ascii.is_ascii_punctuation(), ch.is_ascii_punctuation());
+            assert_eq!(
+                ascii.is_whitespace(),
+                ch.is_whitespace(),
+                "{:?} ({:#04x})",
+                ch,
+                byte
+            );
+            assert_eq!(
+                ascii.is_ascii_whitespace(),
+                ch.is_ascii_whitespace(),
+                "{:?} ({:#04x})",
+                ch,
+                byte
+            );
+            assert_eq!(ascii.is_uppercase(), ch.is_uppercase());
+            assert_eq!(ascii.is_ascii_uppercase(), ch.is_ascii_uppercase());
+            assert_eq!(ascii.is_lowercase(), ch.is_lowercase());
+            assert_eq!(ascii.is_ascii_lowercase(), ch.is_ascii_lowercase());
+            assert_eq!(ascii.to_ascii_uppercase(), ch.to_ascii_uppercase());
+            assert_eq!(ascii.to_ascii_lowercase(), ch.to_ascii_lowercase());
+        }
+    }
+
+    #[test]
+    fn is_digit_strange_radixes() {
+        assert_eq!(AsciiChar::_0.is_digit(0), '0'.is_digit(0));
+        assert_eq!(AsciiChar::_0.is_digit(1), '0'.is_digit(1));
+        assert_eq!(AsciiChar::_5.is_digit(5), '5'.is_digit(5));
+        assert_eq!(AsciiChar::z.is_digit(35), 'z'.is_digit(35));
+    }
+
+    #[test]
+    #[should_panic]
+    fn is_digit_bad_radix() {
+        let _ = AsciiChar::_7.is_digit(37);
+    }
+
+    #[test]
+    fn cmp_wider() {
+        assert_eq!(AsciiChar::A, 'A');
+        assert_eq!(b'b', AsciiChar::b);
+        assert!(AsciiChar::a < 'z');
+    }
+
+    #[test]
+    fn ascii_case() {
+        assert_eq!(AsciiChar::At.to_ascii_lowercase(), AsciiChar::At);
+        assert_eq!(AsciiChar::At.to_ascii_uppercase(), AsciiChar::At);
+        assert_eq!(AsciiChar::A.to_ascii_lowercase(), AsciiChar::a);
+        assert_eq!(AsciiChar::A.to_ascii_uppercase(), AsciiChar::A);
+        assert_eq!(AsciiChar::a.to_ascii_lowercase(), AsciiChar::a);
+        assert_eq!(AsciiChar::a.to_ascii_uppercase(), AsciiChar::A);
+
+        let mut mutable = (AsciiChar::A, AsciiChar::a);
+        mutable.0.make_ascii_lowercase();
+        mutable.1.make_ascii_uppercase();
+        assert_eq!(mutable.0, AsciiChar::a);
+        assert_eq!(mutable.1, AsciiChar::A);
+
+        assert!(AsciiChar::LineFeed.eq_ignore_ascii_case(&AsciiChar::LineFeed));
+        assert!(!AsciiChar::LineFeed.eq_ignore_ascii_case(&AsciiChar::CarriageReturn));
+        assert!(AsciiChar::z.eq_ignore_ascii_case(&AsciiChar::Z));
+        assert!(AsciiChar::Z.eq_ignore_ascii_case(&AsciiChar::z));
+        assert!(AsciiChar::A.eq_ignore_ascii_case(&AsciiChar::a));
+        assert!(!AsciiChar::K.eq_ignore_ascii_case(&AsciiChar::C));
+        assert!(!AsciiChar::Z.eq_ignore_ascii_case(&AsciiChar::DEL));
+        assert!(!AsciiChar::BracketOpen.eq_ignore_ascii_case(&AsciiChar::CurlyBraceOpen));
+        assert!(!AsciiChar::Grave.eq_ignore_ascii_case(&AsciiChar::At));
+        assert!(!AsciiChar::Grave.eq_ignore_ascii_case(&AsciiChar::DEL));
+    }
+
+    #[test]
+    #[cfg(feature = "std")]
+    fn fmt_ascii() {
+        assert_eq!(format!("{}", AsciiChar::t), "t");
+        assert_eq!(format!("{:?}", AsciiChar::t), "'t'");
+        assert_eq!(format!("{}", AsciiChar::LineFeed), "\n");
+        assert_eq!(format!("{:?}", AsciiChar::LineFeed), "'\\n'");
+    }
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/ascii-1.1.0/src/ascii_str.rs

@@ -0,0 +1,1600 @@
+#[cfg(feature = "alloc")]
+use alloc::borrow::ToOwned;
+#[cfg(feature = "alloc")]
+use alloc::boxed::Box;
+use core::fmt;
+use core::ops::{Index, IndexMut};
+use core::ops::{Range, RangeFrom, RangeFull, RangeInclusive, RangeTo, RangeToInclusive};
+use core::slice::{self, Iter, IterMut, SliceIndex};
+#[cfg(feature = "std")]
+use std::error::Error;
+#[cfg(feature = "std")]
+use std::ffi::CStr;
+
+use ascii_char::AsciiChar;
+#[cfg(feature = "alloc")]
+use ascii_string::AsciiString;
+
+/// [`AsciiStr`] represents a byte or string slice that only contains ASCII characters.
+///
+/// It wraps an `[AsciiChar]` and implements many of `str`s methods and traits.
+///
+/// It can be created by a checked conversion from a `str` or `[u8]`, or borrowed from an
+/// `AsciiString`.
+#[derive(PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[repr(transparent)]
+pub struct AsciiStr {
+    slice: [AsciiChar],
+}
+
+impl AsciiStr {
+    /// Converts `&self` to a `&str` slice.
+    #[inline]
+    #[must_use]
+    pub fn as_str(&self) -> &str {
+        // SAFETY: All variants of `AsciiChar` are valid bytes for a `str`.
+        unsafe { &*(self as *const AsciiStr as *const str) }
+    }
+
+    /// Converts `&self` into a byte slice.
+    #[inline]
+    #[must_use]
+    pub fn as_bytes(&self) -> &[u8] {
+        // SAFETY: All variants of `AsciiChar` are valid `u8`, given they're `repr(u8)`.
+        unsafe { &*(self as *const AsciiStr as *const [u8]) }
+    }
+
+    /// Returns the entire string as slice of `AsciiChar`s.
+    #[inline]
+    #[must_use]
+    pub const fn as_slice(&self) -> &[AsciiChar] {
+        &self.slice
+    }
+
+    /// Returns the entire string as mutable slice of `AsciiChar`s.
+    #[inline]
+    #[must_use]
+    pub fn as_mut_slice(&mut self) -> &mut [AsciiChar] {
+        &mut self.slice
+    }
+
+    /// Returns a raw pointer to the `AsciiStr`'s buffer.
+    ///
+    /// The caller must ensure that the slice outlives the pointer this function returns, or else it
+    /// will end up pointing to garbage. Modifying the `AsciiStr` may cause it's buffer to be
+    /// reallocated, which would also make any pointers to it invalid.
+    #[inline]
+    #[must_use]
+    pub const fn as_ptr(&self) -> *const AsciiChar {
+        self.as_slice().as_ptr()
+    }
+
+    /// Returns an unsafe mutable pointer to the `AsciiStr`'s buffer.
+    ///
+    /// The caller must ensure that the slice outlives the pointer this function returns, or else it
+    /// will end up pointing to garbage. Modifying the `AsciiStr` may cause it's buffer to be
+    /// reallocated, which would also make any pointers to it invalid.
+    #[inline]
+    #[must_use]
+    pub fn as_mut_ptr(&mut self) -> *mut AsciiChar {
+        self.as_mut_slice().as_mut_ptr()
+    }
+
+    /// Copies the content of this `AsciiStr` into an owned `AsciiString`.
+    #[cfg(feature = "alloc")]
+    #[must_use]
+    pub fn to_ascii_string(&self) -> AsciiString {
+        AsciiString::from(self.slice.to_vec())
+    }
+
+    /// Converts anything that can represent a byte slice into an `AsciiStr`.
+    ///
+    /// # Errors
+    /// If `bytes` contains a non-ascii byte, `Err` will be returned
+    ///
+    /// # Examples
+    /// ```
+    /// # use ascii::AsciiStr;
+    /// let foo = AsciiStr::from_ascii(b"foo");
+    /// let err = AsciiStr::from_ascii("Ŋ");
+    /// assert_eq!(foo.unwrap().as_str(), "foo");
+    /// assert_eq!(err.unwrap_err().valid_up_to(), 0);
+    /// ```
+    #[inline]
+    pub fn from_ascii<B>(bytes: &B) -> Result<&AsciiStr, AsAsciiStrError>
+    where
+        B: AsRef<[u8]> + ?Sized,
+    {
+        bytes.as_ref().as_ascii_str()
+    }
+
+    /// Converts anything that can be represented as a byte slice to an `AsciiStr` without checking
+    /// for non-ASCII characters..
+    ///
+    /// # Safety
+    /// If any of the bytes in `bytes` do not represent valid ascii characters, calling
+    /// this function is undefined behavior.
+    ///
+    /// # Examples
+    /// ```
+    /// # use ascii::AsciiStr;
+    /// let foo = unsafe { AsciiStr::from_ascii_unchecked(&b"foo"[..]) };
+    /// assert_eq!(foo.as_str(), "foo");
+    /// ```
+    #[inline]
+    #[must_use]
+    pub unsafe fn from_ascii_unchecked(bytes: &[u8]) -> &AsciiStr {
+        // SAFETY: Caller guarantees all bytes in `bytes` are valid
+        //         ascii characters.
+        unsafe { bytes.as_ascii_str_unchecked() }
+    }
+
+    /// Returns the number of characters / bytes in this ASCII sequence.
+    ///
+    /// # Examples
+    /// ```
+    /// # use ascii::AsciiStr;
+    /// let s = AsciiStr::from_ascii("foo").unwrap();
+    /// assert_eq!(s.len(), 3);
+    /// ```
+    #[inline]
+    #[must_use]
+    pub const fn len(&self) -> usize {
+        self.slice.len()
+    }
+
+    /// Returns true if the ASCII slice contains zero bytes.
+    ///
+    /// # Examples
+    /// ```
+    /// # use ascii::AsciiStr;
+    /// let mut empty = AsciiStr::from_ascii("").unwrap();
+    /// let mut full = AsciiStr::from_ascii("foo").unwrap();
+    /// assert!(empty.is_empty());
+    /// assert!(!full.is_empty());
+    /// ```
+    #[inline]
+    #[must_use]
+    pub const fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    /// Returns an iterator over the characters of the `AsciiStr`.
+    #[inline]
+    #[must_use]
+    pub fn chars(&self) -> Chars {
+        Chars(self.slice.iter())
+    }
+
+    /// Returns an iterator over the characters of the `AsciiStr` which allows you to modify the
+    /// value of each `AsciiChar`.
+    #[inline]
+    #[must_use]
+    pub fn chars_mut(&mut self) -> CharsMut {
+        CharsMut(self.slice.iter_mut())
+    }
+
+    /// Returns an iterator over parts of the `AsciiStr` separated by a character.
+    ///
+    /// # Examples
+    /// ```
+    /// # use ascii::{AsciiStr, AsciiChar};
+    /// let words = AsciiStr::from_ascii("apple banana lemon").unwrap()
+    ///     .split(AsciiChar::Space)
+    ///     .map(|a| a.as_str())
+    ///     .collect::<Vec<_>>();
+    /// assert_eq!(words, ["apple", "banana", "lemon"]);
+    /// ```
+    #[must_use]
+    pub fn split(&self, on: AsciiChar) -> impl DoubleEndedIterator<Item = &AsciiStr> {
+        Split {
+            on,
+            ended: false,
+            chars: self.chars(),
+        }
+    }
+
+    /// Returns an iterator over the lines of the `AsciiStr`, which are themselves `AsciiStr`s.
+    ///
+    /// Lines are ended with either `LineFeed` (`\n`), or `CarriageReturn` then `LineFeed` (`\r\n`).
+    ///
+    /// The final line ending is optional.
+    #[inline]
+    #[must_use]
+    pub fn lines(&self) -> impl DoubleEndedIterator<Item = &AsciiStr> {
+        Lines { string: self }
+    }
+
+    /// Returns an ASCII string slice with leading and trailing whitespace removed.
+    ///
+    /// # Examples
+    /// ```
+    /// # use ascii::AsciiStr;
+    /// let example = AsciiStr::from_ascii("  \twhite \tspace  \t").unwrap();
+    /// assert_eq!("white \tspace", example.trim());
+    /// ```
+    #[must_use]
+    pub fn trim(&self) -> &Self {
+        self.trim_start().trim_end()
+    }
+
+    /// Returns an ASCII string slice with leading whitespace removed.
+    ///
+    /// # Examples
+    /// ```
+    /// # use ascii::AsciiStr;
+    /// let example = AsciiStr::from_ascii("  \twhite \tspace  \t").unwrap();
+    /// assert_eq!("white \tspace  \t", example.trim_start());
+    /// ```
+    #[must_use]
+    pub fn trim_start(&self) -> &Self {
+        let whitespace_len = self
+            .chars()
+            .position(|ch| !ch.is_whitespace())
+            .unwrap_or_else(|| self.len());
+
+        // SAFETY: `whitespace_len` is `0..=len`, which is at most `len`, which is a valid empty slice.
+        unsafe { self.as_slice().get_unchecked(whitespace_len..).into() }
+    }
+
+    /// Returns an ASCII string slice with trailing whitespace removed.
+    ///
+    /// # Examples
+    /// ```
+    /// # use ascii::AsciiStr;
+    /// let example = AsciiStr::from_ascii("  \twhite \tspace  \t").unwrap();
+    /// assert_eq!("  \twhite \tspace", example.trim_end());
+    /// ```
+    #[must_use]
+    pub fn trim_end(&self) -> &Self {
+        // Number of whitespace characters counting from the end
+        let whitespace_len = self
+            .chars()
+            .rev()
+            .position(|ch| !ch.is_whitespace())
+            .unwrap_or_else(|| self.len());
+
+        // SAFETY: `whitespace_len` is `0..=len`, which is at most `len`, which is a valid empty slice, and at least `0`, which is the whole slice.
+        unsafe {
+            self.as_slice()
+                .get_unchecked(..self.len() - whitespace_len)
+                .into()
+        }
+    }
+
+    /// Compares two strings case-insensitively.
+    #[must_use]
+    pub fn eq_ignore_ascii_case(&self, other: &Self) -> bool {
+        self.len() == other.len()
+            && self
+                .chars()
+                .zip(other.chars())
+                .all(|(ch, other_ch)| ch.eq_ignore_ascii_case(&other_ch))
+    }
+
+    /// Replaces lowercase letters with their uppercase equivalent.
+    pub fn make_ascii_uppercase(&mut self) {
+        for ch in self.chars_mut() {
+            *ch = ch.to_ascii_uppercase();
+        }
+    }
+
+    /// Replaces uppercase letters with their lowercase equivalent.
+    pub fn make_ascii_lowercase(&mut self) {
+        for ch in self.chars_mut() {
+            *ch = ch.to_ascii_lowercase();
+        }
+    }
+
+    /// Returns a copy of this string where letters 'a' to 'z' are mapped to 'A' to 'Z'.
+    #[cfg(feature = "alloc")]
+    #[must_use]
+    pub fn to_ascii_uppercase(&self) -> AsciiString {
+        let mut ascii_string = self.to_ascii_string();
+        ascii_string.make_ascii_uppercase();
+        ascii_string
+    }
+
+    /// Returns a copy of this string where letters 'A' to 'Z' are mapped to 'a' to 'z'.
+    #[cfg(feature = "alloc")]
+    #[must_use]
+    pub fn to_ascii_lowercase(&self) -> AsciiString {
+        let mut ascii_string = self.to_ascii_string();
+        ascii_string.make_ascii_lowercase();
+        ascii_string
+    }
+
+    /// Returns the first character if the string is not empty.
+    #[inline]
+    #[must_use]
+    pub fn first(&self) -> Option<AsciiChar> {
+        self.slice.first().copied()
+    }
+
+    /// Returns the last character if the string is not empty.
+    #[inline]
+    #[must_use]
+    pub fn last(&self) -> Option<AsciiChar> {
+        self.slice.last().copied()
+    }
+
+    /// Converts a [`Box<AsciiStr>`] into a [`AsciiString`] without copying or allocating.
+    #[cfg(feature = "alloc")]
+    #[inline]
+    #[must_use]
+    pub fn into_ascii_string(self: Box<Self>) -> AsciiString {
+        let slice = Box::<[AsciiChar]>::from(self);
+        AsciiString::from(slice.into_vec())
+    }
+}
+
+macro_rules! impl_partial_eq {
+    ($wider: ty) => {
+        impl PartialEq<$wider> for AsciiStr {
+            #[inline]
+            fn eq(&self, other: &$wider) -> bool {
+                <AsciiStr as AsRef<$wider>>::as_ref(self) == other
+            }
+        }
+        impl PartialEq<AsciiStr> for $wider {
+            #[inline]
+            fn eq(&self, other: &AsciiStr) -> bool {
+                self == <AsciiStr as AsRef<$wider>>::as_ref(other)
+            }
+        }
+    };
+}
+
+impl_partial_eq! {str}
+impl_partial_eq! {[u8]}
+impl_partial_eq! {[AsciiChar]}
+
+#[cfg(feature = "alloc")]
+impl ToOwned for AsciiStr {
+    type Owned = AsciiString;
+
+    #[inline]
+    fn to_owned(&self) -> AsciiString {
+        self.to_ascii_string()
+    }
+}
+
+impl AsRef<[u8]> for AsciiStr {
+    #[inline]
+    fn as_ref(&self) -> &[u8] {
+        self.as_bytes()
+    }
+}
+impl AsRef<str> for AsciiStr {
+    #[inline]
+    fn as_ref(&self) -> &str {
+        self.as_str()
+    }
+}
+impl AsRef<[AsciiChar]> for AsciiStr {
+    #[inline]
+    fn as_ref(&self) -> &[AsciiChar] {
+        &self.slice
+    }
+}
+impl AsMut<[AsciiChar]> for AsciiStr {
+    #[inline]
+    fn as_mut(&mut self) -> &mut [AsciiChar] {
+        &mut self.slice
+    }
+}
+
+impl Default for &'static AsciiStr {
+    #[inline]
+    fn default() -> &'static AsciiStr {
+        From::from(&[] as &[AsciiChar])
+    }
+}
+impl<'a> From<&'a [AsciiChar]> for &'a AsciiStr {
+    #[inline]
+    fn from(slice: &[AsciiChar]) -> &AsciiStr {
+        let ptr = slice as *const [AsciiChar] as *const AsciiStr;
+        unsafe { &*ptr }
+    }
+}
+impl<'a> From<&'a mut [AsciiChar]> for &'a mut AsciiStr {
+    #[inline]
+    fn from(slice: &mut [AsciiChar]) -> &mut AsciiStr {
+        let ptr = slice as *mut [AsciiChar] as *mut AsciiStr;
+        unsafe { &mut *ptr }
+    }
+}
+#[cfg(feature = "alloc")]
+impl From<Box<[AsciiChar]>> for Box<AsciiStr> {
+    #[inline]
+    fn from(owned: Box<[AsciiChar]>) -> Box<AsciiStr> {
+        let ptr = Box::into_raw(owned) as *mut AsciiStr;
+        unsafe { Box::from_raw(ptr) }
+    }
+}
+
+impl AsRef<AsciiStr> for AsciiStr {
+    #[inline]
+    fn as_ref(&self) -> &AsciiStr {
+        self
+    }
+}
+impl AsMut<AsciiStr> for AsciiStr {
+    #[inline]
+    fn as_mut(&mut self) -> &mut AsciiStr {
+        self
+    }
+}
+impl AsRef<AsciiStr> for [AsciiChar] {
+    #[inline]
+    fn as_ref(&self) -> &AsciiStr {
+        self.into()
+    }
+}
+impl AsMut<AsciiStr> for [AsciiChar] {
+    #[inline]
+    fn as_mut(&mut self) -> &mut AsciiStr {
+        self.into()
+    }
+}
+
+impl<'a> From<&'a AsciiStr> for &'a [AsciiChar] {
+    #[inline]
+    fn from(astr: &AsciiStr) -> &[AsciiChar] {
+        &astr.slice
+    }
+}
+impl<'a> From<&'a mut AsciiStr> for &'a mut [AsciiChar] {
+    #[inline]
+    fn from(astr: &mut AsciiStr) -> &mut [AsciiChar] {
+        &mut astr.slice
+    }
+}
+impl<'a> From<&'a AsciiStr> for &'a [u8] {
+    #[inline]
+    fn from(astr: &AsciiStr) -> &[u8] {
+        astr.as_bytes()
+    }
+}
+impl<'a> From<&'a AsciiStr> for &'a str {
+    #[inline]
+    fn from(astr: &AsciiStr) -> &str {
+        astr.as_str()
+    }
+}
+macro_rules! widen_box {
+    ($wider: ty) => {
+        #[cfg(feature = "alloc")]
+        impl From<Box<AsciiStr>> for Box<$wider> {
+            #[inline]
+            fn from(owned: Box<AsciiStr>) -> Box<$wider> {
+                let ptr = Box::into_raw(owned) as *mut $wider;
+                unsafe { Box::from_raw(ptr) }
+            }
+        }
+    };
+}
+widen_box! {[AsciiChar]}
+widen_box! {[u8]}
+widen_box! {str}
+
+// allows &AsciiChar to be used by generic AsciiString Extend and FromIterator
+impl AsRef<AsciiStr> for AsciiChar {
+    fn as_ref(&self) -> &AsciiStr {
+        slice::from_ref(self).into()
+    }
+}
+
+impl fmt::Display for AsciiStr {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Display::fmt(self.as_str(), f)
+    }
+}
+
+impl fmt::Debug for AsciiStr {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Debug::fmt(self.as_str(), f)
+    }
+}
+
+macro_rules! impl_index {
+    ($idx:ty) => {
+        #[allow(clippy::indexing_slicing)] // In `Index`, if it's out of bounds, panic is the default
+        impl Index<$idx> for AsciiStr {
+            type Output = AsciiStr;
+
+            #[inline]
+            fn index(&self, index: $idx) -> &AsciiStr {
+                self.slice[index].as_ref()
+            }
+        }
+
+        #[allow(clippy::indexing_slicing)] // In `IndexMut`, if it's out of bounds, panic is the default
+        impl IndexMut<$idx> for AsciiStr {
+            #[inline]
+            fn index_mut(&mut self, index: $idx) -> &mut AsciiStr {
+                self.slice[index].as_mut()
+            }
+        }
+    };
+}
+
+impl_index! { Range<usize> }
+impl_index! { RangeTo<usize> }
+impl_index! { RangeFrom<usize> }
+impl_index! { RangeFull }
+impl_index! { RangeInclusive<usize> }
+impl_index! { RangeToInclusive<usize> }
+
+#[allow(clippy::indexing_slicing)] // In `Index`, if it's out of bounds, panic is the default
+impl Index<usize> for AsciiStr {
+    type Output = AsciiChar;
+
+    #[inline]
+    fn index(&self, index: usize) -> &AsciiChar {
+        &self.slice[index]
+    }
+}
+
+#[allow(clippy::indexing_slicing)] // In `IndexMut`, if it's out of bounds, panic is the default
+impl IndexMut<usize> for AsciiStr {
+    #[inline]
+    fn index_mut(&mut self, index: usize) -> &mut AsciiChar {
+        &mut self.slice[index]
+    }
+}
+
+/// Produces references for compatibility with `[u8]`.
+///
+/// (`str` doesn't implement `IntoIterator` for its references,
+///  so there is no compatibility to lose.)
+impl<'a> IntoIterator for &'a AsciiStr {
+    type Item = &'a AsciiChar;
+    type IntoIter = CharsRef<'a>;
+    #[inline]
+    fn into_iter(self) -> Self::IntoIter {
+        CharsRef(self.as_slice().iter())
+    }
+}
+
+impl<'a> IntoIterator for &'a mut AsciiStr {
+    type Item = &'a mut AsciiChar;
+    type IntoIter = CharsMut<'a>;
+    #[inline]
+    fn into_iter(self) -> Self::IntoIter {
+        self.chars_mut()
+    }
+}
+
+/// A copying iterator over the characters of an `AsciiStr`.
+#[derive(Clone, Debug)]
+pub struct Chars<'a>(Iter<'a, AsciiChar>);
+impl<'a> Chars<'a> {
+    /// Returns the ascii string slice with the remaining characters.
+    #[must_use]
+    pub fn as_str(&self) -> &'a AsciiStr {
+        self.0.as_slice().into()
+    }
+}
+impl<'a> Iterator for Chars<'a> {
+    type Item = AsciiChar;
+    #[inline]
+    fn next(&mut self) -> Option<AsciiChar> {
+        self.0.next().copied()
+    }
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.0.size_hint()
+    }
+}
+impl<'a> DoubleEndedIterator for Chars<'a> {
+    #[inline]
+    fn next_back(&mut self) -> Option<AsciiChar> {
+        self.0.next_back().copied()
+    }
+}
+impl<'a> ExactSizeIterator for Chars<'a> {
+    fn len(&self) -> usize {
+        self.0.len()
+    }
+}
+
+/// A mutable iterator over the characters of an `AsciiStr`.
+#[derive(Debug)]
+pub struct CharsMut<'a>(IterMut<'a, AsciiChar>);
+impl<'a> CharsMut<'a> {
+    /// Returns the ascii string slice with the remaining characters.
+    #[must_use]
+    pub fn into_str(self) -> &'a mut AsciiStr {
+        self.0.into_slice().into()
+    }
+}
+impl<'a> Iterator for CharsMut<'a> {
+    type Item = &'a mut AsciiChar;
+    #[inline]
+    fn next(&mut self) -> Option<&'a mut AsciiChar> {
+        self.0.next()
+    }
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.0.size_hint()
+    }
+}
+impl<'a> DoubleEndedIterator for CharsMut<'a> {
+    #[inline]
+    fn next_back(&mut self) -> Option<&'a mut AsciiChar> {
+        self.0.next_back()
+    }
+}
+impl<'a> ExactSizeIterator for CharsMut<'a> {
+    fn len(&self) -> usize {
+        self.0.len()
+    }
+}
+
+/// An immutable iterator over the characters of an `AsciiStr`.
+#[derive(Clone, Debug)]
+pub struct CharsRef<'a>(Iter<'a, AsciiChar>);
+impl<'a> CharsRef<'a> {
+    /// Returns the ascii string slice with the remaining characters.
+    #[must_use]
+    pub fn as_str(&self) -> &'a AsciiStr {
+        self.0.as_slice().into()
+    }
+}
+impl<'a> Iterator for CharsRef<'a> {
+    type Item = &'a AsciiChar;
+    #[inline]
+    fn next(&mut self) -> Option<&'a AsciiChar> {
+        self.0.next()
+    }
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.0.size_hint()
+    }
+}
+impl<'a> DoubleEndedIterator for CharsRef<'a> {
+    #[inline]
+    fn next_back(&mut self) -> Option<&'a AsciiChar> {
+        self.0.next_back()
+    }
+}
+
+/// An iterator over parts of an `AsciiStr` separated by an `AsciiChar`.
+///
+/// This type is created by [`AsciiChar::split()`](struct.AsciiChar.html#method.split).
+#[derive(Clone, Debug)]
+struct Split<'a> {
+    on: AsciiChar,
+    ended: bool,
+    chars: Chars<'a>,
+}
+impl<'a> Iterator for Split<'a> {
+    type Item = &'a AsciiStr;
+
+    fn next(&mut self) -> Option<&'a AsciiStr> {
+        if !self.ended {
+            let start: &AsciiStr = self.chars.as_str();
+            let split_on = self.on;
+
+            if let Some(at) = self.chars.position(|ch| ch == split_on) {
+                // SAFETY: `at` is guaranteed to be in bounds, as `position` returns `Ok(0..len)`.
+                Some(unsafe { start.as_slice().get_unchecked(..at).into() })
+            } else {
+                self.ended = true;
+                Some(start)
+            }
+        } else {
+            None
+        }
+    }
+}
+impl<'a> DoubleEndedIterator for Split<'a> {
+    fn next_back(&mut self) -> Option<&'a AsciiStr> {
+        if !self.ended {
+            let start: &AsciiStr = self.chars.as_str();
+            let split_on = self.on;
+
+            if let Some(at) = self.chars.rposition(|ch| ch == split_on) {
+                // SAFETY: `at` is guaranteed to be in bounds, as `rposition` returns `Ok(0..len)`, and slices `1..`, `2..`, etc... until `len..` inclusive, are valid.
+                Some(unsafe { start.as_slice().get_unchecked(at + 1..).into() })
+            } else {
+                self.ended = true;
+                Some(start)
+            }
+        } else {
+            None
+        }
+    }
+}
+
+/// An iterator over the lines of the internal character array.
+#[derive(Clone, Debug)]
+struct Lines<'a> {
+    string: &'a AsciiStr,
+}
+impl<'a> Iterator for Lines<'a> {
+    type Item = &'a AsciiStr;
+
+    fn next(&mut self) -> Option<&'a AsciiStr> {
+        if let Some(idx) = self
+            .string
+            .chars()
+            .position(|chr| chr == AsciiChar::LineFeed)
+        {
+            // SAFETY: `idx` is guaranteed to be `1..len`, as we get it from `position` as `0..len` and make sure it's not `0`.
+            let line = if idx > 0
+                && *unsafe { self.string.as_slice().get_unchecked(idx - 1) }
+                    == AsciiChar::CarriageReturn
+            {
+                // SAFETY: As per above, `idx` is guaranteed to be `1..len`
+                unsafe { self.string.as_slice().get_unchecked(..idx - 1).into() }
+            } else {
+                // SAFETY: As per above, `idx` is guaranteed to be `0..len`
+                unsafe { self.string.as_slice().get_unchecked(..idx).into() }
+            };
+            // SAFETY: As per above, `idx` is guaranteed to be `0..len`, so at the extreme, slicing `len..` is a valid empty slice.
+            self.string = unsafe { self.string.as_slice().get_unchecked(idx + 1..).into() };
+            Some(line)
+        } else if self.string.is_empty() {
+            None
+        } else {
+            let line = self.string;
+            // SAFETY: An empty string is a valid string.
+            self.string = unsafe { AsciiStr::from_ascii_unchecked(b"") };
+            Some(line)
+        }
+    }
+}
+
+impl<'a> DoubleEndedIterator for Lines<'a> {
+    fn next_back(&mut self) -> Option<&'a AsciiStr> {
+        if self.string.is_empty() {
+            return None;
+        }
+
+        // If we end with `LF` / `CR/LF`, remove them
+        if let Some(AsciiChar::LineFeed) = self.string.last() {
+            // SAFETY: `last()` returned `Some`, so our len is at least 1.
+            self.string = unsafe {
+                self.string
+                    .as_slice()
+                    .get_unchecked(..self.string.len() - 1)
+                    .into()
+            };
+
+            if let Some(AsciiChar::CarriageReturn) = self.string.last() {
+                // SAFETY: `last()` returned `Some`, so our len is at least 1.
+                self.string = unsafe {
+                    self.string
+                        .as_slice()
+                        .get_unchecked(..self.string.len() - 1)
+                        .into()
+                };
+            }
+        }
+
+        // Get the position of the first `LF` from the end.
+        let lf_rev_pos = self
+            .string
+            .chars()
+            .rev()
+            .position(|ch| ch == AsciiChar::LineFeed)
+            .unwrap_or_else(|| self.string.len());
+
+        // SAFETY: `lf_rev_pos` will be in range `0..=len`, so `len - lf_rev_pos`
+        //         will be within `0..=len`, making it correct as a start and end
+        //         point for the strings.
+        let line = unsafe {
+            self.string
+                .as_slice()
+                .get_unchecked(self.string.len() - lf_rev_pos..)
+                .into()
+        };
+        self.string = unsafe {
+            self.string
+                .as_slice()
+                .get_unchecked(..self.string.len() - lf_rev_pos)
+                .into()
+        };
+        Some(line)
+    }
+}
+
+/// Error that is returned when a sequence of `u8` are not all ASCII.
+///
+/// Is used by `As[Mut]AsciiStr` and the `from_ascii` method on `AsciiStr` and `AsciiString`.
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub struct AsAsciiStrError(usize);
+
+const ERRORMSG_STR: &str = "one or more bytes are not ASCII";
+
+impl AsAsciiStrError {
+    /// Returns the index of the first non-ASCII byte.
+    ///
+    /// It is the maximum index such that `from_ascii(input[..index])` would return `Ok(_)`.
+    #[inline]
+    #[must_use]
+    pub const fn valid_up_to(self) -> usize {
+        self.0
+    }
+    #[cfg(not(feature = "std"))]
+    /// Returns a description for this error, like `std::error::Error::description`.
+    #[inline]
+    #[must_use]
+    #[allow(clippy::unused_self)]
+    pub const fn description(&self) -> &'static str {
+        ERRORMSG_STR
+    }
+}
+impl fmt::Display for AsAsciiStrError {
+    fn fmt(&self, fmtr: &mut fmt::Formatter) -> fmt::Result {
+        write!(fmtr, "the byte at index {} is not ASCII", self.0)
+    }
+}
+#[cfg(feature = "std")]
+impl Error for AsAsciiStrError {
+    #[inline]
+    fn description(&self) -> &'static str {
+        ERRORMSG_STR
+    }
+}
+
+/// Convert slices of bytes or [`AsciiChar`] to [`AsciiStr`].
+// Could nearly replace this trait with SliceIndex, but its methods isn't even
+// on a path for stabilization.
+pub trait AsAsciiStr {
+    /// Used to constrain `SliceIndex`
+    #[doc(hidden)]
+    type Inner;
+    /// Convert a subslice to an ASCII slice.
+    ///
+    /// # Errors
+    /// Returns `Err` if the range is out of bounds or if not all bytes in the
+    /// slice are ASCII. The value in the error will be the index of the first
+    /// non-ASCII byte or the end of the slice.
+    ///
+    /// # Examples
+    /// ```
+    /// use ascii::AsAsciiStr;
+    /// assert!("'zoä'".slice_ascii(..3).is_ok());
+    /// assert!("'zoä'".slice_ascii(0..4).is_err());
+    /// assert!("'zoä'".slice_ascii(5..=5).is_ok());
+    /// assert!("'zoä'".slice_ascii(4..).is_err());
+    /// assert!(b"\r\n".slice_ascii(..).is_ok());
+    /// ```
+    fn slice_ascii<R>(&self, range: R) -> Result<&AsciiStr, AsAsciiStrError>
+    where
+        R: SliceIndex<[Self::Inner], Output = [Self::Inner]>;
+    /// Convert to an ASCII slice.
+    ///
+    /// # Errors
+    /// Returns `Err` if not all bytes are valid ascii values.
+    ///
+    /// # Example
+    /// ```
+    /// use ascii::{AsAsciiStr, AsciiChar};
+    /// assert!("ASCII".as_ascii_str().is_ok());
+    /// assert!(b"\r\n".as_ascii_str().is_ok());
+    /// assert!("'zoä'".as_ascii_str().is_err());
+    /// assert!(b"\xff".as_ascii_str().is_err());
+    /// assert!([AsciiChar::C][..].as_ascii_str().is_ok()); // infallible
+    /// ```
+    fn as_ascii_str(&self) -> Result<&AsciiStr, AsAsciiStrError> {
+        self.slice_ascii(..)
+    }
+    /// Get a single ASCII character from the slice.
+    ///
+    /// Returns `None` if the index is out of bounds or the byte is not ASCII.
+    ///
+    /// # Examples
+    /// ```
+    /// use ascii::{AsAsciiStr, AsciiChar};
+    /// assert_eq!("'zoä'".get_ascii(4), None);
+    /// assert_eq!("'zoä'".get_ascii(5), Some(AsciiChar::Apostrophe));
+    /// assert_eq!("'zoä'".get_ascii(6), None);
+    /// ```
+    fn get_ascii(&self, index: usize) -> Option<AsciiChar> {
+        self.slice_ascii(index..=index)
+            .ok()
+            .and_then(AsciiStr::first)
+    }
+    /// Convert to an ASCII slice without checking for non-ASCII characters.
+    ///
+    /// # Safety
+    /// Calling this function when `self` contains non-ascii characters is
+    /// undefined behavior.
+    ///
+    /// # Examples
+    ///
+    unsafe fn as_ascii_str_unchecked(&self) -> &AsciiStr;
+}
+
+/// Convert mutable slices of bytes or [`AsciiChar`] to [`AsciiStr`].
+pub trait AsMutAsciiStr: AsAsciiStr {
+    /// Convert a subslice to an ASCII slice.
+    ///
+    /// # Errors
+    /// This function returns `Err` if range is out of bounds, or if
+    /// `self` contains non-ascii values
+    fn slice_ascii_mut<R>(&mut self, range: R) -> Result<&mut AsciiStr, AsAsciiStrError>
+    where
+        R: SliceIndex<[Self::Inner], Output = [Self::Inner]>;
+
+    /// Convert to a mutable ASCII slice.
+    ///
+    /// # Errors
+    /// This function returns `Err` if `self` contains non-ascii values
+    fn as_mut_ascii_str(&mut self) -> Result<&mut AsciiStr, AsAsciiStrError> {
+        self.slice_ascii_mut(..)
+    }
+
+    /// Convert to a mutable ASCII slice without checking for non-ASCII characters.
+    ///
+    /// # Safety
+    /// Calling this function when `self` contains non-ascii characters is
+    /// undefined behavior.
+    unsafe fn as_mut_ascii_str_unchecked(&mut self) -> &mut AsciiStr;
+}
+
+// These generic implementations mirror the generic implementations for AsRef<T> in core.
+impl<'a, T> AsAsciiStr for &'a T
+where
+    T: AsAsciiStr + ?Sized,
+{
+    type Inner = <T as AsAsciiStr>::Inner;
+    fn slice_ascii<R>(&self, range: R) -> Result<&AsciiStr, AsAsciiStrError>
+    where
+        R: SliceIndex<[Self::Inner], Output = [Self::Inner]>,
+    {
+        <T as AsAsciiStr>::slice_ascii(*self, range)
+    }
+
+    unsafe fn as_ascii_str_unchecked(&self) -> &AsciiStr {
+        // SAFETY: Caller guarantees `self` does not contain non-ascii characters
+        unsafe { <T as AsAsciiStr>::as_ascii_str_unchecked(*self) }
+    }
+}
+
+impl<'a, T> AsAsciiStr for &'a mut T
+where
+    T: AsAsciiStr + ?Sized,
+{
+    type Inner = <T as AsAsciiStr>::Inner;
+    fn slice_ascii<R>(&self, range: R) -> Result<&AsciiStr, AsAsciiStrError>
+    where
+        R: SliceIndex<[Self::Inner], Output = [Self::Inner]>,
+    {
+        <T as AsAsciiStr>::slice_ascii(*self, range)
+    }
+
+    unsafe fn as_ascii_str_unchecked(&self) -> &AsciiStr {
+        // SAFETY: Caller guarantees `self` does not contain non-ascii characters
+        unsafe { <T as AsAsciiStr>::as_ascii_str_unchecked(*self) }
+    }
+}
+
+impl<'a, T> AsMutAsciiStr for &'a mut T
+where
+    T: AsMutAsciiStr + ?Sized,
+{
+    fn slice_ascii_mut<R>(&mut self, range: R) -> Result<&mut AsciiStr, AsAsciiStrError>
+    where
+        R: SliceIndex<[Self::Inner], Output = [Self::Inner]>,
+    {
+        <T as AsMutAsciiStr>::slice_ascii_mut(*self, range)
+    }
+
+    unsafe fn as_mut_ascii_str_unchecked(&mut self) -> &mut AsciiStr {
+        // SAFETY: Caller guarantees `self` does not contain non-ascii characters
+        unsafe { <T as AsMutAsciiStr>::as_mut_ascii_str_unchecked(*self) }
+    }
+}
+
+impl AsAsciiStr for AsciiStr {
+    type Inner = AsciiChar;
+
+    fn slice_ascii<R>(&self, range: R) -> Result<&AsciiStr, AsAsciiStrError>
+    where
+        R: SliceIndex<[AsciiChar], Output = [AsciiChar]>,
+    {
+        self.slice.slice_ascii(range)
+    }
+
+    #[inline]
+    fn as_ascii_str(&self) -> Result<&AsciiStr, AsAsciiStrError> {
+        Ok(self)
+    }
+
+    #[inline]
+    unsafe fn as_ascii_str_unchecked(&self) -> &AsciiStr {
+        self
+    }
+
+    #[inline]
+    fn get_ascii(&self, index: usize) -> Option<AsciiChar> {
+        self.slice.get_ascii(index)
+    }
+}
+impl AsMutAsciiStr for AsciiStr {
+    fn slice_ascii_mut<R>(&mut self, range: R) -> Result<&mut AsciiStr, AsAsciiStrError>
+    where
+        R: SliceIndex<[AsciiChar], Output = [AsciiChar]>,
+    {
+        self.slice.slice_ascii_mut(range)
+    }
+
+    #[inline]
+    unsafe fn as_mut_ascii_str_unchecked(&mut self) -> &mut AsciiStr {
+        self
+    }
+}
+
+impl AsAsciiStr for [AsciiChar] {
+    type Inner = AsciiChar;
+    fn slice_ascii<R>(&self, range: R) -> Result<&AsciiStr, AsAsciiStrError>
+    where
+        R: SliceIndex<[AsciiChar], Output = [AsciiChar]>,
+    {
+        match self.get(range) {
+            Some(slice) => Ok(slice.into()),
+            None => Err(AsAsciiStrError(self.len())),
+        }
+    }
+
+    #[inline]
+    fn as_ascii_str(&self) -> Result<&AsciiStr, AsAsciiStrError> {
+        Ok(self.into())
+    }
+
+    #[inline]
+    unsafe fn as_ascii_str_unchecked(&self) -> &AsciiStr {
+        <&AsciiStr>::from(self)
+    }
+
+    #[inline]
+    fn get_ascii(&self, index: usize) -> Option<AsciiChar> {
+        self.get(index).copied()
+    }
+}
+impl AsMutAsciiStr for [AsciiChar] {
+    fn slice_ascii_mut<R>(&mut self, range: R) -> Result<&mut AsciiStr, AsAsciiStrError>
+    where
+        R: SliceIndex<[AsciiChar], Output = [AsciiChar]>,
+    {
+        let len = self.len();
+        match self.get_mut(range) {
+            Some(slice) => Ok(slice.into()),
+            None => Err(AsAsciiStrError(len)),
+        }
+    }
+    #[inline]
+    unsafe fn as_mut_ascii_str_unchecked(&mut self) -> &mut AsciiStr {
+        <&mut AsciiStr>::from(self)
+    }
+}
+
+impl AsAsciiStr for [u8] {
+    type Inner = u8;
+
+    fn slice_ascii<R>(&self, range: R) -> Result<&AsciiStr, AsAsciiStrError>
+    where
+        R: SliceIndex<[u8], Output = [u8]>,
+    {
+        if let Some(slice) = self.get(range) {
+            slice.as_ascii_str().map_err(|AsAsciiStrError(not_ascii)| {
+                let offset = slice.as_ptr() as usize - self.as_ptr() as usize;
+                AsAsciiStrError(offset + not_ascii)
+            })
+        } else {
+            Err(AsAsciiStrError(self.len()))
+        }
+    }
+
+    fn as_ascii_str(&self) -> Result<&AsciiStr, AsAsciiStrError> {
+        // is_ascii is likely optimized
+        if self.is_ascii() {
+            // SAFETY: `is_ascii` guarantees all bytes are within ascii range.
+            unsafe { Ok(self.as_ascii_str_unchecked()) }
+        } else {
+            Err(AsAsciiStrError(
+                self.iter().take_while(|&b| b.is_ascii()).count(),
+            ))
+        }
+    }
+
+    #[inline]
+    unsafe fn as_ascii_str_unchecked(&self) -> &AsciiStr {
+        // SAFETY: Caller guarantees `self` does not contain non-ascii characters
+        unsafe { &*(self as *const [u8] as *const AsciiStr) }
+    }
+}
+impl AsMutAsciiStr for [u8] {
+    fn slice_ascii_mut<R>(&mut self, range: R) -> Result<&mut AsciiStr, AsAsciiStrError>
+    where
+        R: SliceIndex<[u8], Output = [u8]>,
+    {
+        let (ptr, len) = (self.as_ptr(), self.len());
+        if let Some(slice) = self.get_mut(range) {
+            let slice_ptr = slice.as_ptr();
+            slice
+                .as_mut_ascii_str()
+                .map_err(|AsAsciiStrError(not_ascii)| {
+                    let offset = slice_ptr as usize - ptr as usize;
+                    AsAsciiStrError(offset + not_ascii)
+                })
+        } else {
+            Err(AsAsciiStrError(len))
+        }
+    }
+
+    fn as_mut_ascii_str(&mut self) -> Result<&mut AsciiStr, AsAsciiStrError> {
+        // is_ascii() is likely optimized
+        if self.is_ascii() {
+            // SAFETY: `is_ascii` guarantees all bytes are within ascii range.
+            unsafe { Ok(self.as_mut_ascii_str_unchecked()) }
+        } else {
+            Err(AsAsciiStrError(
+                self.iter().take_while(|&b| b.is_ascii()).count(),
+            ))
+        }
+    }
+
+    #[inline]
+    unsafe fn as_mut_ascii_str_unchecked(&mut self) -> &mut AsciiStr {
+        // SAFETY: Caller guarantees `self` does not contain non-ascii characters
+        unsafe { &mut *(self as *mut [u8] as *mut AsciiStr) }
+    }
+}
+
+impl AsAsciiStr for str {
+    type Inner = u8;
+    fn slice_ascii<R>(&self, range: R) -> Result<&AsciiStr, AsAsciiStrError>
+    where
+        R: SliceIndex<[u8], Output = [u8]>,
+    {
+        self.as_bytes().slice_ascii(range)
+    }
+    fn as_ascii_str(&self) -> Result<&AsciiStr, AsAsciiStrError> {
+        self.as_bytes().as_ascii_str()
+    }
+    #[inline]
+    unsafe fn as_ascii_str_unchecked(&self) -> &AsciiStr {
+        // SAFETY: Caller guarantees `self` does not contain non-ascii characters
+        unsafe { self.as_bytes().as_ascii_str_unchecked() }
+    }
+}
+impl AsMutAsciiStr for str {
+    fn slice_ascii_mut<R>(&mut self, range: R) -> Result<&mut AsciiStr, AsAsciiStrError>
+    where
+        R: SliceIndex<[u8], Output = [u8]>,
+    {
+        // SAFETY: We don't modify the reference in this function, and the caller may
+        //         only modify it to include valid ascii characters.
+        let bytes = unsafe { self.as_bytes_mut() };
+        match bytes.get_mut(range) {
+            // Valid ascii slice
+            Some(slice) if slice.is_ascii() => {
+                // SAFETY: All bytes are ascii, so this cast is valid
+                let ptr = slice.as_mut_ptr().cast::<AsciiChar>();
+                let len = slice.len();
+
+                // SAFETY: The pointer is valid for `len` elements, as it came
+                //         from a slice.
+                unsafe {
+                    let slice = core::slice::from_raw_parts_mut(ptr, len);
+                    Ok(<&mut AsciiStr>::from(slice))
+                }
+            }
+            Some(slice) => {
+                let not_ascii_len = slice.iter().copied().take_while(u8::is_ascii).count();
+                let offset = slice.as_ptr() as usize - self.as_ptr() as usize;
+
+                Err(AsAsciiStrError(offset + not_ascii_len))
+            }
+            None => Err(AsAsciiStrError(self.len())),
+        }
+    }
+    fn as_mut_ascii_str(&mut self) -> Result<&mut AsciiStr, AsAsciiStrError> {
+        match self.bytes().position(|b| !b.is_ascii()) {
+            Some(index) => Err(AsAsciiStrError(index)),
+            // SAFETY: All bytes were iterated, and all were ascii
+            None => unsafe { Ok(self.as_mut_ascii_str_unchecked()) },
+        }
+    }
+    #[inline]
+    unsafe fn as_mut_ascii_str_unchecked(&mut self) -> &mut AsciiStr {
+        // SAFETY: Caller guarantees `self` does not contain non-ascii characters
+        &mut *(self as *mut str as *mut AsciiStr)
+    }
+}
+
+/// Note that the trailing null byte will be removed in the conversion.
+#[cfg(feature = "std")]
+impl AsAsciiStr for CStr {
+    type Inner = u8;
+    fn slice_ascii<R>(&self, range: R) -> Result<&AsciiStr, AsAsciiStrError>
+    where
+        R: SliceIndex<[u8], Output = [u8]>,
+    {
+        self.to_bytes().slice_ascii(range)
+    }
+    #[inline]
+    fn as_ascii_str(&self) -> Result<&AsciiStr, AsAsciiStrError> {
+        self.to_bytes().as_ascii_str()
+    }
+    #[inline]
+    unsafe fn as_ascii_str_unchecked(&self) -> &AsciiStr {
+        // SAFETY: Caller guarantees `self` does not contain non-ascii characters
+        unsafe { self.to_bytes().as_ascii_str_unchecked() }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{AsAsciiStr, AsAsciiStrError, AsMutAsciiStr, AsciiStr};
+    #[cfg(feature = "alloc")]
+    use alloc::string::{String, ToString};
+    #[cfg(feature = "alloc")]
+    use alloc::vec::Vec;
+    use AsciiChar;
+
+    /// Ensures that common types, `str`, `[u8]`, `AsciiStr` and their
+    /// references, shared and mutable implement `AsAsciiStr`.
+    #[test]
+    fn generic_as_ascii_str() {
+        // Generic function to ensure `C` implements `AsAsciiStr`
+        fn generic<C: AsAsciiStr + ?Sized>(c: &C) -> Result<&AsciiStr, AsAsciiStrError> {
+            c.as_ascii_str()
+        }
+
+        let arr = [AsciiChar::A];
+        let ascii_str = arr.as_ref().into();
+        let mut mut_arr = arr; // Note: We need a second copy to prevent overlapping mutable borrows.
+        let mut_ascii_str = mut_arr.as_mut().into();
+        let mut_arr_mut_ref: &mut [AsciiChar] = &mut [AsciiChar::A];
+        let mut string_bytes = [b'A'];
+        let string_mut = unsafe { core::str::from_utf8_unchecked_mut(&mut string_bytes) }; // SAFETY: 'A' is a valid string.
+        let string_mut_bytes: &mut [u8] = &mut [b'A'];
+
+        // Note: This is a trick because `rustfmt` doesn't support
+        //       attributes on blocks yet.
+        #[rustfmt::skip]
+        let _ = [
+            assert_eq!(generic::<str             >("A"              ), Ok(ascii_str)),
+            assert_eq!(generic::<[u8]            >(&b"A"[..]        ), Ok(ascii_str)),
+            assert_eq!(generic::<AsciiStr        >(ascii_str        ), Ok(ascii_str)),
+            assert_eq!(generic::<[AsciiChar]     >(&arr             ), Ok(ascii_str)),
+            assert_eq!(generic::<&str            >(&"A"             ), Ok(ascii_str)),
+            assert_eq!(generic::<&[u8]           >(&&b"A"[..]       ), Ok(ascii_str)),
+            assert_eq!(generic::<&AsciiStr       >(&ascii_str       ), Ok(ascii_str)),
+            assert_eq!(generic::<&[AsciiChar]    >(&&arr[..]        ), Ok(ascii_str)),
+            assert_eq!(generic::<&mut str        >(&string_mut      ), Ok(ascii_str)),
+            assert_eq!(generic::<&mut [u8]       >(&string_mut_bytes), Ok(ascii_str)),
+            assert_eq!(generic::<&mut AsciiStr   >(&mut_ascii_str   ), Ok(ascii_str)),
+            assert_eq!(generic::<&mut [AsciiChar]>(&mut_arr_mut_ref ), Ok(ascii_str)),
+        ];
+    }
+
+    #[cfg(feature = "std")]
+    #[test]
+    fn cstring_as_ascii_str() {
+        use std::ffi::CString;
+        fn generic<C: AsAsciiStr + ?Sized>(c: &C) -> Result<&AsciiStr, AsAsciiStrError> {
+            c.as_ascii_str()
+        }
+        let arr = [AsciiChar::A];
+        let ascii_str: &AsciiStr = arr.as_ref().into();
+        let cstr = CString::new("A").unwrap();
+        assert_eq!(generic(&*cstr), Ok(ascii_str));
+    }
+
+    #[test]
+    fn generic_as_mut_ascii_str() {
+        fn generic_mut<C: AsMutAsciiStr + ?Sized>(
+            c: &mut C,
+        ) -> Result<&mut AsciiStr, AsAsciiStrError> {
+            c.as_mut_ascii_str()
+        }
+
+        let mut arr_mut = [AsciiChar::B];
+        let mut ascii_str_mut: &mut AsciiStr = arr_mut.as_mut().into();
+        // Need a second reference to prevent overlapping mutable borrows
+        let mut arr_mut_2 = [AsciiChar::B];
+        let ascii_str_mut_2: &mut AsciiStr = arr_mut_2.as_mut().into();
+        assert_eq!(generic_mut(&mut ascii_str_mut), Ok(&mut *ascii_str_mut_2));
+        assert_eq!(generic_mut(ascii_str_mut), Ok(&mut *ascii_str_mut_2));
+    }
+
+    #[test]
+    fn as_ascii_str() {
+        macro_rules! err {{$i:expr} => {Err(AsAsciiStrError($i))}}
+        let s = "abčd";
+        let b = s.as_bytes();
+        assert_eq!(s.as_ascii_str(), err!(2));
+        assert_eq!(b.as_ascii_str(), err!(2));
+        let a: &AsciiStr = [AsciiChar::a, AsciiChar::b][..].as_ref();
+        assert_eq!(s[..2].as_ascii_str(), Ok(a));
+        assert_eq!(b[..2].as_ascii_str(), Ok(a));
+        assert_eq!(s.slice_ascii(..2), Ok(a));
+        assert_eq!(b.slice_ascii(..2), Ok(a));
+        assert_eq!(s.slice_ascii(..=2), err!(2));
+        assert_eq!(b.slice_ascii(..=2), err!(2));
+        assert_eq!(s.get_ascii(4), Some(AsciiChar::d));
+        assert_eq!(b.get_ascii(4), Some(AsciiChar::d));
+        assert_eq!(s.get_ascii(3), None);
+        assert_eq!(b.get_ascii(3), None);
+        assert_eq!(s.get_ascii(b.len()), None);
+        assert_eq!(b.get_ascii(b.len()), None);
+        assert_eq!(a.get_ascii(0), Some(AsciiChar::a));
+        assert_eq!(a.get_ascii(a.len()), None);
+    }
+
+    #[test]
+    #[cfg(feature = "std")]
+    fn cstr_as_ascii_str() {
+        use std::ffi::CStr;
+        macro_rules! err {{$i:expr} => {Err(AsAsciiStrError($i))}}
+        let cstr = CStr::from_bytes_with_nul(b"a\xbbcde\xffg\0").unwrap();
+        assert_eq!(cstr.as_ascii_str(), err!(1));
+        assert_eq!(cstr.slice_ascii(2..), err!(5));
+        assert_eq!(cstr.get_ascii(5), None);
+        assert_eq!(cstr.get_ascii(6), Some(AsciiChar::g));
+        assert_eq!(cstr.get_ascii(7), None);
+        let ascii_slice = &[AsciiChar::X, AsciiChar::Y, AsciiChar::Z, AsciiChar::Null][..];
+        let ascii_str: &AsciiStr = ascii_slice.as_ref();
+        let cstr = CStr::from_bytes_with_nul(ascii_str.as_bytes()).unwrap();
+        assert_eq!(cstr.slice_ascii(..2), Ok(&ascii_str[..2]));
+        assert_eq!(cstr.as_ascii_str(), Ok(&ascii_str[..3]));
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn as_mut_ascii_str() {
+        macro_rules! err {{$i:expr} => {Err(AsAsciiStrError($i))}}
+        let mut s: String = "abčd".to_string();
+        let mut b: Vec<u8> = s.clone().into();
+        let mut first = [AsciiChar::a, AsciiChar::b];
+        let mut second = [AsciiChar::d];
+        assert_eq!(s.as_mut_ascii_str(), err!(2));
+        assert_eq!(b.as_mut_ascii_str(), err!(2));
+        assert_eq!(s.slice_ascii_mut(..), err!(2));
+        assert_eq!(b.slice_ascii_mut(..), err!(2));
+        assert_eq!(s[..2].as_mut_ascii_str(), Ok((&mut first[..]).into()));
+        assert_eq!(b[..2].as_mut_ascii_str(), Ok((&mut first[..]).into()));
+        assert_eq!(s.slice_ascii_mut(0..2), Ok((&mut first[..]).into()));
+        assert_eq!(b.slice_ascii_mut(0..2), Ok((&mut first[..]).into()));
+        assert_eq!(s.slice_ascii_mut(4..), Ok((&mut second[..]).into()));
+        assert_eq!(b.slice_ascii_mut(4..), Ok((&mut second[..]).into()));
+        assert_eq!(s.slice_ascii_mut(4..=10), err!(5));
+        assert_eq!(b.slice_ascii_mut(4..=10), err!(5));
+    }
+
+    #[test]
+    fn default() {
+        let default: &'static AsciiStr = Default::default();
+        assert!(default.is_empty());
+    }
+
+    #[test]
+    #[allow(clippy::redundant_slicing)]
+    fn index() {
+        let mut arr = [AsciiChar::A, AsciiChar::B, AsciiChar::C, AsciiChar::D];
+        {
+            let a: &AsciiStr = arr[..].into();
+            assert_eq!(a[..].as_slice(), &a.as_slice()[..]);
+            assert_eq!(a[..4].as_slice(), &a.as_slice()[..4]);
+            assert_eq!(a[4..].as_slice(), &a.as_slice()[4..]);
+            assert_eq!(a[2..3].as_slice(), &a.as_slice()[2..3]);
+            assert_eq!(a[..=3].as_slice(), &a.as_slice()[..=3]);
+            assert_eq!(a[1..=1].as_slice(), &a.as_slice()[1..=1]);
+        }
+        let mut copy = arr;
+        let a_mut: &mut AsciiStr = { &mut arr[..] }.into();
+        assert_eq!(a_mut[..].as_mut_slice(), &mut copy[..]);
+        assert_eq!(a_mut[..2].as_mut_slice(), &mut copy[..2]);
+        assert_eq!(a_mut[3..].as_mut_slice(), &mut copy[3..]);
+        assert_eq!(a_mut[4..4].as_mut_slice(), &mut copy[4..4]);
+        assert_eq!(a_mut[..=0].as_mut_slice(), &mut copy[..=0]);
+        assert_eq!(a_mut[0..=2].as_mut_slice(), &mut copy[0..=2]);
+    }
+
+    #[test]
+    fn as_str() {
+        let b = b"( ;";
+        let v = AsciiStr::from_ascii(b).unwrap();
+        assert_eq!(v.as_str(), "( ;");
+        assert_eq!(AsRef::<str>::as_ref(v), "( ;");
+    }
+
+    #[test]
+    fn as_bytes() {
+        let b = b"( ;";
+        let v = AsciiStr::from_ascii(b).unwrap();
+        assert_eq!(v.as_bytes(), b"( ;");
+        assert_eq!(AsRef::<[u8]>::as_ref(v), b"( ;");
+    }
+
+    #[test]
+    fn make_ascii_case() {
+        let mut bytes = ([b'a', b'@', b'A'], [b'A', b'@', b'a']);
+        let a = bytes.0.as_mut_ascii_str().unwrap();
+        let b = bytes.1.as_mut_ascii_str().unwrap();
+        assert!(a.eq_ignore_ascii_case(b));
+        assert!(b.eq_ignore_ascii_case(a));
+        a.make_ascii_lowercase();
+        b.make_ascii_uppercase();
+        assert_eq!(a, "a@a");
+        assert_eq!(b, "A@A");
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn to_ascii_case() {
+        let bytes = ([b'a', b'@', b'A'], [b'A', b'@', b'a']);
+        let a = bytes.0.as_ascii_str().unwrap();
+        let b = bytes.1.as_ascii_str().unwrap();
+        assert_eq!(a.to_ascii_lowercase().as_str(), "a@a");
+        assert_eq!(a.to_ascii_uppercase().as_str(), "A@A");
+        assert_eq!(b.to_ascii_lowercase().as_str(), "a@a");
+        assert_eq!(b.to_ascii_uppercase().as_str(), "A@A");
+    }
+
+    #[test]
+    fn chars_iter() {
+        let chars = &[
+            b'h', b'e', b'l', b'l', b'o', b' ', b'w', b'o', b'r', b'l', b'd', b'\0',
+        ];
+        let ascii = AsciiStr::from_ascii(chars).unwrap();
+        for (achar, byte) in ascii.chars().zip(chars.iter().copied()) {
+            assert_eq!(achar, byte);
+        }
+    }
+
+    #[test]
+    fn chars_iter_mut() {
+        let chars = &mut [
+            b'h', b'e', b'l', b'l', b'o', b' ', b'w', b'o', b'r', b'l', b'd', b'\0',
+        ];
+        let ascii = chars.as_mut_ascii_str().unwrap();
+        *ascii.chars_mut().next().unwrap() = AsciiChar::H;
+        assert_eq!(ascii[0], b'H');
+    }
+
+    #[test]
+    fn lines_iter() {
+        use core::iter::Iterator;
+
+        let lines: [&str; 4] = ["foo", "bar", "", "baz"];
+        let joined = "foo\r\nbar\n\nbaz\n";
+        let ascii = AsciiStr::from_ascii(joined.as_bytes()).unwrap();
+        for (asciiline, line) in ascii.lines().zip(&lines) {
+            assert_eq!(asciiline, *line);
+        }
+        assert_eq!(ascii.lines().count(), lines.len());
+
+        let lines: [&str; 4] = ["foo", "bar", "", "baz"];
+        let joined = "foo\r\nbar\n\nbaz";
+        let ascii = AsciiStr::from_ascii(joined.as_bytes()).unwrap();
+        for (asciiline, line) in ascii.lines().zip(&lines) {
+            assert_eq!(asciiline, *line);
+        }
+        assert_eq!(ascii.lines().count(), lines.len());
+
+        let trailing_line_break = b"\n";
+        let ascii = AsciiStr::from_ascii(&trailing_line_break).unwrap();
+        let mut line_iter = ascii.lines();
+        assert_eq!(line_iter.next(), Some(AsciiStr::from_ascii("").unwrap()));
+        assert_eq!(line_iter.next(), None);
+
+        let empty_lines = b"\n\r\n\n\r\n";
+        let mut iter_count = 0;
+        let ascii = AsciiStr::from_ascii(&empty_lines).unwrap();
+        for line in ascii.lines() {
+            iter_count += 1;
+            assert!(line.is_empty());
+        }
+        assert_eq!(4, iter_count);
+    }
+
+    #[test]
+    fn lines_iter_rev() {
+        let joined = "foo\r\nbar\n\nbaz\n";
+        let ascii = AsciiStr::from_ascii(joined.as_bytes()).unwrap();
+        assert_eq!(ascii.lines().rev().count(), 4);
+        assert_eq!(ascii.lines().rev().count(), joined.lines().rev().count());
+        for (asciiline, line) in ascii.lines().rev().zip(joined.lines().rev()) {
+            assert_eq!(asciiline, line);
+        }
+        let mut iter = ascii.lines();
+        assert_eq!(iter.next(), Some("foo".as_ascii_str().unwrap()));
+        assert_eq!(iter.next_back(), Some("baz".as_ascii_str().unwrap()));
+        assert_eq!(iter.next_back(), Some("".as_ascii_str().unwrap()));
+        assert_eq!(iter.next(), Some("bar".as_ascii_str().unwrap()));
+
+        let empty_lines = b"\n\r\n\n\r\n";
+        let mut iter_count = 0;
+        let ascii = AsciiStr::from_ascii(&empty_lines).unwrap();
+        for line in ascii.lines().rev() {
+            iter_count += 1;
+            assert!(line.is_empty());
+        }
+        assert_eq!(4, iter_count);
+    }
+
+    #[test]
+    fn lines_iter_empty() {
+        assert_eq!("".as_ascii_str().unwrap().lines().next(), None);
+        assert_eq!("".as_ascii_str().unwrap().lines().next_back(), None);
+        assert_eq!("".lines().next(), None);
+    }
+
+    #[test]
+    fn split_str() {
+        fn split_equals_str(haystack: &str, needle: char) {
+            let mut strs = haystack.split(needle);
+            let mut asciis = haystack
+                .as_ascii_str()
+                .unwrap()
+                .split(AsciiChar::from_ascii(needle).unwrap())
+                .map(AsciiStr::as_str);
+            loop {
+                assert_eq!(asciis.size_hint(), strs.size_hint());
+                let (a, s) = (asciis.next(), strs.next());
+                assert_eq!(a, s);
+                if a == None {
+                    break;
+                }
+            }
+            // test fusedness if str's version is fused
+            if strs.next() == None {
+                assert_eq!(asciis.next(), None);
+            }
+        }
+        split_equals_str("", '=');
+        split_equals_str("1,2,3", ',');
+        split_equals_str("foo;bar;baz;", ';');
+        split_equals_str("|||", '|');
+        split_equals_str(" a  b  c ", ' ');
+    }
+
+    #[test]
+    fn split_str_rev() {
+        let words = " foo  bar baz ";
+        let ascii = words.as_ascii_str().unwrap();
+        for (word, asciiword) in words
+            .split(' ')
+            .rev()
+            .zip(ascii.split(AsciiChar::Space).rev())
+        {
+            assert_eq!(asciiword, word);
+        }
+        let mut iter = ascii.split(AsciiChar::Space);
+        assert_eq!(iter.next(), Some("".as_ascii_str().unwrap()));
+        assert_eq!(iter.next_back(), Some("".as_ascii_str().unwrap()));
+        assert_eq!(iter.next(), Some("foo".as_ascii_str().unwrap()));
+        assert_eq!(iter.next_back(), Some("baz".as_ascii_str().unwrap()));
+        assert_eq!(iter.next_back(), Some("bar".as_ascii_str().unwrap()));
+        assert_eq!(iter.next(), Some("".as_ascii_str().unwrap()));
+        assert_eq!(iter.next_back(), None);
+    }
+
+    #[test]
+    fn split_str_empty() {
+        let empty = <&AsciiStr>::default();
+        let mut iter = empty.split(AsciiChar::NAK);
+        assert_eq!(iter.next(), Some(empty));
+        assert_eq!(iter.next(), None);
+        let mut iter = empty.split(AsciiChar::NAK);
+        assert_eq!(iter.next_back(), Some(empty));
+        assert_eq!(iter.next_back(), None);
+        assert_eq!("".split('s').next(), Some("")); // str.split() also produces one element
+    }
+
+    #[test]
+    #[cfg(feature = "std")]
+    fn fmt_ascii_str() {
+        let s = "abc".as_ascii_str().unwrap();
+        assert_eq!(format!("{}", s), "abc".to_string());
+        assert_eq!(format!("{:?}", s), "\"abc\"".to_string());
+    }
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/ascii-1.1.0/src/ascii_string.rs

@@ -0,0 +1,1057 @@
+use alloc::borrow::{Borrow, BorrowMut, Cow, ToOwned};
+use alloc::fmt;
+use alloc::string::String;
+use alloc::vec::Vec;
+use alloc::boxed::Box;
+use alloc::rc::Rc;
+use alloc::sync::Arc;
+#[cfg(feature = "std")]
+use core::any::Any;
+use core::iter::FromIterator;
+use core::mem;
+use core::ops::{Add, AddAssign, Deref, DerefMut, Index, IndexMut};
+use core::str::FromStr;
+#[cfg(feature = "std")]
+use std::error::Error;
+#[cfg(feature = "std")]
+use std::ffi::{CStr, CString};
+
+use ascii_char::AsciiChar;
+use ascii_str::{AsAsciiStr, AsAsciiStrError, AsciiStr};
+
+/// A growable string stored as an ASCII encoded buffer.
+#[derive(Clone, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[repr(transparent)]
+pub struct AsciiString {
+    vec: Vec<AsciiChar>,
+}
+
+impl AsciiString {
+    /// Creates a new, empty ASCII string buffer without allocating.
+    ///
+    /// # Examples
+    /// ```
+    /// # use ascii::AsciiString;
+    /// let mut s = AsciiString::new();
+    /// ```
+    #[inline]
+    #[must_use]
+    pub const fn new() -> Self {
+        AsciiString { vec: Vec::new() }
+    }
+
+    /// Creates a new ASCII string buffer with the given capacity.
+    /// The string will be able to hold exactly `capacity` bytes without reallocating.
+    /// If `capacity` is 0, the ASCII string will not allocate.
+    ///
+    /// # Examples
+    /// ```
+    /// # use ascii::AsciiString;
+    /// let mut s = AsciiString::with_capacity(10);
+    /// ```
+    #[inline]
+    #[must_use]
+    pub fn with_capacity(capacity: usize) -> Self {
+        AsciiString {
+            vec: Vec::with_capacity(capacity),
+        }
+    }
+
+    /// Creates a new `AsciiString` from a length, capacity and pointer.
+    ///
+    /// # Safety
+    ///
+    /// This is highly unsafe, due to the number of invariants that aren't checked:
+    ///
+    /// * The memory at `buf` need to have been previously allocated by the same allocator this
+    ///   library uses, with an alignment of 1.
+    /// * `length` needs to be less than or equal to `capacity`.
+    /// * `capacity` needs to be the correct value.
+    /// * `buf` must have `length` valid ascii elements and contain a total of `capacity` total,
+    ///   possibly, uninitialized, elements.
+    /// * Nothing else must be using the memory `buf` points to.
+    ///
+    /// Violating these may cause problems like corrupting the allocator's internal data structures.
+    ///
+    /// # Examples
+    ///
+    /// Basic usage:
+    ///
+    /// ```
+    /// # use ascii::AsciiString;
+    /// use std::mem;
+    ///
+    /// unsafe {
+    ///    let mut s = AsciiString::from_ascii("hello").unwrap();
+    ///    let ptr = s.as_mut_ptr();
+    ///    let len = s.len();
+    ///    let capacity = s.capacity();
+    ///
+    ///    mem::forget(s);
+    ///
+    ///    let s = AsciiString::from_raw_parts(ptr, len, capacity);
+    ///
+    ///    assert_eq!(AsciiString::from_ascii("hello").unwrap(), s);
+    /// }
+    /// ```
+    #[inline]
+    #[must_use]
+    pub unsafe fn from_raw_parts(buf: *mut AsciiChar, length: usize, capacity: usize) -> Self {
+        AsciiString {
+            // SAFETY: Caller guarantees that `buf` was previously allocated by this library,
+            //         that `buf` contains `length` valid ascii elements and has a total capacity
+            //         of `capacity` elements, and that nothing else is using the momory.
+            vec: unsafe { Vec::from_raw_parts(buf, length, capacity) },
+        }
+    }
+
+    /// Converts a vector of bytes to an `AsciiString` without checking for non-ASCII characters.
+    ///
+    /// # Safety
+    /// This function is unsafe because it does not check that the bytes passed to it are valid
+    /// ASCII characters. If this constraint is violated, it may cause memory unsafety issues with
+    /// future of the `AsciiString`, as the rest of this library assumes that `AsciiString`s are
+    /// ASCII encoded.
+    #[inline]
+    #[must_use]
+    pub unsafe fn from_ascii_unchecked<B>(bytes: B) -> Self
+    where
+        B: Into<Vec<u8>>,
+    {
+        let mut bytes = bytes.into();
+        // SAFETY: The caller guarantees all bytes are valid ascii bytes.
+        let ptr = bytes.as_mut_ptr().cast::<AsciiChar>();
+        let length = bytes.len();
+        let capacity = bytes.capacity();
+        mem::forget(bytes);
+
+        // SAFETY: We guarantee all invariants, as we got the
+        //         pointer, length and capacity from a `Vec`,
+        //         and we also guarantee the pointer is valid per
+        //         the `SAFETY` notice above.
+        let vec = Vec::from_raw_parts(ptr, length, capacity);
+
+        Self { vec }
+    }
+
+    /// Converts anything that can represent a byte buffer into an `AsciiString`.
+    ///
+    /// # Errors
+    /// Returns the byte buffer if not all of the bytes are ASCII characters.
+    ///
+    /// # Examples
+    /// ```
+    /// # use ascii::AsciiString;
+    /// let foo = AsciiString::from_ascii("foo".to_string()).unwrap();
+    /// let err = AsciiString::from_ascii("Ŋ".to_string()).unwrap_err();
+    /// assert_eq!(foo.as_str(), "foo");
+    /// assert_eq!(err.into_source(), "Ŋ");
+    /// ```
+    pub fn from_ascii<B>(bytes: B) -> Result<AsciiString, FromAsciiError<B>>
+    where
+        B: Into<Vec<u8>> + AsRef<[u8]>,
+    {
+        match bytes.as_ref().as_ascii_str() {
+            // SAFETY: `as_ascii_str` guarantees all bytes are valid ascii bytes.
+            Ok(_) => Ok(unsafe { AsciiString::from_ascii_unchecked(bytes) }),
+            Err(e) => Err(FromAsciiError {
+                error: e,
+                owner: bytes,
+            }),
+        }
+    }
+
+    /// Pushes the given ASCII string onto this ASCII string buffer.
+    ///
+    /// # Examples
+    /// ```
+    /// # use ascii::{AsciiString, AsAsciiStr};
+    /// use std::str::FromStr;
+    /// let mut s = AsciiString::from_str("foo").unwrap();
+    /// s.push_str("bar".as_ascii_str().unwrap());
+    /// assert_eq!(s, "foobar".as_ascii_str().unwrap());
+    /// ```
+    #[inline]
+    pub fn push_str(&mut self, string: &AsciiStr) {
+        self.vec.extend(string.chars());
+    }
+
+    /// Inserts the given ASCII string at the given place in this ASCII string buffer.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `idx` is larger than the `AsciiString`'s length.
+    ///
+    /// # Examples
+    /// ```
+    /// # use ascii::{AsciiString, AsAsciiStr};
+    /// use std::str::FromStr;
+    /// let mut s = AsciiString::from_str("abc").unwrap();
+    /// s.insert_str(1, "def".as_ascii_str().unwrap());
+    /// assert_eq!(&*s, "adefbc");
+    #[inline]
+    pub fn insert_str(&mut self, idx: usize, string: &AsciiStr) {
+        self.vec.reserve(string.len());
+        self.vec.splice(idx..idx, string.into_iter().copied());
+    }
+
+    /// Returns the number of bytes that this ASCII string buffer can hold without reallocating.
+    ///
+    /// # Examples
+    /// ```
+    /// # use ascii::AsciiString;
+    /// let s = String::with_capacity(10);
+    /// assert!(s.capacity() >= 10);
+    /// ```
+    #[inline]
+    #[must_use]
+    pub fn capacity(&self) -> usize {
+        self.vec.capacity()
+    }
+
+    /// Reserves capacity for at least `additional` more bytes to be inserted in the given
+    /// `AsciiString`. The collection may reserve more space to avoid frequent reallocations.
+    ///
+    /// # Panics
+    /// Panics if the new capacity overflows `usize`.
+    ///
+    /// # Examples
+    /// ```
+    /// # use ascii::AsciiString;
+    /// let mut s = AsciiString::new();
+    /// s.reserve(10);
+    /// assert!(s.capacity() >= 10);
+    /// ```
+    #[inline]
+    pub fn reserve(&mut self, additional: usize) {
+        self.vec.reserve(additional);
+    }
+
+    /// Reserves the minimum capacity for exactly `additional` more bytes to be inserted in the
+    /// given `AsciiString`. Does nothing if the capacity is already sufficient.
+    ///
+    /// Note that the allocator may give the collection more space than it requests. Therefore
+    /// capacity can not be relied upon to be precisely minimal. Prefer `reserve` if future
+    /// insertions are expected.
+    ///
+    /// # Panics
+    /// Panics if the new capacity overflows `usize`.
+    ///
+    /// # Examples
+    /// ```
+    /// # use ascii::AsciiString;
+    /// let mut s = AsciiString::new();
+    /// s.reserve_exact(10);
+    /// assert!(s.capacity() >= 10);
+    /// ```
+    #[inline]
+
+    pub fn reserve_exact(&mut self, additional: usize) {
+        self.vec.reserve_exact(additional);
+    }
+
+    /// Shrinks the capacity of this ASCII string buffer to match it's length.
+    ///
+    /// # Examples
+    /// ```
+    /// # use ascii::AsciiString;
+    /// use std::str::FromStr;
+    /// let mut s = AsciiString::from_str("foo").unwrap();
+    /// s.reserve(100);
+    /// assert!(s.capacity() >= 100);
+    /// s.shrink_to_fit();
+    /// assert_eq!(s.capacity(), 3);
+    /// ```
+    #[inline]
+
+    pub fn shrink_to_fit(&mut self) {
+        self.vec.shrink_to_fit();
+    }
+
+    /// Adds the given ASCII character to the end of the ASCII string.
+    ///
+    /// # Examples
+    /// ```
+    /// # use ascii::{ AsciiChar, AsciiString};
+    /// let mut s = AsciiString::from_ascii("abc").unwrap();
+    /// s.push(AsciiChar::from_ascii('1').unwrap());
+    /// s.push(AsciiChar::from_ascii('2').unwrap());
+    /// s.push(AsciiChar::from_ascii('3').unwrap());
+    /// assert_eq!(s, "abc123");
+    /// ```
+    #[inline]
+
+    pub fn push(&mut self, ch: AsciiChar) {
+        self.vec.push(ch);
+    }
+
+    /// Shortens a ASCII string to the specified length.
+    ///
+    /// # Panics
+    /// Panics if `new_len` > current length.
+    ///
+    /// # Examples
+    /// ```
+    /// # use ascii::AsciiString;
+    /// let mut s = AsciiString::from_ascii("hello").unwrap();
+    /// s.truncate(2);
+    /// assert_eq!(s, "he");
+    /// ```
+    #[inline]
+
+    pub fn truncate(&mut self, new_len: usize) {
+        self.vec.truncate(new_len);
+    }
+
+    /// Removes the last character from the ASCII string buffer and returns it.
+    /// Returns `None` if this string buffer is empty.
+    ///
+    /// # Examples
+    /// ```
+    /// # use ascii::AsciiString;
+    /// let mut s = AsciiString::from_ascii("foo").unwrap();
+    /// assert_eq!(s.pop().map(|c| c.as_char()), Some('o'));
+    /// assert_eq!(s.pop().map(|c| c.as_char()), Some('o'));
+    /// assert_eq!(s.pop().map(|c| c.as_char()), Some('f'));
+    /// assert_eq!(s.pop(), None);
+    /// ```
+    #[inline]
+    #[must_use]
+    pub fn pop(&mut self) -> Option<AsciiChar> {
+        self.vec.pop()
+    }
+
+    /// Removes the ASCII character at position `idx` from the buffer and returns it.
+    ///
+    /// # Warning
+    /// This is an O(n) operation as it requires copying every element in the buffer.
+    ///
+    /// # Panics
+    /// If `idx` is out of bounds this function will panic.
+    ///
+    /// # Examples
+    /// ```
+    /// # use ascii::AsciiString;
+    /// let mut s = AsciiString::from_ascii("foo").unwrap();
+    /// assert_eq!(s.remove(0).as_char(), 'f');
+    /// assert_eq!(s.remove(1).as_char(), 'o');
+    /// assert_eq!(s.remove(0).as_char(), 'o');
+    /// ```
+    #[inline]
+    #[must_use]
+    pub fn remove(&mut self, idx: usize) -> AsciiChar {
+        self.vec.remove(idx)
+    }
+
+    /// Inserts an ASCII character into the buffer at position `idx`.
+    ///
+    /// # Warning
+    /// This is an O(n) operation as it requires copying every element in the buffer.
+    ///
+    /// # Panics
+    /// If `idx` is out of bounds this function will panic.
+    ///
+    /// # Examples
+    /// ```
+    /// # use ascii::{AsciiString,AsciiChar};
+    /// let mut s = AsciiString::from_ascii("foo").unwrap();
+    /// s.insert(2, AsciiChar::b);
+    /// assert_eq!(s, "fobo");
+    /// ```
+    #[inline]
+
+    pub fn insert(&mut self, idx: usize, ch: AsciiChar) {
+        self.vec.insert(idx, ch);
+    }
+
+    /// Returns the number of bytes in this ASCII string.
+    ///
+    /// # Examples
+    /// ```
+    /// # use ascii::AsciiString;
+    /// let s = AsciiString::from_ascii("foo").unwrap();
+    /// assert_eq!(s.len(), 3);
+    /// ```
+    #[inline]
+    #[must_use]
+    pub fn len(&self) -> usize {
+        self.vec.len()
+    }
+
+    /// Returns true if the ASCII string contains zero bytes.
+    ///
+    /// # Examples
+    /// ```
+    /// # use ascii::{AsciiChar, AsciiString};
+    /// let mut s = AsciiString::new();
+    /// assert!(s.is_empty());
+    /// s.push(AsciiChar::from_ascii('a').unwrap());
+    /// assert!(!s.is_empty());
+    /// ```
+    #[inline]
+    #[must_use]
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    /// Truncates the ASCII string, setting length (but not capacity) to zero.
+    ///
+    /// # Examples
+    /// ```
+    /// # use ascii::AsciiString;
+    /// let mut s = AsciiString::from_ascii("foo").unwrap();
+    /// s.clear();
+    /// assert!(s.is_empty());
+    /// ```
+    #[inline]
+
+    pub fn clear(&mut self) {
+        self.vec.clear();
+    }
+
+    /// Converts this [`AsciiString`] into a [`Box`]`<`[`AsciiStr`]`>`.
+    ///
+    /// This will drop any excess capacity
+    #[inline]
+    #[must_use]
+    pub fn into_boxed_ascii_str(self) -> Box<AsciiStr> {
+        let slice = self.vec.into_boxed_slice();
+        Box::from(slice)
+    }
+}
+
+impl Deref for AsciiString {
+    type Target = AsciiStr;
+
+    #[inline]
+    fn deref(&self) -> &AsciiStr {
+        self.vec.as_slice().as_ref()
+    }
+}
+
+impl DerefMut for AsciiString {
+    #[inline]
+    fn deref_mut(&mut self) -> &mut AsciiStr {
+        self.vec.as_mut_slice().as_mut()
+    }
+}
+
+impl PartialEq<str> for AsciiString {
+    #[inline]
+    fn eq(&self, other: &str) -> bool {
+        **self == *other
+    }
+}
+
+impl PartialEq<AsciiString> for str {
+    #[inline]
+    fn eq(&self, other: &AsciiString) -> bool {
+        **other == *self
+    }
+}
+
+macro_rules! impl_eq {
+    ($lhs:ty, $rhs:ty) => {
+        impl PartialEq<$rhs> for $lhs {
+            #[inline]
+            fn eq(&self, other: &$rhs) -> bool {
+                PartialEq::eq(&**self, &**other)
+            }
+        }
+    };
+}
+
+impl_eq! { AsciiString, String }
+impl_eq! { String, AsciiString }
+impl_eq! { &AsciiStr, String }
+impl_eq! { String, &AsciiStr }
+impl_eq! { &AsciiStr, AsciiString }
+impl_eq! { AsciiString, &AsciiStr }
+impl_eq! { &str, AsciiString }
+impl_eq! { AsciiString, &str }
+
+impl Borrow<AsciiStr> for AsciiString {
+    #[inline]
+    fn borrow(&self) -> &AsciiStr {
+        &**self
+    }
+}
+
+impl BorrowMut<AsciiStr> for AsciiString {
+    #[inline]
+    fn borrow_mut(&mut self) -> &mut AsciiStr {
+        &mut **self
+    }
+}
+
+impl From<Vec<AsciiChar>> for AsciiString {
+    #[inline]
+    fn from(vec: Vec<AsciiChar>) -> Self {
+        AsciiString { vec }
+    }
+}
+
+impl From<AsciiChar> for AsciiString {
+    #[inline]
+    fn from(ch: AsciiChar) -> Self {
+        AsciiString { vec: vec![ch] }
+    }
+}
+
+impl From<AsciiString> for Vec<u8> {
+    fn from(mut s: AsciiString) -> Vec<u8> {
+        // SAFETY: All ascii bytes are valid `u8`, as we are `repr(u8)`.
+        // Note: We forget `self` to avoid `self.vec` from being deallocated.
+        let ptr = s.vec.as_mut_ptr().cast::<u8>();
+        let length = s.vec.len();
+        let capacity = s.vec.capacity();
+        mem::forget(s);
+
+        // SAFETY: We guarantee all invariants due to getting `ptr`, `length`
+        //         and `capacity` from a `Vec`. We also guarantee `ptr` is valid
+        //         due to the `SAFETY` block above.
+        unsafe { Vec::from_raw_parts(ptr, length, capacity) }
+    }
+}
+
+impl From<AsciiString> for Vec<AsciiChar> {
+    fn from(s: AsciiString) -> Vec<AsciiChar> {
+        s.vec
+    }
+}
+
+impl<'a> From<&'a AsciiStr> for AsciiString {
+    #[inline]
+    fn from(s: &'a AsciiStr) -> Self {
+        s.to_ascii_string()
+    }
+}
+
+impl<'a> From<&'a [AsciiChar]> for AsciiString {
+    #[inline]
+    fn from(s: &'a [AsciiChar]) -> AsciiString {
+        s.iter().copied().collect()
+    }
+}
+
+impl From<AsciiString> for String {
+    #[inline]
+    fn from(s: AsciiString) -> String {
+        // SAFETY: All ascii bytes are `utf8`.
+        unsafe { String::from_utf8_unchecked(s.into()) }
+    }
+}
+
+impl From<Box<AsciiStr>> for AsciiString {
+    #[inline]
+    fn from(boxed: Box<AsciiStr>) -> Self {
+        boxed.into_ascii_string()
+    }
+}
+
+impl From<AsciiString> for Box<AsciiStr> {
+    #[inline]
+    fn from(string: AsciiString) -> Self {
+        string.into_boxed_ascii_str()
+    }
+}
+
+impl From<AsciiString> for Rc<AsciiStr> {
+    fn from(s: AsciiString) -> Rc<AsciiStr> {
+        let var: Rc<[AsciiChar]> = s.vec.into();
+        // SAFETY: AsciiStr is repr(transparent) and thus has the same layout as [AsciiChar]
+        unsafe { Rc::from_raw(Rc::into_raw(var) as *const AsciiStr) }
+    }
+}
+
+impl From<AsciiString> for Arc<AsciiStr> {
+    fn from(s: AsciiString) -> Arc<AsciiStr> {
+        let var: Arc<[AsciiChar]> = s.vec.into();
+        // SAFETY: AsciiStr is repr(transparent) and thus has the same layout as [AsciiChar]
+        unsafe { Arc::from_raw(Arc::into_raw(var) as *const AsciiStr) }
+    }
+}
+
+impl<'a> From<Cow<'a, AsciiStr>> for AsciiString {
+    fn from(cow: Cow<'a, AsciiStr>) -> AsciiString {
+        cow.into_owned()
+    }
+}
+
+impl From<AsciiString> for Cow<'static, AsciiStr> {
+    fn from(string: AsciiString) -> Cow<'static, AsciiStr> {
+        Cow::Owned(string)
+    }
+}
+
+impl<'a> From<&'a AsciiStr> for Cow<'a, AsciiStr> {
+    fn from(s: &'a AsciiStr) -> Cow<'a, AsciiStr> {
+        Cow::Borrowed(s)
+    }
+}
+
+impl AsRef<AsciiStr> for AsciiString {
+    #[inline]
+    fn as_ref(&self) -> &AsciiStr {
+        &**self
+    }
+}
+
+impl AsRef<[AsciiChar]> for AsciiString {
+    #[inline]
+    fn as_ref(&self) -> &[AsciiChar] {
+        &self.vec
+    }
+}
+
+impl AsRef<[u8]> for AsciiString {
+    #[inline]
+    fn as_ref(&self) -> &[u8] {
+        self.as_bytes()
+    }
+}
+
+impl AsRef<str> for AsciiString {
+    #[inline]
+    fn as_ref(&self) -> &str {
+        self.as_str()
+    }
+}
+
+impl AsMut<AsciiStr> for AsciiString {
+    #[inline]
+    fn as_mut(&mut self) -> &mut AsciiStr {
+        &mut *self
+    }
+}
+
+impl AsMut<[AsciiChar]> for AsciiString {
+    #[inline]
+    fn as_mut(&mut self) -> &mut [AsciiChar] {
+        &mut self.vec
+    }
+}
+
+impl FromStr for AsciiString {
+    type Err = AsAsciiStrError;
+
+    fn from_str(s: &str) -> Result<AsciiString, AsAsciiStrError> {
+        s.as_ascii_str().map(AsciiStr::to_ascii_string)
+    }
+}
+
+impl fmt::Display for AsciiString {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Display::fmt(&**self, f)
+    }
+}
+
+impl fmt::Debug for AsciiString {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Debug::fmt(&**self, f)
+    }
+}
+
+/// Please note that the `std::fmt::Result` returned by these methods does not support
+/// transmission of an error other than that an error occurred.
+impl fmt::Write for AsciiString {
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        if let Ok(astr) = AsciiStr::from_ascii(s) {
+            self.push_str(astr);
+            Ok(())
+        } else {
+            Err(fmt::Error)
+        }
+    }
+
+    fn write_char(&mut self, c: char) -> fmt::Result {
+        if let Ok(achar) = AsciiChar::from_ascii(c) {
+            self.push(achar);
+            Ok(())
+        } else {
+            Err(fmt::Error)
+        }
+    }
+}
+
+impl<A: AsRef<AsciiStr>> FromIterator<A> for AsciiString {
+    fn from_iter<I: IntoIterator<Item = A>>(iter: I) -> AsciiString {
+        let mut buf = AsciiString::new();
+        buf.extend(iter);
+        buf
+    }
+}
+
+impl<A: AsRef<AsciiStr>> Extend<A> for AsciiString {
+    fn extend<I: IntoIterator<Item = A>>(&mut self, iterable: I) {
+        let iterator = iterable.into_iter();
+        let (lower_bound, _) = iterator.size_hint();
+        self.reserve(lower_bound);
+        for item in iterator {
+            self.push_str(item.as_ref());
+        }
+    }
+}
+
+impl<'a> Add<&'a AsciiStr> for AsciiString {
+    type Output = AsciiString;
+
+    #[inline]
+    fn add(mut self, other: &AsciiStr) -> AsciiString {
+        self.push_str(other);
+        self
+    }
+}
+
+impl<'a> AddAssign<&'a AsciiStr> for AsciiString {
+    #[inline]
+    fn add_assign(&mut self, other: &AsciiStr) {
+        self.push_str(other);
+    }
+}
+
+#[allow(clippy::indexing_slicing)] // In `Index`, if it's out of bounds, panic is the default
+impl<T> Index<T> for AsciiString
+where
+    AsciiStr: Index<T>,
+{
+    type Output = <AsciiStr as Index<T>>::Output;
+
+    #[inline]
+    fn index(&self, index: T) -> &<AsciiStr as Index<T>>::Output {
+        &(**self)[index]
+    }
+}
+
+#[allow(clippy::indexing_slicing)] // In `IndexMut`, if it's out of bounds, panic is the default
+impl<T> IndexMut<T> for AsciiString
+where
+    AsciiStr: IndexMut<T>,
+{
+    #[inline]
+    fn index_mut(&mut self, index: T) -> &mut <AsciiStr as Index<T>>::Output {
+        &mut (**self)[index]
+    }
+}
+
+/// A possible error value when converting an `AsciiString` from a byte vector or string.
+/// It wraps an `AsAsciiStrError` which you can get through the `ascii_error()` method.
+///
+/// This is the error type for `AsciiString::from_ascii()` and
+/// `IntoAsciiString::into_ascii_string()`. They will never clone or touch the content of the
+/// original type; It can be extracted by the `into_source` method.
+///
+/// #Examples
+/// ```
+/// # use ascii::IntoAsciiString;
+/// let err = "bø!".to_string().into_ascii_string().unwrap_err();
+/// assert_eq!(err.ascii_error().valid_up_to(), 1);
+/// assert_eq!(err.into_source(), "bø!".to_string());
+/// ```
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub struct FromAsciiError<O> {
+    error: AsAsciiStrError,
+    owner: O,
+}
+impl<O> FromAsciiError<O> {
+    /// Get the position of the first non-ASCII byte or character.
+    #[inline]
+    #[must_use]
+    pub fn ascii_error(&self) -> AsAsciiStrError {
+        self.error
+    }
+    /// Get back the original, unmodified type.
+    #[inline]
+    #[must_use]
+    pub fn into_source(self) -> O {
+        self.owner
+    }
+}
+impl<O> fmt::Debug for FromAsciiError<O> {
+    #[inline]
+    fn fmt(&self, fmtr: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Debug::fmt(&self.error, fmtr)
+    }
+}
+impl<O> fmt::Display for FromAsciiError<O> {
+    #[inline]
+    fn fmt(&self, fmtr: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Display::fmt(&self.error, fmtr)
+    }
+}
+#[cfg(feature = "std")]
+impl<O: Any> Error for FromAsciiError<O> {
+    #[inline]
+    #[allow(deprecated)] // TODO: Remove deprecation once the earliest version we support deprecates this method.
+    fn description(&self) -> &str {
+        self.error.description()
+    }
+    /// Always returns an `AsAsciiStrError`
+    fn cause(&self) -> Option<&dyn Error> {
+        Some(&self.error as &dyn Error)
+    }
+}
+
+/// Convert vectors into `AsciiString`.
+pub trait IntoAsciiString: Sized {
+    /// Convert to `AsciiString` without checking for non-ASCII characters.
+    ///
+    /// # Safety
+    /// If `self` contains non-ascii characters, calling this function is
+    /// undefined behavior.
+    unsafe fn into_ascii_string_unchecked(self) -> AsciiString;
+
+    /// Convert to `AsciiString`.
+    ///
+    /// # Errors
+    /// If `self` contains non-ascii characters, this will return `Err`
+    fn into_ascii_string(self) -> Result<AsciiString, FromAsciiError<Self>>;
+}
+
+impl IntoAsciiString for Vec<AsciiChar> {
+    #[inline]
+    unsafe fn into_ascii_string_unchecked(self) -> AsciiString {
+        AsciiString::from(self)
+    }
+    #[inline]
+    fn into_ascii_string(self) -> Result<AsciiString, FromAsciiError<Self>> {
+        Ok(AsciiString::from(self))
+    }
+}
+
+impl<'a> IntoAsciiString for &'a [AsciiChar] {
+    #[inline]
+    unsafe fn into_ascii_string_unchecked(self) -> AsciiString {
+        AsciiString::from(self)
+    }
+    #[inline]
+    fn into_ascii_string(self) -> Result<AsciiString, FromAsciiError<Self>> {
+        Ok(AsciiString::from(self))
+    }
+}
+
+impl<'a> IntoAsciiString for &'a AsciiStr {
+    #[inline]
+    unsafe fn into_ascii_string_unchecked(self) -> AsciiString {
+        AsciiString::from(self)
+    }
+    #[inline]
+    fn into_ascii_string(self) -> Result<AsciiString, FromAsciiError<Self>> {
+        Ok(AsciiString::from(self))
+    }
+}
+
+macro_rules! impl_into_ascii_string {
+    ('a, $wider:ty) => {
+        impl<'a> IntoAsciiString for $wider {
+            #[inline]
+            unsafe fn into_ascii_string_unchecked(self) -> AsciiString {
+                // SAFETY: Caller guarantees `self` only has valid ascii bytes
+                unsafe { AsciiString::from_ascii_unchecked(self) }
+            }
+
+            #[inline]
+            fn into_ascii_string(self) -> Result<AsciiString, FromAsciiError<Self>> {
+                AsciiString::from_ascii(self)
+            }
+        }
+    };
+
+    ($wider:ty) => {
+        impl IntoAsciiString for $wider {
+            #[inline]
+            unsafe fn into_ascii_string_unchecked(self) -> AsciiString {
+                // SAFETY: Caller guarantees `self` only has valid ascii bytes
+                unsafe { AsciiString::from_ascii_unchecked(self) }
+            }
+
+            #[inline]
+            fn into_ascii_string(self) -> Result<AsciiString, FromAsciiError<Self>> {
+                AsciiString::from_ascii(self)
+            }
+        }
+    };
+}
+
+impl_into_ascii_string! {AsciiString}
+impl_into_ascii_string! {Vec<u8>}
+impl_into_ascii_string! {'a, &'a [u8]}
+impl_into_ascii_string! {String}
+impl_into_ascii_string! {'a, &'a str}
+
+/// # Notes
+/// The trailing null byte `CString` has will be removed during this conversion.
+#[cfg(feature = "std")]
+impl IntoAsciiString for CString {
+    #[inline]
+    unsafe fn into_ascii_string_unchecked(self) -> AsciiString {
+        // SAFETY: Caller guarantees `self` only has valid ascii bytes
+        unsafe { AsciiString::from_ascii_unchecked(self.into_bytes()) }
+    }
+
+    fn into_ascii_string(self) -> Result<AsciiString, FromAsciiError<Self>> {
+        AsciiString::from_ascii(self.into_bytes_with_nul())
+            .map_err(|FromAsciiError { error, owner }| {
+                FromAsciiError {
+                    // SAFETY: We don't discard the NULL byte from the original
+                    //         string, so we ensure that it's null terminated
+                    owner: unsafe { CString::from_vec_unchecked(owner) },
+                    error,
+                }
+            })
+            .map(|mut s| {
+                let nul = s.pop();
+                debug_assert_eq!(nul, Some(AsciiChar::Null));
+                s
+            })
+    }
+}
+
+/// Note that the trailing null byte will be removed in the conversion.
+#[cfg(feature = "std")]
+impl<'a> IntoAsciiString for &'a CStr {
+    #[inline]
+    unsafe fn into_ascii_string_unchecked(self) -> AsciiString {
+        // SAFETY: Caller guarantees `self` only has valid ascii bytes
+        unsafe { AsciiString::from_ascii_unchecked(self.to_bytes()) }
+    }
+
+    fn into_ascii_string(self) -> Result<AsciiString, FromAsciiError<Self>> {
+        AsciiString::from_ascii(self.to_bytes_with_nul())
+            .map_err(|FromAsciiError { error, owner }| FromAsciiError {
+                // SAFETY: We don't discard the NULL byte from the original
+                //         string, so we ensure that it's null terminated
+                owner: unsafe { CStr::from_ptr(owner.as_ptr().cast()) },
+                error,
+            })
+            .map(|mut s| {
+                let nul = s.pop();
+                debug_assert_eq!(nul, Some(AsciiChar::Null));
+                s
+            })
+    }
+}
+
+impl<'a, B> IntoAsciiString for Cow<'a, B>
+where
+    B: 'a + ToOwned + ?Sized,
+    &'a B: IntoAsciiString,
+    <B as ToOwned>::Owned: IntoAsciiString,
+{
+    #[inline]
+    unsafe fn into_ascii_string_unchecked(self) -> AsciiString {
+        // SAFETY: Caller guarantees `self` only has valid ascii bytes
+        unsafe { IntoAsciiString::into_ascii_string_unchecked(self.into_owned()) }
+    }
+
+    fn into_ascii_string(self) -> Result<AsciiString, FromAsciiError<Self>> {
+        match self {
+            Cow::Owned(b) => {
+                IntoAsciiString::into_ascii_string(b).map_err(|FromAsciiError { error, owner }| {
+                    FromAsciiError {
+                        owner: Cow::Owned(owner),
+                        error,
+                    }
+                })
+            }
+            Cow::Borrowed(b) => {
+                IntoAsciiString::into_ascii_string(b).map_err(|FromAsciiError { error, owner }| {
+                    FromAsciiError {
+                        owner: Cow::Borrowed(owner),
+                        error,
+                    }
+                })
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{AsciiString, IntoAsciiString};
+    use alloc::str::FromStr;
+    use alloc::string::{String, ToString};
+    use alloc::vec::Vec;
+    use alloc::boxed::Box;
+    #[cfg(feature = "std")]
+    use std::ffi::CString;
+    use {AsciiChar, AsciiStr};
+
+    #[test]
+    fn into_string() {
+        let v = AsciiString::from_ascii(&[40_u8, 32, 59][..]).unwrap();
+        assert_eq!(Into::<String>::into(v), "( ;".to_string());
+    }
+
+    #[test]
+    fn into_bytes() {
+        let v = AsciiString::from_ascii(&[40_u8, 32, 59][..]).unwrap();
+        assert_eq!(Into::<Vec<u8>>::into(v), vec![40_u8, 32, 59]);
+    }
+
+    #[test]
+    fn from_ascii_vec() {
+        let vec = vec![
+            AsciiChar::from_ascii('A').unwrap(),
+            AsciiChar::from_ascii('B').unwrap(),
+        ];
+        assert_eq!(AsciiString::from(vec), AsciiString::from_str("AB").unwrap());
+    }
+
+    #[test]
+    #[cfg(feature = "std")]
+    fn from_cstring() {
+        let cstring = CString::new("baz").unwrap();
+        let ascii_str = cstring.clone().into_ascii_string().unwrap();
+        let expected_chars = &[AsciiChar::b, AsciiChar::a, AsciiChar::z];
+        assert_eq!(ascii_str.len(), 3);
+        assert_eq!(ascii_str.as_slice(), expected_chars);
+
+        // SAFETY: "baz" only contains valid ascii characters.
+        let ascii_str_unchecked = unsafe { cstring.into_ascii_string_unchecked() };
+        assert_eq!(ascii_str_unchecked.len(), 3);
+        assert_eq!(ascii_str_unchecked.as_slice(), expected_chars);
+
+        let sparkle_heart_bytes = vec![240_u8, 159, 146, 150];
+        let cstring = CString::new(sparkle_heart_bytes).unwrap();
+        let cstr = &*cstring;
+        let ascii_err = cstr.into_ascii_string().unwrap_err();
+        assert_eq!(ascii_err.into_source(), &*cstring);
+    }
+
+    #[test]
+    #[cfg(feature = "std")]
+    fn fmt_ascii_string() {
+        let s = "abc".to_string().into_ascii_string().unwrap();
+        assert_eq!(format!("{}", s), "abc".to_string());
+        assert_eq!(format!("{:?}", s), "\"abc\"".to_string());
+    }
+
+    #[test]
+    fn write_fmt() {
+        use alloc::{fmt, str};
+
+        let mut s0 = AsciiString::new();
+        fmt::write(&mut s0, format_args!("Hello World")).unwrap();
+        assert_eq!(s0, "Hello World");
+
+        let mut s1 = AsciiString::new();
+        fmt::write(&mut s1, format_args!("{}", 9)).unwrap();
+        assert_eq!(s1, "9");
+
+        let mut s2 = AsciiString::new();
+        let sparkle_heart_bytes = [240, 159, 146, 150];
+        let sparkle_heart = str::from_utf8(&sparkle_heart_bytes).unwrap();
+        assert!(fmt::write(&mut s2, format_args!("{}", sparkle_heart)).is_err());
+    }
+
+    #[test]
+    fn to_and_from_box() {
+        let string = "abc".into_ascii_string().unwrap();
+        let converted: Box<AsciiStr> = Box::from(string.clone());
+        let converted: AsciiString = converted.into();
+        assert_eq!(string, converted);
+    }
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/ascii-1.1.0/src/free_functions.rs

@@ -0,0 +1,59 @@
+use ascii_char::{AsciiChar, ToAsciiChar};
+
+/// Terminals use [caret notation](https://en.wikipedia.org/wiki/Caret_notation)
+/// to display some typed control codes, such as ^D for EOT and ^Z for SUB.
+///
+/// This function returns the caret notation letter for control codes,
+/// or `None` for printable characters.
+///
+/// # Examples
+/// ```
+/// # use ascii::{AsciiChar, caret_encode};
+/// assert_eq!(caret_encode(b'\0'), Some(AsciiChar::At));
+/// assert_eq!(caret_encode(AsciiChar::DEL), Some(AsciiChar::Question));
+/// assert_eq!(caret_encode(b'E'), None);
+/// assert_eq!(caret_encode(b'\n'), Some(AsciiChar::J));
+/// ```
+pub fn caret_encode<C: Copy + Into<u8>>(c: C) -> Option<AsciiChar> {
+    // The formula is explained in the Wikipedia article.
+    let c = c.into() ^ 0b0100_0000;
+    if (b'?'..=b'_').contains(&c) {
+        // SAFETY: All bytes between '?' (0x3F) and '_' (0x5f) are valid ascii characters.
+        Some(unsafe { c.to_ascii_char_unchecked() })
+    } else {
+        None
+    }
+}
+
+/// Returns the control code represented by a [caret notation](https://en.wikipedia.org/wiki/Caret_notation)
+/// letter, or `None` if the letter is not used in caret notation.
+///
+/// This function is the inverse of `caret_encode()`.
+///
+/// # Examples
+///
+/// Basic usage:
+///
+/// ```
+/// # use ascii::{AsciiChar, caret_decode};
+/// assert_eq!(caret_decode(b'?'), Some(AsciiChar::DEL));
+/// assert_eq!(caret_decode(AsciiChar::D), Some(AsciiChar::EOT));
+/// assert_eq!(caret_decode(b'\0'), None);
+/// ```
+///
+/// Symmetry:
+///
+/// ```
+/// # use ascii::{AsciiChar, caret_encode, caret_decode};
+/// assert_eq!(caret_encode(AsciiChar::US).and_then(caret_decode), Some(AsciiChar::US));
+/// assert_eq!(caret_decode(b'@').and_then(caret_encode), Some(AsciiChar::At));
+/// ```
+pub fn caret_decode<C: Copy + Into<u8>>(c: C) -> Option<AsciiChar> {
+    // The formula is explained in the Wikipedia article.
+    match c.into() {
+        // SAFETY: All bytes between '?' (0x3F) and '_' (0x5f) after `xoring` with `0b0100_0000` are
+        //         valid bytes, as they represent characters between '␀' (0x0) and '␠' (0x1f) + '␡' (0x7f)
+        b'?'..=b'_' => Some(unsafe { AsciiChar::from_ascii_unchecked(c.into() ^ 0b0100_0000) }),
+        _ => None,
+    }
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/ascii-1.1.0/src/lib.rs

@@ -0,0 +1,82 @@
+// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! A library that provides ASCII-only string and character types, equivalent to the `char`, `str`
+//! and `String` types in the standard library.
+//!
+//! Please refer to the readme file to learn about the different feature modes of this crate.
+//!
+//! # Minimum supported Rust version
+//!
+//! The minimum Rust version for 1.1.\* releases is 1.41.1.
+//! Later 1.y.0 releases might require newer Rust versions, but the three most
+//! recent stable releases at the time of publishing will always be supported.  
+//! For example this means that if the current stable Rust version is 1.70 when
+//! ascii 1.2.0 is released, then ascii 1.2.\* will not require a newer
+//! Rust version than 1.68.
+//!
+//! # History
+//!
+//! This package included the Ascii types that were removed from the Rust standard library by the
+//! 2014-12 [reform of the `std::ascii` module](https://github.com/rust-lang/rfcs/pull/486). The
+//! API changed significantly since then.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+// Clippy lints
+#![warn(
+    clippy::pedantic,
+    clippy::decimal_literal_representation,
+    clippy::get_unwrap,
+    clippy::indexing_slicing
+)]
+// Naming conventions sometimes go against this lint
+#![allow(clippy::module_name_repetitions)]
+// We need to get literal non-asciis for tests
+#![allow(clippy::non_ascii_literal)]
+// Sometimes it looks better to invert the order, such as when the `else` block is small
+#![allow(clippy::if_not_else)]
+// Shadowing is common and doesn't affect understanding
+// TODO: Consider removing `shadow_unrelated`, as it can show some actual logic errors
+#![allow(clippy::shadow_unrelated, clippy::shadow_reuse, clippy::shadow_same)]
+// A `if let` / `else` sometimes looks better than using iterator adaptors
+#![allow(clippy::option_if_let_else)]
+// In tests, we're fine with indexing, since a panic is a failure.
+#![cfg_attr(test, allow(clippy::indexing_slicing))]
+// for compatibility with methods on char and u8
+#![allow(clippy::trivially_copy_pass_by_ref)]
+// In preparation for feature `unsafe_block_in_unsafe_fn` (https://github.com/rust-lang/rust/issues/71668)
+#![allow(unused_unsafe)]
+
+#[cfg(feature = "alloc")]
+#[macro_use]
+extern crate alloc;
+#[cfg(feature = "std")]
+extern crate core;
+
+#[cfg(feature = "serde")]
+extern crate serde;
+
+#[cfg(all(test, feature = "serde_test"))]
+extern crate serde_test;
+
+mod ascii_char;
+mod ascii_str;
+#[cfg(feature = "alloc")]
+mod ascii_string;
+mod free_functions;
+#[cfg(feature = "serde")]
+mod serialization;
+
+pub use ascii_char::{AsciiChar, ToAsciiChar, ToAsciiCharError};
+pub use ascii_str::{AsAsciiStr, AsAsciiStrError, AsMutAsciiStr, AsciiStr};
+pub use ascii_str::{Chars, CharsMut, CharsRef};
+#[cfg(feature = "alloc")]
+pub use ascii_string::{AsciiString, FromAsciiError, IntoAsciiString};
+pub use free_functions::{caret_decode, caret_encode};

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/ascii-1.1.0/src/serialization/ascii_char.rs

@@ -0,0 +1,89 @@
+use std::fmt;
+
+use serde::de::{Error, Unexpected, Visitor};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
+use ascii_char::AsciiChar;
+
+impl Serialize for AsciiChar {
+    #[inline]
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        serializer.serialize_char(self.as_char())
+    }
+}
+
+struct AsciiCharVisitor;
+
+impl<'de> Visitor<'de> for AsciiCharVisitor {
+    type Value = AsciiChar;
+
+    fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str("an ascii character")
+    }
+
+    #[inline]
+    fn visit_char<E: Error>(self, v: char) -> Result<Self::Value, E> {
+        AsciiChar::from_ascii(v).map_err(|_| Error::invalid_value(Unexpected::Char(v), &self))
+    }
+
+    #[inline]
+    fn visit_str<E: Error>(self, v: &str) -> Result<Self::Value, E> {
+        if v.len() == 1 {
+            let c = v.chars().next().unwrap();
+            self.visit_char(c)
+        } else {
+            Err(Error::invalid_value(Unexpected::Str(v), &self))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for AsciiChar {
+    fn deserialize<D>(deserializer: D) -> Result<AsciiChar, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_char(AsciiCharVisitor)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[cfg(feature = "serde_test")]
+    const ASCII_CHAR: char = 'e';
+    #[cfg(feature = "serde_test")]
+    const ASCII_STR: &str = "e";
+    #[cfg(feature = "serde_test")]
+    const UNICODE_CHAR: char = 'é';
+
+    #[test]
+    fn basic() {
+        fn assert_serialize<T: Serialize>() {}
+        fn assert_deserialize<'de, T: Deserialize<'de>>() {}
+        assert_serialize::<AsciiChar>();
+        assert_deserialize::<AsciiChar>();
+    }
+
+    #[test]
+    #[cfg(feature = "serde_test")]
+    fn serialize() {
+        use serde_test::{assert_tokens, Token};
+        let ascii_char = AsciiChar::from_ascii(ASCII_CHAR).unwrap();
+        assert_tokens(&ascii_char, &[Token::Char(ASCII_CHAR)]);
+    }
+
+    #[test]
+    #[cfg(feature = "serde_test")]
+    fn deserialize() {
+        use serde_test::{assert_de_tokens, assert_de_tokens_error, Token};
+        let ascii_char = AsciiChar::from_ascii(ASCII_CHAR).unwrap();
+        assert_de_tokens(&ascii_char, &[Token::String(ASCII_STR)]);
+        assert_de_tokens(&ascii_char, &[Token::Str(ASCII_STR)]);
+        assert_de_tokens(&ascii_char, &[Token::BorrowedStr(ASCII_STR)]);
+        assert_de_tokens_error::<AsciiChar>(
+            &[Token::Char(UNICODE_CHAR)],
+            "invalid value: character `é`, expected an ascii character",
+        );
+    }
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/ascii-1.1.0/src/serialization/ascii_str.rs

@@ -0,0 +1,79 @@
+use std::fmt;
+
+use serde::de::{Error, Unexpected, Visitor};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
+use ascii_str::AsciiStr;
+
+impl Serialize for AsciiStr {
+    #[inline]
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        serializer.serialize_str(self.as_str())
+    }
+}
+
+struct AsciiStrVisitor;
+
+impl<'a> Visitor<'a> for AsciiStrVisitor {
+    type Value = &'a AsciiStr;
+
+    fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str("a borrowed ascii string")
+    }
+
+    fn visit_borrowed_str<E: Error>(self, v: &'a str) -> Result<Self::Value, E> {
+        AsciiStr::from_ascii(v.as_bytes())
+            .map_err(|_| Error::invalid_value(Unexpected::Str(v), &self))
+    }
+
+    fn visit_borrowed_bytes<E: Error>(self, v: &'a [u8]) -> Result<Self::Value, E> {
+        AsciiStr::from_ascii(v).map_err(|_| Error::invalid_value(Unexpected::Bytes(v), &self))
+    }
+}
+
+impl<'de: 'a, 'a> Deserialize<'de> for &'a AsciiStr {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(AsciiStrVisitor)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[cfg(feature = "serde_test")]
+    const ASCII: &str = "Francais";
+    #[cfg(feature = "serde_test")]
+    const UNICODE: &str = "Français";
+
+    #[test]
+    fn basic() {
+        fn assert_serialize<T: Serialize>() {}
+        fn assert_deserialize<'de, T: Deserialize<'de>>() {}
+        assert_serialize::<&AsciiStr>();
+        assert_deserialize::<&AsciiStr>();
+    }
+
+    #[test]
+    #[cfg(feature = "serde_test")]
+    fn serialize() {
+        use serde_test::{assert_tokens, Token};
+        let ascii_str = AsciiStr::from_ascii(ASCII).unwrap();
+        assert_tokens(&ascii_str, &[Token::BorrowedStr(ASCII)]);
+    }
+
+    #[test]
+    #[cfg(feature = "serde_test")]
+    fn deserialize() {
+        use serde_test::{assert_de_tokens, assert_de_tokens_error, Token};
+        let ascii_str = AsciiStr::from_ascii(ASCII).unwrap();
+        assert_de_tokens(&ascii_str, &[Token::BorrowedBytes(ASCII.as_bytes())]);
+        assert_de_tokens_error::<&AsciiStr>(
+            &[Token::BorrowedStr(UNICODE)],
+            "invalid value: string \"Français\", expected a borrowed ascii string",
+        );
+    }
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/ascii-1.1.0/src/serialization/ascii_string.rs

@@ -0,0 +1,149 @@
+use std::fmt;
+
+use serde::de::{Error, Unexpected, Visitor};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
+use ascii_str::AsciiStr;
+use ascii_string::AsciiString;
+
+impl Serialize for AsciiString {
+    #[inline]
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        serializer.serialize_str(self.as_str())
+    }
+}
+
+struct AsciiStringVisitor;
+
+impl<'de> Visitor<'de> for AsciiStringVisitor {
+    type Value = AsciiString;
+
+    fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str("an ascii string")
+    }
+
+    fn visit_str<E: Error>(self, v: &str) -> Result<Self::Value, E> {
+        AsciiString::from_ascii(v).map_err(|_| Error::invalid_value(Unexpected::Str(v), &self))
+    }
+
+    fn visit_string<E: Error>(self, v: String) -> Result<Self::Value, E> {
+        AsciiString::from_ascii(v.as_bytes())
+            .map_err(|_| Error::invalid_value(Unexpected::Str(&v), &self))
+    }
+
+    fn visit_bytes<E: Error>(self, v: &[u8]) -> Result<Self::Value, E> {
+        AsciiString::from_ascii(v).map_err(|_| Error::invalid_value(Unexpected::Bytes(v), &self))
+    }
+
+    fn visit_byte_buf<E: Error>(self, v: Vec<u8>) -> Result<Self::Value, E> {
+        AsciiString::from_ascii(v.as_slice())
+            .map_err(|_| Error::invalid_value(Unexpected::Bytes(&v), &self))
+    }
+}
+
+struct AsciiStringInPlaceVisitor<'a>(&'a mut AsciiString);
+
+impl<'a, 'de> Visitor<'de> for AsciiStringInPlaceVisitor<'a> {
+    type Value = ();
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter.write_str("an ascii string")
+    }
+
+    fn visit_str<E: Error>(self, v: &str) -> Result<Self::Value, E> {
+        let ascii_str = match AsciiStr::from_ascii(v.as_bytes()) {
+            Ok(ascii_str) => ascii_str,
+            Err(_) => return Err(Error::invalid_value(Unexpected::Str(v), &self)),
+        };
+        self.0.clear();
+        self.0.push_str(ascii_str);
+        Ok(())
+    }
+
+    fn visit_string<E: Error>(self, v: String) -> Result<Self::Value, E> {
+        let ascii_string = match AsciiString::from_ascii(v.as_bytes()) {
+            Ok(ascii_string) => ascii_string,
+            Err(_) => return Err(Error::invalid_value(Unexpected::Str(&v), &self)),
+        };
+        *self.0 = ascii_string;
+        Ok(())
+    }
+
+    fn visit_bytes<E: Error>(self, v: &[u8]) -> Result<Self::Value, E> {
+        let ascii_str = match AsciiStr::from_ascii(v) {
+            Ok(ascii_str) => ascii_str,
+            Err(_) => return Err(Error::invalid_value(Unexpected::Bytes(v), &self)),
+        };
+        self.0.clear();
+        self.0.push_str(ascii_str);
+        Ok(())
+    }
+
+    fn visit_byte_buf<E: Error>(self, v: Vec<u8>) -> Result<Self::Value, E> {
+        let ascii_string = match AsciiString::from_ascii(v.as_slice()) {
+            Ok(ascii_string) => ascii_string,
+            Err(_) => return Err(Error::invalid_value(Unexpected::Bytes(&v), &self)),
+        };
+        *self.0 = ascii_string;
+        Ok(())
+    }
+}
+
+impl<'de> Deserialize<'de> for AsciiString {
+    fn deserialize<D>(deserializer: D) -> Result<AsciiString, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_string(AsciiStringVisitor)
+    }
+
+    fn deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<(), D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_string(AsciiStringInPlaceVisitor(place))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[cfg(feature = "serde_test")]
+    const ASCII: &str = "Francais";
+    #[cfg(feature = "serde_test")]
+    const UNICODE: &str = "Français";
+
+    #[test]
+    fn basic() {
+        fn assert_serialize<T: Serialize>() {}
+        fn assert_deserialize<'de, T: Deserialize<'de>>() {}
+        assert_serialize::<AsciiString>();
+        assert_deserialize::<AsciiString>();
+    }
+
+    #[test]
+    #[cfg(feature = "serde_test")]
+    fn serialize() {
+        use serde_test::{assert_tokens, Token};
+
+        let ascii_string = AsciiString::from_ascii(ASCII).unwrap();
+        assert_tokens(&ascii_string, &[Token::String(ASCII)]);
+        assert_tokens(&ascii_string, &[Token::Str(ASCII)]);
+        assert_tokens(&ascii_string, &[Token::BorrowedStr(ASCII)]);
+    }
+
+    #[test]
+    #[cfg(feature = "serde_test")]
+    fn deserialize() {
+        use serde_test::{assert_de_tokens, assert_de_tokens_error, Token};
+        let ascii_string = AsciiString::from_ascii(ASCII).unwrap();
+        assert_de_tokens(&ascii_string, &[Token::Bytes(ASCII.as_bytes())]);
+        assert_de_tokens(&ascii_string, &[Token::BorrowedBytes(ASCII.as_bytes())]);
+        assert_de_tokens(&ascii_string, &[Token::ByteBuf(ASCII.as_bytes())]);
+        assert_de_tokens_error::<AsciiString>(
+            &[Token::String(UNICODE)],
+            "invalid value: string \"Français\", expected an ascii string",
+        );
+    }
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/ascii-1.1.0/src/serialization/mod.rs

@@ -0,0 +1,3 @@
+mod ascii_char;
+mod ascii_str;
+mod ascii_string;

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-epoch-0.9.18/benches/defer.rs

@@ -0,0 +1,69 @@
+#![feature(test)]
+
+extern crate test;
+
+use crossbeam_epoch::{self as epoch, Owned};
+use crossbeam_utils::thread::scope;
+use test::Bencher;
+
+#[bench]
+fn single_alloc_defer_free(b: &mut Bencher) {
+    b.iter(|| {
+        let guard = &epoch::pin();
+        let p = Owned::new(1).into_shared(guard);
+        unsafe {
+            guard.defer_destroy(p);
+        }
+    });
+}
+
+#[bench]
+fn single_defer(b: &mut Bencher) {
+    b.iter(|| {
+        let guard = &epoch::pin();
+        guard.defer(move || ());
+    });
+}
+
+#[bench]
+fn multi_alloc_defer_free(b: &mut Bencher) {
+    const THREADS: usize = 16;
+    const STEPS: usize = 10_000;
+
+    b.iter(|| {
+        scope(|s| {
+            for _ in 0..THREADS {
+                s.spawn(|_| {
+                    for _ in 0..STEPS {
+                        let guard = &epoch::pin();
+                        let p = Owned::new(1).into_shared(guard);
+                        unsafe {
+                            guard.defer_destroy(p);
+                        }
+                    }
+                });
+            }
+        })
+        .unwrap();
+    });
+}
+
+#[bench]
+fn multi_defer(b: &mut Bencher) {
+    const THREADS: usize = 16;
+    const STEPS: usize = 10_000;
+
+    b.iter(|| {
+        scope(|s| {
+            for _ in 0..THREADS {
+                s.spawn(|_| {
+                    for _ in 0..STEPS {
+                        let guard = &epoch::pin();
+                        guard.defer(move || ());
+                    }
+                });
+            }
+        })
+        .unwrap();
+    });
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-epoch-0.9.18/benches/flush.rs

@@ -0,0 +1,52 @@
+#![feature(test)]
+
+extern crate test;
+
+use std::sync::Barrier;
+
+use crossbeam_epoch as epoch;
+use crossbeam_utils::thread::scope;
+use test::Bencher;
+
+#[bench]
+fn single_flush(b: &mut Bencher) {
+    const THREADS: usize = 16;
+
+    let start = Barrier::new(THREADS + 1);
+    let end = Barrier::new(THREADS + 1);
+
+    scope(|s| {
+        for _ in 0..THREADS {
+            s.spawn(|_| {
+                epoch::pin();
+                start.wait();
+                end.wait();
+            });
+        }
+
+        start.wait();
+        b.iter(|| epoch::pin().flush());
+        end.wait();
+    })
+    .unwrap();
+}
+
+#[bench]
+fn multi_flush(b: &mut Bencher) {
+    const THREADS: usize = 16;
+    const STEPS: usize = 10_000;
+
+    b.iter(|| {
+        scope(|s| {
+            for _ in 0..THREADS {
+                s.spawn(|_| {
+                    for _ in 0..STEPS {
+                        let guard = &epoch::pin();
+                        guard.flush();
+                    }
+                });
+            }
+        })
+        .unwrap();
+    });
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-epoch-0.9.18/benches/pin.rs

@@ -0,0 +1,31 @@
+#![feature(test)]
+
+extern crate test;
+
+use crossbeam_epoch as epoch;
+use crossbeam_utils::thread::scope;
+use test::Bencher;
+
+#[bench]
+fn single_pin(b: &mut Bencher) {
+    b.iter(epoch::pin);
+}
+
+#[bench]
+fn multi_pin(b: &mut Bencher) {
+    const THREADS: usize = 16;
+    const STEPS: usize = 100_000;
+
+    b.iter(|| {
+        scope(|s| {
+            for _ in 0..THREADS {
+                s.spawn(|_| {
+                    for _ in 0..STEPS {
+                        epoch::pin();
+                    }
+                });
+            }
+        })
+        .unwrap();
+    });
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-epoch-0.9.18/examples/sanitize.rs

@@ -0,0 +1,66 @@
+use std::sync::atomic::AtomicUsize;
+use std::sync::atomic::Ordering::{AcqRel, Acquire, Relaxed};
+use std::sync::Arc;
+use std::thread;
+use std::time::{Duration, Instant};
+
+use crossbeam_epoch::{self as epoch, Atomic, Collector, LocalHandle, Owned, Shared};
+use rand::Rng;
+
+fn worker(a: Arc<Atomic<AtomicUsize>>, handle: LocalHandle) -> usize {
+    let mut rng = rand::thread_rng();
+    let mut sum = 0;
+
+    if rng.gen() {
+        thread::sleep(Duration::from_millis(1));
+    }
+    let timeout = Duration::from_millis(rng.gen_range(0..10));
+    let now = Instant::now();
+
+    while now.elapsed() < timeout {
+        for _ in 0..100 {
+            let guard = &handle.pin();
+            guard.flush();
+
+            let val = if rng.gen() {
+                let p = a.swap(Owned::new(AtomicUsize::new(sum)), AcqRel, guard);
+                unsafe {
+                    guard.defer_destroy(p);
+                    guard.flush();
+                    p.deref().load(Relaxed)
+                }
+            } else {
+                let p = a.load(Acquire, guard);
+                unsafe { p.deref().fetch_add(sum, Relaxed) }
+            };
+
+            sum = sum.wrapping_add(val);
+        }
+    }
+
+    sum
+}
+
+fn main() {
+    for _ in 0..100 {
+        let collector = Collector::new();
+        let a = Arc::new(Atomic::new(AtomicUsize::new(777)));
+
+        let threads = (0..16)
+            .map(|_| {
+                let a = a.clone();
+                let c = collector.clone();
+                thread::spawn(move || worker(a, c.register()))
+            })
+            .collect::<Vec<_>>();
+
+        for t in threads {
+            t.join().unwrap();
+        }
+
+        unsafe {
+            a.swap(Shared::null(), AcqRel, epoch::unprotected())
+                .into_owned();
+        }
+    }
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-epoch-0.9.18/src/atomic.rs

@@ -0,0 +1,1702 @@
+use alloc::boxed::Box;
+use core::alloc::Layout;
+use core::borrow::{Borrow, BorrowMut};
+use core::cmp;
+use core::fmt;
+use core::marker::PhantomData;
+use core::mem::{self, MaybeUninit};
+use core::ops::{Deref, DerefMut};
+use core::ptr;
+use core::slice;
+
+use crate::guard::Guard;
+use crate::primitive::sync::atomic::{AtomicUsize, Ordering};
+use crossbeam_utils::atomic::AtomicConsume;
+
+/// Given ordering for the success case in a compare-exchange operation, returns the strongest
+/// appropriate ordering for the failure case.
+#[inline]
+fn strongest_failure_ordering(ord: Ordering) -> Ordering {
+    use self::Ordering::*;
+    match ord {
+        Relaxed | Release => Relaxed,
+        Acquire | AcqRel => Acquire,
+        _ => SeqCst,
+    }
+}
+
+/// The error returned on failed compare-and-set operation.
+// TODO: remove in the next major version.
+#[deprecated(note = "Use `CompareExchangeError` instead")]
+pub type CompareAndSetError<'g, T, P> = CompareExchangeError<'g, T, P>;
+
+/// The error returned on failed compare-and-swap operation.
+pub struct CompareExchangeError<'g, T: ?Sized + Pointable, P: Pointer<T>> {
+    /// The value in the atomic pointer at the time of the failed operation.
+    pub current: Shared<'g, T>,
+
+    /// The new value, which the operation failed to store.
+    pub new: P,
+}
+
+impl<T, P: Pointer<T> + fmt::Debug> fmt::Debug for CompareExchangeError<'_, T, P> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("CompareExchangeError")
+            .field("current", &self.current)
+            .field("new", &self.new)
+            .finish()
+    }
+}
+
+/// Memory orderings for compare-and-set operations.
+///
+/// A compare-and-set operation can have different memory orderings depending on whether it
+/// succeeds or fails. This trait generalizes different ways of specifying memory orderings.
+///
+/// The two ways of specifying orderings for compare-and-set are:
+///
+/// 1. Just one `Ordering` for the success case. In case of failure, the strongest appropriate
+///    ordering is chosen.
+/// 2. A pair of `Ordering`s. The first one is for the success case, while the second one is
+///    for the failure case.
+// TODO: remove in the next major version.
+#[deprecated(
+    note = "`compare_and_set` and `compare_and_set_weak` that use this trait are deprecated, \
+            use `compare_exchange` or `compare_exchange_weak instead`"
+)]
+pub trait CompareAndSetOrdering {
+    /// The ordering of the operation when it succeeds.
+    fn success(&self) -> Ordering;
+
+    /// The ordering of the operation when it fails.
+    ///
+    /// The failure ordering can't be `Release` or `AcqRel` and must be equivalent or weaker than
+    /// the success ordering.
+    fn failure(&self) -> Ordering;
+}
+
+#[allow(deprecated)]
+impl CompareAndSetOrdering for Ordering {
+    #[inline]
+    fn success(&self) -> Ordering {
+        *self
+    }
+
+    #[inline]
+    fn failure(&self) -> Ordering {
+        strongest_failure_ordering(*self)
+    }
+}
+
+#[allow(deprecated)]
+impl CompareAndSetOrdering for (Ordering, Ordering) {
+    #[inline]
+    fn success(&self) -> Ordering {
+        self.0
+    }
+
+    #[inline]
+    fn failure(&self) -> Ordering {
+        self.1
+    }
+}
+
+/// Returns a bitmask containing the unused least significant bits of an aligned pointer to `T`.
+#[inline]
+fn low_bits<T: ?Sized + Pointable>() -> usize {
+    (1 << T::ALIGN.trailing_zeros()) - 1
+}
+
+/// Panics if the pointer is not properly unaligned.
+#[inline]
+fn ensure_aligned<T: ?Sized + Pointable>(raw: usize) {
+    assert_eq!(raw & low_bits::<T>(), 0, "unaligned pointer");
+}
+
+/// Given a tagged pointer `data`, returns the same pointer, but tagged with `tag`.
+///
+/// `tag` is truncated to fit into the unused bits of the pointer to `T`.
+#[inline]
+fn compose_tag<T: ?Sized + Pointable>(data: usize, tag: usize) -> usize {
+    (data & !low_bits::<T>()) | (tag & low_bits::<T>())
+}
+
+/// Decomposes a tagged pointer `data` into the pointer and the tag.
+#[inline]
+fn decompose_tag<T: ?Sized + Pointable>(data: usize) -> (usize, usize) {
+    (data & !low_bits::<T>(), data & low_bits::<T>())
+}
+
+/// Types that are pointed to by a single word.
+///
+/// In concurrent programming, it is necessary to represent an object within a word because atomic
+/// operations (e.g., reads, writes, read-modify-writes) support only single words.  This trait
+/// qualifies such types that are pointed to by a single word.
+///
+/// The trait generalizes `Box<T>` for a sized type `T`.  In a box, an object of type `T` is
+/// allocated in heap and it is owned by a single-word pointer.  This trait is also implemented for
+/// `[MaybeUninit<T>]` by storing its size along with its elements and pointing to the pair of array
+/// size and elements.
+///
+/// Pointers to `Pointable` types can be stored in [`Atomic`], [`Owned`], and [`Shared`].  In
+/// particular, Crossbeam supports dynamically sized slices as follows.
+///
+/// ```
+/// use std::mem::MaybeUninit;
+/// use crossbeam_epoch::Owned;
+///
+/// let o = Owned::<[MaybeUninit<i32>]>::init(10); // allocating [i32; 10]
+/// ```
+pub trait Pointable {
+    /// The alignment of pointer.
+    const ALIGN: usize;
+
+    /// The type for initializers.
+    type Init;
+
+    /// Initializes a with the given initializer.
+    ///
+    /// # Safety
+    ///
+    /// The result should be a multiple of `ALIGN`.
+    unsafe fn init(init: Self::Init) -> usize;
+
+    /// Dereferences the given pointer.
+    ///
+    /// # Safety
+    ///
+    /// - The given `ptr` should have been initialized with [`Pointable::init`].
+    /// - `ptr` should not have yet been dropped by [`Pointable::drop`].
+    /// - `ptr` should not be mutably dereferenced by [`Pointable::deref_mut`] concurrently.
+    unsafe fn deref<'a>(ptr: usize) -> &'a Self;
+
+    /// Mutably dereferences the given pointer.
+    ///
+    /// # Safety
+    ///
+    /// - The given `ptr` should have been initialized with [`Pointable::init`].
+    /// - `ptr` should not have yet been dropped by [`Pointable::drop`].
+    /// - `ptr` should not be dereferenced by [`Pointable::deref`] or [`Pointable::deref_mut`]
+    ///   concurrently.
+    unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut Self;
+
+    /// Drops the object pointed to by the given pointer.
+    ///
+    /// # Safety
+    ///
+    /// - The given `ptr` should have been initialized with [`Pointable::init`].
+    /// - `ptr` should not have yet been dropped by [`Pointable::drop`].
+    /// - `ptr` should not be dereferenced by [`Pointable::deref`] or [`Pointable::deref_mut`]
+    ///   concurrently.
+    unsafe fn drop(ptr: usize);
+}
+
+impl<T> Pointable for T {
+    const ALIGN: usize = mem::align_of::<T>();
+
+    type Init = T;
+
+    unsafe fn init(init: Self::Init) -> usize {
+        Box::into_raw(Box::new(init)) as usize
+    }
+
+    unsafe fn deref<'a>(ptr: usize) -> &'a Self {
+        &*(ptr as *const T)
+    }
+
+    unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut Self {
+        &mut *(ptr as *mut T)
+    }
+
+    unsafe fn drop(ptr: usize) {
+        drop(Box::from_raw(ptr as *mut T));
+    }
+}
+
+/// Array with size.
+///
+/// # Memory layout
+///
+/// An array consisting of size and elements:
+///
+/// ```text
+///          elements
+///          |
+///          |
+/// ------------------------------------
+/// | size | 0 | 1 | 2 | 3 | 4 | 5 | 6 |
+/// ------------------------------------
+/// ```
+///
+/// Its memory layout is different from that of `Box<[T]>` in that size is in the allocation (not
+/// along with pointer as in `Box<[T]>`).
+///
+/// Elements are not present in the type, but they will be in the allocation.
+/// ```
+#[repr(C)]
+struct Array<T> {
+    /// The number of elements (not the number of bytes).
+    len: usize,
+    elements: [MaybeUninit<T>; 0],
+}
+
+impl<T> Array<T> {
+    fn layout(len: usize) -> Layout {
+        Layout::new::<Self>()
+            .extend(Layout::array::<MaybeUninit<T>>(len).unwrap())
+            .unwrap()
+            .0
+            .pad_to_align()
+    }
+}
+
+impl<T> Pointable for [MaybeUninit<T>] {
+    const ALIGN: usize = mem::align_of::<Array<T>>();
+
+    type Init = usize;
+
+    unsafe fn init(len: Self::Init) -> usize {
+        let layout = Array::<T>::layout(len);
+        let ptr = alloc::alloc::alloc(layout).cast::<Array<T>>();
+        if ptr.is_null() {
+            alloc::alloc::handle_alloc_error(layout);
+        }
+        ptr::addr_of_mut!((*ptr).len).write(len);
+        ptr as usize
+    }
+
+    unsafe fn deref<'a>(ptr: usize) -> &'a Self {
+        let array = &*(ptr as *const Array<T>);
+        slice::from_raw_parts(array.elements.as_ptr() as *const _, array.len)
+    }
+
+    unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut Self {
+        let array = &*(ptr as *mut Array<T>);
+        slice::from_raw_parts_mut(array.elements.as_ptr() as *mut _, array.len)
+    }
+
+    unsafe fn drop(ptr: usize) {
+        let len = (*(ptr as *mut Array<T>)).len;
+        let layout = Array::<T>::layout(len);
+        alloc::alloc::dealloc(ptr as *mut u8, layout);
+    }
+}
+
+/// An atomic pointer that can be safely shared between threads.
+///
+/// The pointer must be properly aligned. Since it is aligned, a tag can be stored into the unused
+/// least significant bits of the address. For example, the tag for a pointer to a sized type `T`
+/// should be less than `(1 << mem::align_of::<T>().trailing_zeros())`.
+///
+/// Any method that loads the pointer must be passed a reference to a [`Guard`].
+///
+/// Crossbeam supports dynamically sized types.  See [`Pointable`] for details.
+pub struct Atomic<T: ?Sized + Pointable> {
+    data: AtomicUsize,
+    _marker: PhantomData<*mut T>,
+}
+
+unsafe impl<T: ?Sized + Pointable + Send + Sync> Send for Atomic<T> {}
+unsafe impl<T: ?Sized + Pointable + Send + Sync> Sync for Atomic<T> {}
+
+impl<T> Atomic<T> {
+    /// Allocates `value` on the heap and returns a new atomic pointer pointing to it.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use crossbeam_epoch::Atomic;
+    ///
+    /// let a = Atomic::new(1234);
+    /// # unsafe { drop(a.into_owned()); } // avoid leak
+    /// ```
+    pub fn new(init: T) -> Atomic<T> {
+        Self::init(init)
+    }
+}
+
+impl<T: ?Sized + Pointable> Atomic<T> {
+    /// Allocates `value` on the heap and returns a new atomic pointer pointing to it.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use crossbeam_epoch::Atomic;
+    ///
+    /// let a = Atomic::<i32>::init(1234);
+    /// # unsafe { drop(a.into_owned()); } // avoid leak
+    /// ```
+    pub fn init(init: T::Init) -> Atomic<T> {
+        Self::from(Owned::init(init))
+    }
+
+    /// Returns a new atomic pointer pointing to the tagged pointer `data`.
+    fn from_usize(data: usize) -> Self {
+        Self {
+            data: AtomicUsize::new(data),
+            _marker: PhantomData,
+        }
+    }
+
+    /// Returns a new null atomic pointer.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use crossbeam_epoch::Atomic;
+    ///
+    /// let a = Atomic::<i32>::null();
+    /// ```
+    #[cfg(not(crossbeam_loom))]
+    pub const fn null() -> Atomic<T> {
+        Self {
+            data: AtomicUsize::new(0),
+            _marker: PhantomData,
+        }
+    }
+    /// Returns a new null atomic pointer.
+    #[cfg(crossbeam_loom)]
+    pub fn null() -> Atomic<T> {
+        Self {
+            data: AtomicUsize::new(0),
+            _marker: PhantomData,
+        }
+    }
+
+    /// Loads a `Shared` from the atomic pointer.
+    ///
+    /// This method takes an [`Ordering`] argument which describes the memory ordering of this
+    /// operation.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use crossbeam_epoch::{self as epoch, Atomic};
+    /// use std::sync::atomic::Ordering::SeqCst;
+    ///
+    /// let a = Atomic::new(1234);
+    /// let guard = &epoch::pin();
+    /// let p = a.load(SeqCst, guard);
+    /// # unsafe { drop(a.into_owned()); } // avoid leak
+    /// ```
+    pub fn load<'g>(&self, ord: Ordering, _: &'g Guard) -> Shared<'g, T> {
+        unsafe { Shared::from_usize(self.data.load(ord)) }
+    }
+
+    /// Loads a `Shared` from the atomic pointer using a "consume" memory ordering.
+    ///
+    /// This is similar to the "acquire" ordering, except that an ordering is
+    /// only guaranteed with operations that "depend on" the result of the load.
+    /// However consume loads are usually much faster than acquire loads on
+    /// architectures with a weak memory model since they don't require memory
+    /// fence instructions.
+    ///
+    /// The exact definition of "depend on" is a bit vague, but it works as you
+    /// would expect in practice since a lot of software, especially the Linux
+    /// kernel, rely on this behavior.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use crossbeam_epoch::{self as epoch, Atomic};
+    ///
+    /// let a = Atomic::new(1234);
+    /// let guard = &epoch::pin();
+    /// let p = a.load_consume(guard);
+    /// # unsafe { drop(a.into_owned()); } // avoid leak
+    /// ```
+    pub fn load_consume<'g>(&self, _: &'g Guard) -> Shared<'g, T> {
+        unsafe { Shared::from_usize(self.data.load_consume()) }
+    }
+
+    /// Stores a `Shared` or `Owned` pointer into the atomic pointer.
+    ///
+    /// This method takes an [`Ordering`] argument which describes the memory ordering of this
+    /// operation.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use crossbeam_epoch::{Atomic, Owned, Shared};
+    /// use std::sync::atomic::Ordering::SeqCst;
+    ///
+    /// let a = Atomic::new(1234);
+    /// # unsafe { drop(a.load(SeqCst, &crossbeam_epoch::pin()).into_owned()); } // avoid leak
+    /// a.store(Shared::null(), SeqCst);
+    /// a.store(Owned::new(1234), SeqCst);
+    /// # unsafe { drop(a.into_owned()); } // avoid leak
+    /// ```
+    pub fn store<P: Pointer<T>>(&self, new: P, ord: Ordering) {
+        self.data.store(new.into_usize(), ord);
+    }
+
+    /// Stores a `Shared` or `Owned` pointer into the atomic pointer, returning the previous
+    /// `Shared`.
+    ///
+    /// This method takes an [`Ordering`] argument which describes the memory ordering of this
+    /// operation.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use crossbeam_epoch::{self as epoch, Atomic, Shared};
+    /// use std::sync::atomic::Ordering::SeqCst;
+    ///
+    /// let a = Atomic::new(1234);
+    /// let guard = &epoch::pin();
+    /// let p = a.swap(Shared::null(), SeqCst, guard);
+    /// # unsafe { drop(p.into_owned()); } // avoid leak
+    /// ```
+    pub fn swap<'g, P: Pointer<T>>(&self, new: P, ord: Ordering, _: &'g Guard) -> Shared<'g, T> {
+        unsafe { Shared::from_usize(self.data.swap(new.into_usize(), ord)) }
+    }
+
+    /// Stores the pointer `new` (either `Shared` or `Owned`) into the atomic pointer if the current
+    /// value is the same as `current`. The tag is also taken into account, so two pointers to the
+    /// same object, but with different tags, will not be considered equal.
+    ///
+    /// The return value is a result indicating whether the new pointer was written. On success the
+    /// pointer that was written is returned. On failure the actual current value and `new` are
+    /// returned.
+    ///
+    /// This method takes two `Ordering` arguments to describe the memory
+    /// ordering of this operation. `success` describes the required ordering for the
+    /// read-modify-write operation that takes place if the comparison with `current` succeeds.
+    /// `failure` describes the required ordering for the load operation that takes place when
+    /// the comparison fails. Using `Acquire` as success ordering makes the store part
+    /// of this operation `Relaxed`, and using `Release` makes the successful load
+    /// `Relaxed`. The failure ordering can only be `SeqCst`, `Acquire` or `Relaxed`
+    /// and must be equivalent to or weaker than the success ordering.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use crossbeam_epoch::{self as epoch, Atomic, Owned, Shared};
+    /// use std::sync::atomic::Ordering::SeqCst;
+    ///
+    /// let a = Atomic::new(1234);
+    ///
+    /// let guard = &epoch::pin();
+    /// let curr = a.load(SeqCst, guard);
+    /// let res1 = a.compare_exchange(curr, Shared::null(), SeqCst, SeqCst, guard);
+    /// let res2 = a.compare_exchange(curr, Owned::new(5678), SeqCst, SeqCst, guard);
+    /// # unsafe { drop(curr.into_owned()); } // avoid leak
+    /// ```
+    pub fn compare_exchange<'g, P>(
+        &self,
+        current: Shared<'_, T>,
+        new: P,
+        success: Ordering,
+        failure: Ordering,
+        _: &'g Guard,
+    ) -> Result<Shared<'g, T>, CompareExchangeError<'g, T, P>>
+    where
+        P: Pointer<T>,
+    {
+        let new = new.into_usize();
+        self.data
+            .compare_exchange(current.into_usize(), new, success, failure)
+            .map(|_| unsafe { Shared::from_usize(new) })
+            .map_err(|current| unsafe {
+                CompareExchangeError {
+                    current: Shared::from_usize(current),
+                    new: P::from_usize(new),
+                }
+            })
+    }
+
+    /// Stores the pointer `new` (either `Shared` or `Owned`) into the atomic pointer if the current
+    /// value is the same as `current`. The tag is also taken into account, so two pointers to the
+    /// same object, but with different tags, will not be considered equal.
+    ///
+    /// Unlike [`compare_exchange`], this method is allowed to spuriously fail even when comparison
+    /// succeeds, which can result in more efficient code on some platforms.  The return value is a
+    /// result indicating whether the new pointer was written. On success the pointer that was
+    /// written is returned. On failure the actual current value and `new` are returned.
+    ///
+    /// This method takes two `Ordering` arguments to describe the memory
+    /// ordering of this operation. `success` describes the required ordering for the
+    /// read-modify-write operation that takes place if the comparison with `current` succeeds.
+    /// `failure` describes the required ordering for the load operation that takes place when
+    /// the comparison fails. Using `Acquire` as success ordering makes the store part
+    /// of this operation `Relaxed`, and using `Release` makes the successful load
+    /// `Relaxed`. The failure ordering can only be `SeqCst`, `Acquire` or `Relaxed`
+    /// and must be equivalent to or weaker than the success ordering.
+    ///
+    /// [`compare_exchange`]: Atomic::compare_exchange
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use crossbeam_epoch::{self as epoch, Atomic, Owned, Shared};
+    /// use std::sync::atomic::Ordering::SeqCst;
+    ///
+    /// let a = Atomic::new(1234);
+    /// let guard = &epoch::pin();
+    ///
+    /// let mut new = Owned::new(5678);
+    /// let mut ptr = a.load(SeqCst, guard);
+    /// # unsafe { drop(a.load(SeqCst, guard).into_owned()); } // avoid leak
+    /// loop {
+    ///     match a.compare_exchange_weak(ptr, new, SeqCst, SeqCst, guard) {
+    ///         Ok(p) => {
+    ///             ptr = p;
+    ///             break;
+    ///         }
+    ///         Err(err) => {
+    ///             ptr = err.current;
+    ///             new = err.new;
+    ///         }
+    ///     }
+    /// }
+    ///
+    /// let mut curr = a.load(SeqCst, guard);
+    /// loop {
+    ///     match a.compare_exchange_weak(curr, Shared::null(), SeqCst, SeqCst, guard) {
+    ///         Ok(_) => break,
+    ///         Err(err) => curr = err.current,
+    ///     }
+    /// }
+    /// # unsafe { drop(curr.into_owned()); } // avoid leak
+    /// ```
+    pub fn compare_exchange_weak<'g, P>(
+        &self,
+        current: Shared<'_, T>,
+        new: P,
+        success: Ordering,
+        failure: Ordering,
+        _: &'g Guard,
+    ) -> Result<Shared<'g, T>, CompareExchangeError<'g, T, P>>
+    where
+        P: Pointer<T>,
+    {
+        let new = new.into_usize();
+        self.data
+            .compare_exchange_weak(current.into_usize(), new, success, failure)
+            .map(|_| unsafe { Shared::from_usize(new) })
+            .map_err(|current| unsafe {
+                CompareExchangeError {
+                    current: Shared::from_usize(current),
+                    new: P::from_usize(new),
+                }
+            })
+    }
+
+    /// Fetches the pointer, and then applies a function to it that returns a new value.
+    /// Returns a `Result` of `Ok(previous_value)` if the function returned `Some`, else `Err(_)`.
+    ///
+    /// Note that the given function may be called multiple times if the value has been changed by
+    /// other threads in the meantime, as long as the function returns `Some(_)`, but the function
+    /// will have been applied only once to the stored value.
+    ///
+    /// `fetch_update` takes two [`Ordering`] arguments to describe the memory
+    /// ordering of this operation. The first describes the required ordering for
+    /// when the operation finally succeeds while the second describes the
+    /// required ordering for loads. These correspond to the success and failure
+    /// orderings of [`Atomic::compare_exchange`] respectively.
+    ///
+    /// Using [`Acquire`] as success ordering makes the store part of this
+    /// operation [`Relaxed`], and using [`Release`] makes the final successful
+    /// load [`Relaxed`]. The (failed) load ordering can only be [`SeqCst`],
+    /// [`Acquire`] or [`Relaxed`] and must be equivalent to or weaker than the
+    /// success ordering.
+    ///
+    /// [`Relaxed`]: Ordering::Relaxed
+    /// [`Acquire`]: Ordering::Acquire
+    /// [`Release`]: Ordering::Release
+    /// [`SeqCst`]: Ordering::SeqCst
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use crossbeam_epoch::{self as epoch, Atomic};
+    /// use std::sync::atomic::Ordering::SeqCst;
+    ///
+    /// let a = Atomic::new(1234);
+    /// let guard = &epoch::pin();
+    ///
+    /// let res1 = a.fetch_update(SeqCst, SeqCst, guard, |x| Some(x.with_tag(1)));
+    /// assert!(res1.is_ok());
+    ///
+    /// let res2 = a.fetch_update(SeqCst, SeqCst, guard, |x| None);
+    /// assert!(res2.is_err());
+    /// # unsafe { drop(a.into_owned()); } // avoid leak
+    /// ```
+    pub fn fetch_update<'g, F>(
+        &self,
+        set_order: Ordering,
+        fail_order: Ordering,
+        guard: &'g Guard,
+        mut func: F,
+    ) -> Result<Shared<'g, T>, Shared<'g, T>>
+    where
+        F: FnMut(Shared<'g, T>) -> Option<Shared<'g, T>>,
+    {
+        let mut prev = self.load(fail_order, guard);
+        while let Some(next) = func(prev) {
+            match self.compare_exchange_weak(prev, next, set_order, fail_order, guard) {
+                Ok(shared) => return Ok(shared),
+                Err(next_prev) => prev = next_prev.current,
+            }
+        }
+        Err(prev)
+    }
+
+    /// Stores the pointer `new` (either `Shared` or `Owned`) into the atomic pointer if the current
+    /// value is the same as `current`. The tag is also taken into account, so two pointers to the
+    /// same object, but with different tags, will not be considered equal.
+    ///
+    /// The return value is a result indicating whether the new pointer was written. On success the
+    /// pointer that was written is returned. On failure the actual current value and `new` are
+    /// returned.
+    ///
+    /// This method takes a [`CompareAndSetOrdering`] argument which describes the memory
+    /// ordering of this operation.
+    ///
+    /// # Migrating to `compare_exchange`
+    ///
+    /// `compare_and_set` is equivalent to `compare_exchange` with the following mapping for
+    /// memory orderings:
+    ///
+    /// Original | Success | Failure
+    /// -------- | ------- | -------
+    /// Relaxed  | Relaxed | Relaxed
+    /// Acquire  | Acquire | Acquire
+    /// Release  | Release | Relaxed
+    /// AcqRel   | AcqRel  | Acquire
+    /// SeqCst   | SeqCst  | SeqCst
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #![allow(deprecated)]
+    /// use crossbeam_epoch::{self as epoch, Atomic, Owned, Shared};
+    /// use std::sync::atomic::Ordering::SeqCst;
+    ///
+    /// let a = Atomic::new(1234);
+    ///
+    /// let guard = &epoch::pin();
+    /// let curr = a.load(SeqCst, guard);
+    /// let res1 = a.compare_and_set(curr, Shared::null(), SeqCst, guard);
+    /// let res2 = a.compare_and_set(curr, Owned::new(5678), SeqCst, guard);
+    /// # unsafe { drop(curr.into_owned()); } // avoid leak
+    /// ```
+    // TODO: remove in the next major version.
+    #[allow(deprecated)]
+    #[deprecated(note = "Use `compare_exchange` instead")]
+    pub fn compare_and_set<'g, O, P>(
+        &self,
+        current: Shared<'_, T>,
+        new: P,
+        ord: O,
+        guard: &'g Guard,
+    ) -> Result<Shared<'g, T>, CompareAndSetError<'g, T, P>>
+    where
+        O: CompareAndSetOrdering,
+        P: Pointer<T>,
+    {
+        self.compare_exchange(current, new, ord.success(), ord.failure(), guard)
+    }
+
+    /// Stores the pointer `new` (either `Shared` or `Owned`) into the atomic pointer if the current
+    /// value is the same as `current`. The tag is also taken into account, so two pointers to the
+    /// same object, but with different tags, will not be considered equal.
+    ///
+    /// Unlike [`compare_and_set`], this method is allowed to spuriously fail even when comparison
+    /// succeeds, which can result in more efficient code on some platforms.  The return value is a
+    /// result indicating whether the new pointer was written. On success the pointer that was
+    /// written is returned. On failure the actual current value and `new` are returned.
+    ///
+    /// This method takes a [`CompareAndSetOrdering`] argument which describes the memory
+    /// ordering of this operation.
+    ///
+    /// [`compare_and_set`]: Atomic::compare_and_set
+    ///
+    /// # Migrating to `compare_exchange_weak`
+    ///
+    /// `compare_and_set_weak` is equivalent to `compare_exchange_weak` with the following mapping for
+    /// memory orderings:
+    ///
+    /// Original | Success | Failure
+    /// -------- | ------- | -------
+    /// Relaxed  | Relaxed | Relaxed
+    /// Acquire  | Acquire | Acquire
+    /// Release  | Release | Relaxed
+    /// AcqRel   | AcqRel  | Acquire
+    /// SeqCst   | SeqCst  | SeqCst
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #![allow(deprecated)]
+    /// use crossbeam_epoch::{self as epoch, Atomic, Owned, Shared};
+    /// use std::sync::atomic::Ordering::SeqCst;
+    ///
+    /// let a = Atomic::new(1234);
+    /// let guard = &epoch::pin();
+    ///
+    /// let mut new = Owned::new(5678);
+    /// let mut ptr = a.load(SeqCst, guard);
+    /// # unsafe { drop(a.load(SeqCst, guard).into_owned()); } // avoid leak
+    /// loop {
+    ///     match a.compare_and_set_weak(ptr, new, SeqCst, guard) {
+    ///         Ok(p) => {
+    ///             ptr = p;
+    ///             break;
+    ///         }
+    ///         Err(err) => {
+    ///             ptr = err.current;
+    ///             new = err.new;
+    ///         }
+    ///     }
+    /// }
+    ///
+    /// let mut curr = a.load(SeqCst, guard);
+    /// loop {
+    ///     match a.compare_and_set_weak(curr, Shared::null(), SeqCst, guard) {
+    ///         Ok(_) => break,
+    ///         Err(err) => curr = err.current,
+    ///     }
+    /// }
+    /// # unsafe { drop(curr.into_owned()); } // avoid leak
+    /// ```
+    // TODO: remove in the next major version.
+    #[allow(deprecated)]
+    #[deprecated(note = "Use `compare_exchange_weak` instead")]
+    pub fn compare_and_set_weak<'g, O, P>(
+        &self,
+        current: Shared<'_, T>,
+        new: P,
+        ord: O,
+        guard: &'g Guard,
+    ) -> Result<Shared<'g, T>, CompareAndSetError<'g, T, P>>
+    where
+        O: CompareAndSetOrdering,
+        P: Pointer<T>,
+    {
+        self.compare_exchange_weak(current, new, ord.success(), ord.failure(), guard)
+    }
+
+    /// Bitwise "and" with the current tag.
+    ///
+    /// Performs a bitwise "and" operation on the current tag and the argument `val`, and sets the
+    /// new tag to the result. Returns the previous pointer.
+    ///
+    /// This method takes an [`Ordering`] argument which describes the memory ordering of this
+    /// operation.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use crossbeam_epoch::{self as epoch, Atomic, Shared};
+    /// use std::sync::atomic::Ordering::SeqCst;
+    ///
+    /// let a = Atomic::<i32>::from(Shared::null().with_tag(3));
+    /// let guard = &epoch::pin();
+    /// assert_eq!(a.fetch_and(2, SeqCst, guard).tag(), 3);
+    /// assert_eq!(a.load(SeqCst, guard).tag(), 2);
+    /// ```
+    pub fn fetch_and<'g>(&self, val: usize, ord: Ordering, _: &'g Guard) -> Shared<'g, T> {
+        unsafe { Shared::from_usize(self.data.fetch_and(val | !low_bits::<T>(), ord)) }
+    }
+
+    /// Bitwise "or" with the current tag.
+    ///
+    /// Performs a bitwise "or" operation on the current tag and the argument `val`, and sets the
+    /// new tag to the result. Returns the previous pointer.
+    ///
+    /// This method takes an [`Ordering`] argument which describes the memory ordering of this
+    /// operation.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use crossbeam_epoch::{self as epoch, Atomic, Shared};
+    /// use std::sync::atomic::Ordering::SeqCst;
+    ///
+    /// let a = Atomic::<i32>::from(Shared::null().with_tag(1));
+    /// let guard = &epoch::pin();
+    /// assert_eq!(a.fetch_or(2, SeqCst, guard).tag(), 1);
+    /// assert_eq!(a.load(SeqCst, guard).tag(), 3);
+    /// ```
+    pub fn fetch_or<'g>(&self, val: usize, ord: Ordering, _: &'g Guard) -> Shared<'g, T> {
+        unsafe { Shared::from_usize(self.data.fetch_or(val & low_bits::<T>(), ord)) }
+    }
+
+    /// Bitwise "xor" with the current tag.
+    ///
+    /// Performs a bitwise "xor" operation on the current tag and the argument `val`, and sets the
+    /// new tag to the result. Returns the previous pointer.
+    ///
+    /// This method takes an [`Ordering`] argument which describes the memory ordering of this
+    /// operation.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use crossbeam_epoch::{self as epoch, Atomic, Shared};
+    /// use std::sync::atomic::Ordering::SeqCst;
+    ///
+    /// let a = Atomic::<i32>::from(Shared::null().with_tag(1));
+    /// let guard = &epoch::pin();
+    /// assert_eq!(a.fetch_xor(3, SeqCst, guard).tag(), 1);
+    /// assert_eq!(a.load(SeqCst, guard).tag(), 2);
+    /// ```
+    pub fn fetch_xor<'g>(&self, val: usize, ord: Ordering, _: &'g Guard) -> Shared<'g, T> {
+        unsafe { Shared::from_usize(self.data.fetch_xor(val & low_bits::<T>(), ord)) }
+    }
+
+    /// Takes ownership of the pointee.
+    ///
+    /// This consumes the atomic and converts it into [`Owned`]. As [`Atomic`] doesn't have a
+    /// destructor and doesn't drop the pointee while [`Owned`] does, this is suitable for
+    /// destructors of data structures.
+    ///
+    /// # Panics
+    ///
+    /// Panics if this pointer is null, but only in debug mode.
+    ///
+    /// # Safety
+    ///
+    /// This method may be called only if the pointer is valid and nobody else is holding a
+    /// reference to the same object.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # use std::mem;
+    /// # use crossbeam_epoch::Atomic;
+    /// struct DataStructure {
+    ///     ptr: Atomic<usize>,
+    /// }
+    ///
+    /// impl Drop for DataStructure {
+    ///     fn drop(&mut self) {
+    ///         // By now the DataStructure lives only in our thread and we are sure we don't hold
+    ///         // any Shared or & to it ourselves.
+    ///         unsafe {
+    ///             drop(mem::replace(&mut self.ptr, Atomic::null()).into_owned());
+    ///         }
+    ///     }
+    /// }
+    /// ```
+    pub unsafe fn into_owned(self) -> Owned<T> {
+        Owned::from_usize(self.data.into_inner())
+    }
+
+    /// Takes ownership of the pointee if it is non-null.
+    ///
+    /// This consumes the atomic and converts it into [`Owned`]. As [`Atomic`] doesn't have a
+    /// destructor and doesn't drop the pointee while [`Owned`] does, this is suitable for
+    /// destructors of data structures.
+    ///
+    /// # Safety
+    ///
+    /// This method may be called only if the pointer is valid and nobody else is holding a
+    /// reference to the same object, or the pointer is null.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # use std::mem;
+    /// # use crossbeam_epoch::Atomic;
+    /// struct DataStructure {
+    ///     ptr: Atomic<usize>,
+    /// }
+    ///
+    /// impl Drop for DataStructure {
+    ///     fn drop(&mut self) {
+    ///         // By now the DataStructure lives only in our thread and we are sure we don't hold
+    ///         // any Shared or & to it ourselves, but it may be null, so we have to be careful.
+    ///         let old = mem::replace(&mut self.ptr, Atomic::null());
+    ///         unsafe {
+    ///             if let Some(x) = old.try_into_owned() {
+    ///                 drop(x)
+    ///             }
+    ///         }
+    ///     }
+    /// }
+    /// ```
+    pub unsafe fn try_into_owned(self) -> Option<Owned<T>> {
+        let data = self.data.into_inner();
+        if decompose_tag::<T>(data).0 == 0 {
+            None
+        } else {
+            Some(Owned::from_usize(data))
+        }
+    }
+}
+
+impl<T: ?Sized + Pointable> fmt::Debug for Atomic<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let data = self.data.load(Ordering::SeqCst);
+        let (raw, tag) = decompose_tag::<T>(data);
+
+        f.debug_struct("Atomic")
+            .field("raw", &raw)
+            .field("tag", &tag)
+            .finish()
+    }
+}
+
+impl<T: ?Sized + Pointable> fmt::Pointer for Atomic<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let data = self.data.load(Ordering::SeqCst);
+        let (raw, _) = decompose_tag::<T>(data);
+        fmt::Pointer::fmt(&(unsafe { T::deref(raw) as *const _ }), f)
+    }
+}
+
+impl<T: ?Sized + Pointable> Clone for Atomic<T> {
+    /// Returns a copy of the atomic value.
+    ///
+    /// Note that a `Relaxed` load is used here. If you need synchronization, use it with other
+    /// atomics or fences.
+    fn clone(&self) -> Self {
+        let data = self.data.load(Ordering::Relaxed);
+        Atomic::from_usize(data)
+    }
+}
+
+impl<T: ?Sized + Pointable> Default for Atomic<T> {
+    fn default() -> Self {
+        Atomic::null()
+    }
+}
+
+impl<T: ?Sized + Pointable> From<Owned<T>> for Atomic<T> {
+    /// Returns a new atomic pointer pointing to `owned`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use crossbeam_epoch::{Atomic, Owned};
+    ///
+    /// let a = Atomic::<i32>::from(Owned::new(1234));
+    /// # unsafe { drop(a.into_owned()); } // avoid leak
+    /// ```
+    fn from(owned: Owned<T>) -> Self {
+        let data = owned.data;
+        mem::forget(owned);
+        Self::from_usize(data)
+    }
+}
+
+impl<T> From<Box<T>> for Atomic<T> {
+    fn from(b: Box<T>) -> Self {
+        Self::from(Owned::from(b))
+    }
+}
+
+impl<T> From<T> for Atomic<T> {
+    fn from(t: T) -> Self {
+        Self::new(t)
+    }
+}
+
+impl<'g, T: ?Sized + Pointable> From<Shared<'g, T>> for Atomic<T> {
+    /// Returns a new atomic pointer pointing to `ptr`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use crossbeam_epoch::{Atomic, Shared};
+    ///
+    /// let a = Atomic::<i32>::from(Shared::<i32>::null());
+    /// ```
+    fn from(ptr: Shared<'g, T>) -> Self {
+        Self::from_usize(ptr.data)
+    }
+}
+
+impl<T> From<*const T> for Atomic<T> {
+    /// Returns a new atomic pointer pointing to `raw`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::ptr;
+    /// use crossbeam_epoch::Atomic;
+    ///
+    /// let a = Atomic::<i32>::from(ptr::null::<i32>());
+    /// ```
+    fn from(raw: *const T) -> Self {
+        Self::from_usize(raw as usize)
+    }
+}
+
+/// A trait for either `Owned` or `Shared` pointers.
+pub trait Pointer<T: ?Sized + Pointable> {
+    /// Returns the machine representation of the pointer.
+    fn into_usize(self) -> usize;
+
+    /// Returns a new pointer pointing to the tagged pointer `data`.
+    ///
+    /// # Safety
+    ///
+    /// The given `data` should have been created by `Pointer::into_usize()`, and one `data` should
+    /// not be converted back by `Pointer::from_usize()` multiple times.
+    unsafe fn from_usize(data: usize) -> Self;
+}
+
+/// An owned heap-allocated object.
+///
+/// This type is very similar to `Box<T>`.
+///
+/// The pointer must be properly aligned. Since it is aligned, a tag can be stored into the unused
+/// least significant bits of the address.
+pub struct Owned<T: ?Sized + Pointable> {
+    data: usize,
+    _marker: PhantomData<Box<T>>,
+}
+
+impl<T: ?Sized + Pointable> Pointer<T> for Owned<T> {
+    #[inline]
+    fn into_usize(self) -> usize {
+        let data = self.data;
+        mem::forget(self);
+        data
+    }
+
+    /// Returns a new pointer pointing to the tagged pointer `data`.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the data is zero in debug mode.
+    #[inline]
+    unsafe fn from_usize(data: usize) -> Self {
+        debug_assert!(data != 0, "converting zero into `Owned`");
+        Owned {
+            data,
+            _marker: PhantomData,
+        }
+    }
+}
+
+impl<T> Owned<T> {
+    /// Returns a new owned pointer pointing to `raw`.
+    ///
+    /// This function is unsafe because improper use may lead to memory problems. Argument `raw`
+    /// must be a valid pointer. Also, a double-free may occur if the function is called twice on
+    /// the same raw pointer.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `raw` is not properly aligned.
+    ///
+    /// # Safety
+    ///
+    /// The given `raw` should have been derived from `Owned`, and one `raw` should not be converted
+    /// back by `Owned::from_raw()` multiple times.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use crossbeam_epoch::Owned;
+    ///
+    /// let o = unsafe { Owned::from_raw(Box::into_raw(Box::new(1234))) };
+    /// ```
+    pub unsafe fn from_raw(raw: *mut T) -> Owned<T> {
+        let raw = raw as usize;
+        ensure_aligned::<T>(raw);
+        Self::from_usize(raw)
+    }
+
+    /// Converts the owned pointer into a `Box`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use crossbeam_epoch::Owned;
+    ///
+    /// let o = Owned::new(1234);
+    /// let b: Box<i32> = o.into_box();
+    /// assert_eq!(*b, 1234);
+    /// ```
+    pub fn into_box(self) -> Box<T> {
+        let (raw, _) = decompose_tag::<T>(self.data);
+        mem::forget(self);
+        unsafe { Box::from_raw(raw as *mut _) }
+    }
+
+    /// Allocates `value` on the heap and returns a new owned pointer pointing to it.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use crossbeam_epoch::Owned;
+    ///
+    /// let o = Owned::new(1234);
+    /// ```
+    pub fn new(init: T) -> Owned<T> {
+        Self::init(init)
+    }
+}
+
+impl<T: ?Sized + Pointable> Owned<T> {
+    /// Allocates `value` on the heap and returns a new owned pointer pointing to it.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use crossbeam_epoch::Owned;
+    ///
+    /// let o = Owned::<i32>::init(1234);
+    /// ```
+    pub fn init(init: T::Init) -> Owned<T> {
+        unsafe { Self::from_usize(T::init(init)) }
+    }
+
+    /// Converts the owned pointer into a [`Shared`].
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use crossbeam_epoch::{self as epoch, Owned};
+    ///
+    /// let o = Owned::new(1234);
+    /// let guard = &epoch::pin();
+    /// let p = o.into_shared(guard);
+    /// # unsafe { drop(p.into_owned()); } // avoid leak
+    /// ```
+    #[allow(clippy::needless_lifetimes)]
+    pub fn into_shared<'g>(self, _: &'g Guard) -> Shared<'g, T> {
+        unsafe { Shared::from_usize(self.into_usize()) }
+    }
+
+    /// Returns the tag stored within the pointer.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use crossbeam_epoch::Owned;
+    ///
+    /// assert_eq!(Owned::new(1234).tag(), 0);
+    /// ```
+    pub fn tag(&self) -> usize {
+        let (_, tag) = decompose_tag::<T>(self.data);
+        tag
+    }
+
+    /// Returns the same pointer, but tagged with `tag`. `tag` is truncated to be fit into the
+    /// unused bits of the pointer to `T`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use crossbeam_epoch::Owned;
+    ///
+    /// let o = Owned::new(0u64);
+    /// assert_eq!(o.tag(), 0);
+    /// let o = o.with_tag(2);
+    /// assert_eq!(o.tag(), 2);
+    /// ```
+    pub fn with_tag(self, tag: usize) -> Owned<T> {
+        let data = self.into_usize();
+        unsafe { Self::from_usize(compose_tag::<T>(data, tag)) }
+    }
+}
+
+impl<T: ?Sized + Pointable> Drop for Owned<T> {
+    fn drop(&mut self) {
+        let (raw, _) = decompose_tag::<T>(self.data);
+        unsafe {
+            T::drop(raw);
+        }
+    }
+}
+
+impl<T: ?Sized + Pointable> fmt::Debug for Owned<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let (raw, tag) = decompose_tag::<T>(self.data);
+
+        f.debug_struct("Owned")
+            .field("raw", &raw)
+            .field("tag", &tag)
+            .finish()
+    }
+}
+
+impl<T: Clone> Clone for Owned<T> {
+    fn clone(&self) -> Self {
+        Owned::new((**self).clone()).with_tag(self.tag())
+    }
+}
+
+impl<T: ?Sized + Pointable> Deref for Owned<T> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        let (raw, _) = decompose_tag::<T>(self.data);
+        unsafe { T::deref(raw) }
+    }
+}
+
+impl<T: ?Sized + Pointable> DerefMut for Owned<T> {
+    fn deref_mut(&mut self) -> &mut T {
+        let (raw, _) = decompose_tag::<T>(self.data);
+        unsafe { T::deref_mut(raw) }
+    }
+}
+
+impl<T> From<T> for Owned<T> {
+    fn from(t: T) -> Self {
+        Owned::new(t)
+    }
+}
+
+impl<T> From<Box<T>> for Owned<T> {
+    /// Returns a new owned pointer pointing to `b`.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the pointer (the `Box`) is not properly aligned.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use crossbeam_epoch::Owned;
+    ///
+    /// let o = unsafe { Owned::from_raw(Box::into_raw(Box::new(1234))) };
+    /// ```
+    fn from(b: Box<T>) -> Self {
+        unsafe { Self::from_raw(Box::into_raw(b)) }
+    }
+}
+
+impl<T: ?Sized + Pointable> Borrow<T> for Owned<T> {
+    fn borrow(&self) -> &T {
+        self.deref()
+    }
+}
+
+impl<T: ?Sized + Pointable> BorrowMut<T> for Owned<T> {
+    fn borrow_mut(&mut self) -> &mut T {
+        self.deref_mut()
+    }
+}
+
+impl<T: ?Sized + Pointable> AsRef<T> for Owned<T> {
+    fn as_ref(&self) -> &T {
+        self.deref()
+    }
+}
+
+impl<T: ?Sized + Pointable> AsMut<T> for Owned<T> {
+    fn as_mut(&mut self) -> &mut T {
+        self.deref_mut()
+    }
+}
+
+/// A pointer to an object protected by the epoch GC.
+///
+/// The pointer is valid for use only during the lifetime `'g`.
+///
+/// The pointer must be properly aligned. Since it is aligned, a tag can be stored into the unused
+/// least significant bits of the address.
+pub struct Shared<'g, T: 'g + ?Sized + Pointable> {
+    data: usize,
+    _marker: PhantomData<(&'g (), *const T)>,
+}
+
+impl<T: ?Sized + Pointable> Clone for Shared<'_, T> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl<T: ?Sized + Pointable> Copy for Shared<'_, T> {}
+
+impl<T: ?Sized + Pointable> Pointer<T> for Shared<'_, T> {
+    #[inline]
+    fn into_usize(self) -> usize {
+        self.data
+    }
+
+    #[inline]
+    unsafe fn from_usize(data: usize) -> Self {
+        Shared {
+            data,
+            _marker: PhantomData,
+        }
+    }
+}
+
+impl<'g, T> Shared<'g, T> {
+    /// Converts the pointer to a raw pointer (without the tag).
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use crossbeam_epoch::{self as epoch, Atomic, Owned};
+    /// use std::sync::atomic::Ordering::SeqCst;
+    ///
+    /// let o = Owned::new(1234);
+    /// let raw = &*o as *const _;
+    /// let a = Atomic::from(o);
+    ///
+    /// let guard = &epoch::pin();
+    /// let p = a.load(SeqCst, guard);
+    /// assert_eq!(p.as_raw(), raw);
+    /// # unsafe { drop(a.into_owned()); } // avoid leak
+    /// ```
+    pub fn as_raw(&self) -> *const T {
+        let (raw, _) = decompose_tag::<T>(self.data);
+        raw as *const _
+    }
+}
+
+impl<'g, T: ?Sized + Pointable> Shared<'g, T> {
+    /// Returns a new null pointer.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use crossbeam_epoch::Shared;
+    ///
+    /// let p = Shared::<i32>::null();
+    /// assert!(p.is_null());
+    /// ```
+    pub fn null() -> Shared<'g, T> {
+        Shared {
+            data: 0,
+            _marker: PhantomData,
+        }
+    }
+
+    /// Returns `true` if the pointer is null.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use crossbeam_epoch::{self as epoch, Atomic, Owned};
+    /// use std::sync::atomic::Ordering::SeqCst;
+    ///
+    /// let a = Atomic::null();
+    /// let guard = &epoch::pin();
+    /// assert!(a.load(SeqCst, guard).is_null());
+    /// a.store(Owned::new(1234), SeqCst);
+    /// assert!(!a.load(SeqCst, guard).is_null());
+    /// # unsafe { drop(a.into_owned()); } // avoid leak
+    /// ```
+    pub fn is_null(&self) -> bool {
+        let (raw, _) = decompose_tag::<T>(self.data);
+        raw == 0
+    }
+
+    /// Dereferences the pointer.
+    ///
+    /// Returns a reference to the pointee that is valid during the lifetime `'g`.
+    ///
+    /// # Safety
+    ///
+    /// Dereferencing a pointer is unsafe because it could be pointing to invalid memory.
+    ///
+    /// Another concern is the possibility of data races due to lack of proper synchronization.
+    /// For example, consider the following scenario:
+    ///
+    /// 1. A thread creates a new object: `a.store(Owned::new(10), Relaxed)`
+    /// 2. Another thread reads it: `*a.load(Relaxed, guard).as_ref().unwrap()`
+    ///
+    /// The problem is that relaxed orderings don't synchronize initialization of the object with
+    /// the read from the second thread. This is a data race. A possible solution would be to use
+    /// `Release` and `Acquire` orderings.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use crossbeam_epoch::{self as epoch, Atomic};
+    /// use std::sync::atomic::Ordering::SeqCst;
+    ///
+    /// let a = Atomic::new(1234);
+    /// let guard = &epoch::pin();
+    /// let p = a.load(SeqCst, guard);
+    /// unsafe {
+    ///     assert_eq!(p.deref(), &1234);
+    /// }
+    /// # unsafe { drop(a.into_owned()); } // avoid leak
+    /// ```
+    pub unsafe fn deref(&self) -> &'g T {
+        let (raw, _) = decompose_tag::<T>(self.data);
+        T::deref(raw)
+    }
+
+    /// Dereferences the pointer.
+    ///
+    /// Returns a mutable reference to the pointee that is valid during the lifetime `'g`.
+    ///
+    /// # Safety
+    ///
+    /// * There is no guarantee that there are no more threads attempting to read/write from/to the
+    ///   actual object at the same time.
+    ///
+    ///   The user must know that there are no concurrent accesses towards the object itself.
+    ///
+    /// * Other than the above, all safety concerns of `deref()` applies here.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use crossbeam_epoch::{self as epoch, Atomic};
+    /// use std::sync::atomic::Ordering::SeqCst;
+    ///
+    /// let a = Atomic::new(vec![1, 2, 3, 4]);
+    /// let guard = &epoch::pin();
+    ///
+    /// let mut p = a.load(SeqCst, guard);
+    /// unsafe {
+    ///     assert!(!p.is_null());
+    ///     let b = p.deref_mut();
+    ///     assert_eq!(b, &vec![1, 2, 3, 4]);
+    ///     b.push(5);
+    ///     assert_eq!(b, &vec![1, 2, 3, 4, 5]);
+    /// }
+    ///
+    /// let p = a.load(SeqCst, guard);
+    /// unsafe {
+    ///     assert_eq!(p.deref(), &vec![1, 2, 3, 4, 5]);
+    /// }
+    /// # unsafe { drop(a.into_owned()); } // avoid leak
+    /// ```
+    pub unsafe fn deref_mut(&mut self) -> &'g mut T {
+        let (raw, _) = decompose_tag::<T>(self.data);
+        T::deref_mut(raw)
+    }
+
+    /// Converts the pointer to a reference.
+    ///
+    /// Returns `None` if the pointer is null, or else a reference to the object wrapped in `Some`.
+    ///
+    /// # Safety
+    ///
+    /// Dereferencing a pointer is unsafe because it could be pointing to invalid memory.
+    ///
+    /// Another concern is the possibility of data races due to lack of proper synchronization.
+    /// For example, consider the following scenario:
+    ///
+    /// 1. A thread creates a new object: `a.store(Owned::new(10), Relaxed)`
+    /// 2. Another thread reads it: `*a.load(Relaxed, guard).as_ref().unwrap()`
+    ///
+    /// The problem is that relaxed orderings don't synchronize initialization of the object with
+    /// the read from the second thread. This is a data race. A possible solution would be to use
+    /// `Release` and `Acquire` orderings.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use crossbeam_epoch::{self as epoch, Atomic};
+    /// use std::sync::atomic::Ordering::SeqCst;
+    ///
+    /// let a = Atomic::new(1234);
+    /// let guard = &epoch::pin();
+    /// let p = a.load(SeqCst, guard);
+    /// unsafe {
+    ///     assert_eq!(p.as_ref(), Some(&1234));
+    /// }
+    /// # unsafe { drop(a.into_owned()); } // avoid leak
+    /// ```
+    pub unsafe fn as_ref(&self) -> Option<&'g T> {
+        let (raw, _) = decompose_tag::<T>(self.data);
+        if raw == 0 {
+            None
+        } else {
+            Some(T::deref(raw))
+        }
+    }
+
+    /// Takes ownership of the pointee.
+    ///
+    /// # Panics
+    ///
+    /// Panics if this pointer is null, but only in debug mode.
+    ///
+    /// # Safety
+    ///
+    /// This method may be called only if the pointer is valid and nobody else is holding a
+    /// reference to the same object.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use crossbeam_epoch::{self as epoch, Atomic};
+    /// use std::sync::atomic::Ordering::SeqCst;
+    ///
+    /// let a = Atomic::new(1234);
+    /// unsafe {
+    ///     let guard = &epoch::unprotected();
+    ///     let p = a.load(SeqCst, guard);
+    ///     drop(p.into_owned());
+    /// }
+    /// ```
+    pub unsafe fn into_owned(self) -> Owned<T> {
+        debug_assert!(!self.is_null(), "converting a null `Shared` into `Owned`");
+        Owned::from_usize(self.data)
+    }
+
+    /// Takes ownership of the pointee if it is not null.
+    ///
+    /// # Safety
+    ///
+    /// This method may be called only if the pointer is valid and nobody else is holding a
+    /// reference to the same object, or if the pointer is null.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use crossbeam_epoch::{self as epoch, Atomic};
+    /// use std::sync::atomic::Ordering::SeqCst;
+    ///
+    /// let a = Atomic::new(1234);
+    /// unsafe {
+    ///     let guard = &epoch::unprotected();
+    ///     let p = a.load(SeqCst, guard);
+    ///     if let Some(x) = p.try_into_owned() {
+    ///         drop(x);
+    ///     }
+    /// }
+    /// ```
+    pub unsafe fn try_into_owned(self) -> Option<Owned<T>> {
+        if self.is_null() {
+            None
+        } else {
+            Some(Owned::from_usize(self.data))
+        }
+    }
+
+    /// Returns the tag stored within the pointer.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use crossbeam_epoch::{self as epoch, Atomic, Owned};
+    /// use std::sync::atomic::Ordering::SeqCst;
+    ///
+    /// let a = Atomic::<u64>::from(Owned::new(0u64).with_tag(2));
+    /// let guard = &epoch::pin();
+    /// let p = a.load(SeqCst, guard);
+    /// assert_eq!(p.tag(), 2);
+    /// # unsafe { drop(a.into_owned()); } // avoid leak
+    /// ```
+    pub fn tag(&self) -> usize {
+        let (_, tag) = decompose_tag::<T>(self.data);
+        tag
+    }
+
+    /// Returns the same pointer, but tagged with `tag`. `tag` is truncated to be fit into the
+    /// unused bits of the pointer to `T`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use crossbeam_epoch::{self as epoch, Atomic};
+    /// use std::sync::atomic::Ordering::SeqCst;
+    ///
+    /// let a = Atomic::new(0u64);
+    /// let guard = &epoch::pin();
+    /// let p1 = a.load(SeqCst, guard);
+    /// let p2 = p1.with_tag(2);
+    ///
+    /// assert_eq!(p1.tag(), 0);
+    /// assert_eq!(p2.tag(), 2);
+    /// assert_eq!(p1.as_raw(), p2.as_raw());
+    /// # unsafe { drop(a.into_owned()); } // avoid leak
+    /// ```
+    pub fn with_tag(&self, tag: usize) -> Shared<'g, T> {
+        unsafe { Self::from_usize(compose_tag::<T>(self.data, tag)) }
+    }
+}
+
+impl<T> From<*const T> for Shared<'_, T> {
+    /// Returns a new pointer pointing to `raw`.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `raw` is not properly aligned.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use crossbeam_epoch::Shared;
+    ///
+    /// let p = Shared::from(Box::into_raw(Box::new(1234)) as *const _);
+    /// assert!(!p.is_null());
+    /// # unsafe { drop(p.into_owned()); } // avoid leak
+    /// ```
+    fn from(raw: *const T) -> Self {
+        let raw = raw as usize;
+        ensure_aligned::<T>(raw);
+        unsafe { Self::from_usize(raw) }
+    }
+}
+
+impl<'g, T: ?Sized + Pointable> PartialEq<Shared<'g, T>> for Shared<'g, T> {
+    fn eq(&self, other: &Self) -> bool {
+        self.data == other.data
+    }
+}
+
+impl<T: ?Sized + Pointable> Eq for Shared<'_, T> {}
+
+impl<'g, T: ?Sized + Pointable> PartialOrd<Shared<'g, T>> for Shared<'g, T> {
+    fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
+        self.data.partial_cmp(&other.data)
+    }
+}
+
+impl<T: ?Sized + Pointable> Ord for Shared<'_, T> {
+    fn cmp(&self, other: &Self) -> cmp::Ordering {
+        self.data.cmp(&other.data)
+    }
+}
+
+impl<T: ?Sized + Pointable> fmt::Debug for Shared<'_, T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let (raw, tag) = decompose_tag::<T>(self.data);
+
+        f.debug_struct("Shared")
+            .field("raw", &raw)
+            .field("tag", &tag)
+            .finish()
+    }
+}
+
+impl<T: ?Sized + Pointable> fmt::Pointer for Shared<'_, T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Pointer::fmt(&(unsafe { self.deref() as *const _ }), f)
+    }
+}
+
+impl<T: ?Sized + Pointable> Default for Shared<'_, T> {
+    fn default() -> Self {
+        Shared::null()
+    }
+}
+
+#[cfg(all(test, not(crossbeam_loom)))]
+mod tests {
+    use super::{Owned, Shared};
+    use std::mem::MaybeUninit;
+
+    #[test]
+    fn valid_tag_i8() {
+        Shared::<i8>::null().with_tag(0);
+    }
+
+    #[test]
+    fn valid_tag_i64() {
+        Shared::<i64>::null().with_tag(7);
+    }
+
+    #[test]
+    fn const_atomic_null() {
+        use super::Atomic;
+        static _U: Atomic<u8> = Atomic::<u8>::null();
+    }
+
+    #[test]
+    fn array_init() {
+        let owned = Owned::<[MaybeUninit<usize>]>::init(10);
+        let arr: &[MaybeUninit<usize>] = &owned;
+        assert_eq!(arr.len(), 10);
+    }
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-epoch-0.9.18/src/collector.rs

@@ -0,0 +1,464 @@
+/// Epoch-based garbage collector.
+///
+/// # Examples
+///
+/// ```
+/// use crossbeam_epoch::Collector;
+///
+/// let collector = Collector::new();
+///
+/// let handle = collector.register();
+/// drop(collector); // `handle` still works after dropping `collector`
+///
+/// handle.pin().flush();
+/// ```
+use core::fmt;
+
+use crate::guard::Guard;
+use crate::internal::{Global, Local};
+use crate::primitive::sync::Arc;
+
+/// An epoch-based garbage collector.
+pub struct Collector {
+    pub(crate) global: Arc<Global>,
+}
+
+unsafe impl Send for Collector {}
+unsafe impl Sync for Collector {}
+
+impl Default for Collector {
+    fn default() -> Self {
+        Self {
+            global: Arc::new(Global::new()),
+        }
+    }
+}
+
+impl Collector {
+    /// Creates a new collector.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Registers a new handle for the collector.
+    pub fn register(&self) -> LocalHandle {
+        Local::register(self)
+    }
+}
+
+impl Clone for Collector {
+    /// Creates another reference to the same garbage collector.
+    fn clone(&self) -> Self {
+        Collector {
+            global: self.global.clone(),
+        }
+    }
+}
+
+impl fmt::Debug for Collector {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.pad("Collector { .. }")
+    }
+}
+
+impl PartialEq for Collector {
+    /// Checks if both handles point to the same collector.
+    fn eq(&self, rhs: &Collector) -> bool {
+        Arc::ptr_eq(&self.global, &rhs.global)
+    }
+}
+impl Eq for Collector {}
+
+/// A handle to a garbage collector.
+pub struct LocalHandle {
+    pub(crate) local: *const Local,
+}
+
+impl LocalHandle {
+    /// Pins the handle.
+    #[inline]
+    pub fn pin(&self) -> Guard {
+        unsafe { (*self.local).pin() }
+    }
+
+    /// Returns `true` if the handle is pinned.
+    #[inline]
+    pub fn is_pinned(&self) -> bool {
+        unsafe { (*self.local).is_pinned() }
+    }
+
+    /// Returns the `Collector` associated with this handle.
+    #[inline]
+    pub fn collector(&self) -> &Collector {
+        unsafe { (*self.local).collector() }
+    }
+}
+
+impl Drop for LocalHandle {
+    #[inline]
+    fn drop(&mut self) {
+        unsafe {
+            Local::release_handle(&*self.local);
+        }
+    }
+}
+
+impl fmt::Debug for LocalHandle {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.pad("LocalHandle { .. }")
+    }
+}
+
+#[cfg(all(test, not(crossbeam_loom)))]
+mod tests {
+    use std::mem::ManuallyDrop;
+    use std::sync::atomic::{AtomicUsize, Ordering};
+
+    use crossbeam_utils::thread;
+
+    use crate::{Collector, Owned};
+
+    const NUM_THREADS: usize = 8;
+
+    #[test]
+    fn pin_reentrant() {
+        let collector = Collector::new();
+        let handle = collector.register();
+        drop(collector);
+
+        assert!(!handle.is_pinned());
+        {
+            let _guard = &handle.pin();
+            assert!(handle.is_pinned());
+            {
+                let _guard = &handle.pin();
+                assert!(handle.is_pinned());
+            }
+            assert!(handle.is_pinned());
+        }
+        assert!(!handle.is_pinned());
+    }
+
+    #[test]
+    fn flush_local_bag() {
+        let collector = Collector::new();
+        let handle = collector.register();
+        drop(collector);
+
+        for _ in 0..100 {
+            let guard = &handle.pin();
+            unsafe {
+                let a = Owned::new(7).into_shared(guard);
+                guard.defer_destroy(a);
+
+                assert!(!(*guard.local).bag.with(|b| (*b).is_empty()));
+
+                while !(*guard.local).bag.with(|b| (*b).is_empty()) {
+                    guard.flush();
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn garbage_buffering() {
+        let collector = Collector::new();
+        let handle = collector.register();
+        drop(collector);
+
+        let guard = &handle.pin();
+        unsafe {
+            for _ in 0..10 {
+                let a = Owned::new(7).into_shared(guard);
+                guard.defer_destroy(a);
+            }
+            assert!(!(*guard.local).bag.with(|b| (*b).is_empty()));
+        }
+    }
+
+    #[test]
+    fn pin_holds_advance() {
+        #[cfg(miri)]
+        const N: usize = 500;
+        #[cfg(not(miri))]
+        const N: usize = 500_000;
+
+        let collector = Collector::new();
+
+        thread::scope(|scope| {
+            for _ in 0..NUM_THREADS {
+                scope.spawn(|_| {
+                    let handle = collector.register();
+                    for _ in 0..N {
+                        let guard = &handle.pin();
+
+                        let before = collector.global.epoch.load(Ordering::Relaxed);
+                        collector.global.collect(guard);
+                        let after = collector.global.epoch.load(Ordering::Relaxed);
+
+                        assert!(after.wrapping_sub(before) <= 2);
+                    }
+                });
+            }
+        })
+        .unwrap();
+    }
+
+    #[cfg(not(crossbeam_sanitize))] // TODO: assertions failed due to `cfg(crossbeam_sanitize)` reduce `internal::MAX_OBJECTS`
+    #[test]
+    fn incremental() {
+        #[cfg(miri)]
+        const COUNT: usize = 500;
+        #[cfg(not(miri))]
+        const COUNT: usize = 100_000;
+        static DESTROYS: AtomicUsize = AtomicUsize::new(0);
+
+        let collector = Collector::new();
+        let handle = collector.register();
+
+        unsafe {
+            let guard = &handle.pin();
+            for _ in 0..COUNT {
+                let a = Owned::new(7i32).into_shared(guard);
+                guard.defer_unchecked(move || {
+                    drop(a.into_owned());
+                    DESTROYS.fetch_add(1, Ordering::Relaxed);
+                });
+            }
+            guard.flush();
+        }
+
+        let mut last = 0;
+
+        while last < COUNT {
+            let curr = DESTROYS.load(Ordering::Relaxed);
+            assert!(curr - last <= 1024);
+            last = curr;
+
+            let guard = &handle.pin();
+            collector.global.collect(guard);
+        }
+        assert!(DESTROYS.load(Ordering::Relaxed) == COUNT);
+    }
+
+    #[test]
+    fn buffering() {
+        const COUNT: usize = 10;
+        #[cfg(miri)]
+        const N: usize = 500;
+        #[cfg(not(miri))]
+        const N: usize = 100_000;
+        static DESTROYS: AtomicUsize = AtomicUsize::new(0);
+
+        let collector = Collector::new();
+        let handle = collector.register();
+
+        unsafe {
+            let guard = &handle.pin();
+            for _ in 0..COUNT {
+                let a = Owned::new(7i32).into_shared(guard);
+                guard.defer_unchecked(move || {
+                    drop(a.into_owned());
+                    DESTROYS.fetch_add(1, Ordering::Relaxed);
+                });
+            }
+        }
+
+        for _ in 0..N {
+            collector.global.collect(&handle.pin());
+        }
+        assert!(DESTROYS.load(Ordering::Relaxed) < COUNT);
+
+        handle.pin().flush();
+
+        while DESTROYS.load(Ordering::Relaxed) < COUNT {
+            let guard = &handle.pin();
+            collector.global.collect(guard);
+        }
+        assert_eq!(DESTROYS.load(Ordering::Relaxed), COUNT);
+    }
+
+    #[test]
+    fn count_drops() {
+        #[cfg(miri)]
+        const COUNT: usize = 500;
+        #[cfg(not(miri))]
+        const COUNT: usize = 100_000;
+        static DROPS: AtomicUsize = AtomicUsize::new(0);
+
+        struct Elem(#[allow(dead_code)] i32);
+
+        impl Drop for Elem {
+            fn drop(&mut self) {
+                DROPS.fetch_add(1, Ordering::Relaxed);
+            }
+        }
+
+        let collector = Collector::new();
+        let handle = collector.register();
+
+        unsafe {
+            let guard = &handle.pin();
+
+            for _ in 0..COUNT {
+                let a = Owned::new(Elem(7i32)).into_shared(guard);
+                guard.defer_destroy(a);
+            }
+            guard.flush();
+        }
+
+        while DROPS.load(Ordering::Relaxed) < COUNT {
+            let guard = &handle.pin();
+            collector.global.collect(guard);
+        }
+        assert_eq!(DROPS.load(Ordering::Relaxed), COUNT);
+    }
+
+    #[test]
+    fn count_destroy() {
+        #[cfg(miri)]
+        const COUNT: usize = 500;
+        #[cfg(not(miri))]
+        const COUNT: usize = 100_000;
+        static DESTROYS: AtomicUsize = AtomicUsize::new(0);
+
+        let collector = Collector::new();
+        let handle = collector.register();
+
+        unsafe {
+            let guard = &handle.pin();
+
+            for _ in 0..COUNT {
+                let a = Owned::new(7i32).into_shared(guard);
+                guard.defer_unchecked(move || {
+                    drop(a.into_owned());
+                    DESTROYS.fetch_add(1, Ordering::Relaxed);
+                });
+            }
+            guard.flush();
+        }
+
+        while DESTROYS.load(Ordering::Relaxed) < COUNT {
+            let guard = &handle.pin();
+            collector.global.collect(guard);
+        }
+        assert_eq!(DESTROYS.load(Ordering::Relaxed), COUNT);
+    }
+
+    #[test]
+    fn drop_array() {
+        const COUNT: usize = 700;
+        static DROPS: AtomicUsize = AtomicUsize::new(0);
+
+        struct Elem(#[allow(dead_code)] i32);
+
+        impl Drop for Elem {
+            fn drop(&mut self) {
+                DROPS.fetch_add(1, Ordering::Relaxed);
+            }
+        }
+
+        let collector = Collector::new();
+        let handle = collector.register();
+
+        let mut guard = handle.pin();
+
+        let mut v = Vec::with_capacity(COUNT);
+        for i in 0..COUNT {
+            v.push(Elem(i as i32));
+        }
+
+        {
+            let a = Owned::new(v).into_shared(&guard);
+            unsafe {
+                guard.defer_destroy(a);
+            }
+            guard.flush();
+        }
+
+        while DROPS.load(Ordering::Relaxed) < COUNT {
+            guard.repin();
+            collector.global.collect(&guard);
+        }
+        assert_eq!(DROPS.load(Ordering::Relaxed), COUNT);
+    }
+
+    #[test]
+    fn destroy_array() {
+        #[cfg(miri)]
+        const COUNT: usize = 500;
+        #[cfg(not(miri))]
+        const COUNT: usize = 100_000;
+        static DESTROYS: AtomicUsize = AtomicUsize::new(0);
+
+        let collector = Collector::new();
+        let handle = collector.register();
+
+        unsafe {
+            let guard = &handle.pin();
+
+            let mut v = Vec::with_capacity(COUNT);
+            for i in 0..COUNT {
+                v.push(i as i32);
+            }
+
+            let len = v.len();
+            let cap = v.capacity();
+            let ptr = ManuallyDrop::new(v).as_mut_ptr();
+            guard.defer_unchecked(move || {
+                drop(Vec::from_raw_parts(ptr, len, cap));
+                DESTROYS.fetch_add(len, Ordering::Relaxed);
+            });
+            guard.flush();
+        }
+
+        while DESTROYS.load(Ordering::Relaxed) < COUNT {
+            let guard = &handle.pin();
+            collector.global.collect(guard);
+        }
+        assert_eq!(DESTROYS.load(Ordering::Relaxed), COUNT);
+    }
+
+    #[test]
+    fn stress() {
+        const THREADS: usize = 8;
+        #[cfg(miri)]
+        const COUNT: usize = 500;
+        #[cfg(not(miri))]
+        const COUNT: usize = 100_000;
+        static DROPS: AtomicUsize = AtomicUsize::new(0);
+
+        struct Elem(#[allow(dead_code)] i32);
+
+        impl Drop for Elem {
+            fn drop(&mut self) {
+                DROPS.fetch_add(1, Ordering::Relaxed);
+            }
+        }
+
+        let collector = Collector::new();
+
+        thread::scope(|scope| {
+            for _ in 0..THREADS {
+                scope.spawn(|_| {
+                    let handle = collector.register();
+                    for _ in 0..COUNT {
+                        let guard = &handle.pin();
+                        unsafe {
+                            let a = Owned::new(Elem(7i32)).into_shared(guard);
+                            guard.defer_destroy(a);
+                        }
+                    }
+                });
+            }
+        })
+        .unwrap();
+
+        let handle = collector.register();
+        while DROPS.load(Ordering::Relaxed) < COUNT * THREADS {
+            let guard = &handle.pin();
+            collector.global.collect(guard);
+        }
+        assert_eq!(DROPS.load(Ordering::Relaxed), COUNT * THREADS);
+    }
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-epoch-0.9.18/src/default.rs

@@ -0,0 +1,93 @@
+//! The default garbage collector.
+//!
+//! For each thread, a participant is lazily initialized on its first use, when the current thread
+//! is registered in the default collector.  If initialized, the thread's participant will get
+//! destructed on thread exit, which in turn unregisters the thread.
+
+use crate::collector::{Collector, LocalHandle};
+use crate::guard::Guard;
+use crate::primitive::thread_local;
+#[cfg(not(crossbeam_loom))]
+use crate::sync::once_lock::OnceLock;
+
+fn collector() -> &'static Collector {
+    #[cfg(not(crossbeam_loom))]
+    {
+        /// The global data for the default garbage collector.
+        static COLLECTOR: OnceLock<Collector> = OnceLock::new();
+        COLLECTOR.get_or_init(Collector::new)
+    }
+    // FIXME: loom does not currently provide the equivalent of Lazy:
+    // https://github.com/tokio-rs/loom/issues/263
+    #[cfg(crossbeam_loom)]
+    {
+        loom::lazy_static! {
+            /// The global data for the default garbage collector.
+            static ref COLLECTOR: Collector = Collector::new();
+        }
+        &COLLECTOR
+    }
+}
+
+thread_local! {
+    /// The per-thread participant for the default garbage collector.
+    static HANDLE: LocalHandle = collector().register();
+}
+
+/// Pins the current thread.
+#[inline]
+pub fn pin() -> Guard {
+    with_handle(|handle| handle.pin())
+}
+
+/// Returns `true` if the current thread is pinned.
+#[inline]
+pub fn is_pinned() -> bool {
+    with_handle(|handle| handle.is_pinned())
+}
+
+/// Returns the default global collector.
+pub fn default_collector() -> &'static Collector {
+    collector()
+}
+
+#[inline]
+fn with_handle<F, R>(mut f: F) -> R
+where
+    F: FnMut(&LocalHandle) -> R,
+{
+    HANDLE
+        .try_with(|h| f(h))
+        .unwrap_or_else(|_| f(&collector().register()))
+}
+
+#[cfg(all(test, not(crossbeam_loom)))]
+mod tests {
+    use crossbeam_utils::thread;
+
+    #[test]
+    fn pin_while_exiting() {
+        struct Foo;
+
+        impl Drop for Foo {
+            fn drop(&mut self) {
+                // Pin after `HANDLE` has been dropped. This must not panic.
+                super::pin();
+            }
+        }
+
+        thread_local! {
+            static FOO: Foo = const { Foo };
+        }
+
+        thread::scope(|scope| {
+            scope.spawn(|_| {
+                // Initialize `FOO` and then `HANDLE`.
+                FOO.with(|_| ());
+                super::pin();
+                // At thread exit, `HANDLE` gets dropped first and `FOO` second.
+            });
+        })
+        .unwrap();
+    }
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-epoch-0.9.18/src/deferred.rs

@@ -0,0 +1,146 @@
+use alloc::boxed::Box;
+use core::fmt;
+use core::marker::PhantomData;
+use core::mem::{self, MaybeUninit};
+use core::ptr;
+
+/// Number of words a piece of `Data` can hold.
+///
+/// Three words should be enough for the majority of cases. For example, you can fit inside it the
+/// function pointer together with a fat pointer representing an object that needs to be destroyed.
+const DATA_WORDS: usize = 3;
+
+/// Some space to keep a `FnOnce()` object on the stack.
+type Data = [usize; DATA_WORDS];
+
+/// A `FnOnce()` that is stored inline if small, or otherwise boxed on the heap.
+///
+/// This is a handy way of keeping an unsized `FnOnce()` within a sized structure.
+pub(crate) struct Deferred {
+    call: unsafe fn(*mut u8),
+    data: MaybeUninit<Data>,
+    _marker: PhantomData<*mut ()>, // !Send + !Sync
+}
+
+impl fmt::Debug for Deferred {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+        f.pad("Deferred { .. }")
+    }
+}
+
+impl Deferred {
+    pub(crate) const NO_OP: Self = {
+        fn no_op_call(_raw: *mut u8) {}
+        Self {
+            call: no_op_call,
+            data: MaybeUninit::uninit(),
+            _marker: PhantomData,
+        }
+    };
+
+    /// Constructs a new `Deferred` from a `FnOnce()`.
+    pub(crate) fn new<F: FnOnce()>(f: F) -> Self {
+        let size = mem::size_of::<F>();
+        let align = mem::align_of::<F>();
+
+        unsafe {
+            if size <= mem::size_of::<Data>() && align <= mem::align_of::<Data>() {
+                let mut data = MaybeUninit::<Data>::uninit();
+                ptr::write(data.as_mut_ptr().cast::<F>(), f);
+
+                unsafe fn call<F: FnOnce()>(raw: *mut u8) {
+                    let f: F = ptr::read(raw.cast::<F>());
+                    f();
+                }
+
+                Deferred {
+                    call: call::<F>,
+                    data,
+                    _marker: PhantomData,
+                }
+            } else {
+                let b: Box<F> = Box::new(f);
+                let mut data = MaybeUninit::<Data>::uninit();
+                ptr::write(data.as_mut_ptr().cast::<Box<F>>(), b);
+
+                unsafe fn call<F: FnOnce()>(raw: *mut u8) {
+                    // It's safe to cast `raw` from `*mut u8` to `*mut Box<F>`, because `raw` is
+                    // originally derived from `*mut Box<F>`.
+                    let b: Box<F> = ptr::read(raw.cast::<Box<F>>());
+                    (*b)();
+                }
+
+                Deferred {
+                    call: call::<F>,
+                    data,
+                    _marker: PhantomData,
+                }
+            }
+        }
+    }
+
+    /// Calls the function.
+    #[inline]
+    pub(crate) fn call(mut self) {
+        let call = self.call;
+        unsafe { call(self.data.as_mut_ptr().cast::<u8>()) };
+    }
+}
+
+#[cfg(all(test, not(crossbeam_loom)))]
+mod tests {
+    use super::Deferred;
+    use std::cell::Cell;
+    use std::convert::identity;
+
+    #[test]
+    fn on_stack() {
+        let fired = &Cell::new(false);
+        let a = [0usize; 1];
+
+        let d = Deferred::new(move || {
+            let _ = identity(a);
+            fired.set(true);
+        });
+
+        assert!(!fired.get());
+        d.call();
+        assert!(fired.get());
+    }
+
+    #[test]
+    fn on_heap() {
+        let fired = &Cell::new(false);
+        let a = [0usize; 10];
+
+        let d = Deferred::new(move || {
+            let _ = identity(a);
+            fired.set(true);
+        });
+
+        assert!(!fired.get());
+        d.call();
+        assert!(fired.get());
+    }
+
+    #[test]
+    fn string() {
+        let a = "hello".to_string();
+        let d = Deferred::new(move || assert_eq!(a, "hello"));
+        d.call();
+    }
+
+    #[test]
+    fn boxed_slice_i32() {
+        let a: Box<[i32]> = vec![2, 3, 5, 7].into_boxed_slice();
+        let d = Deferred::new(move || assert_eq!(*a, [2, 3, 5, 7]));
+        d.call();
+    }
+
+    #[test]
+    fn long_slice_usize() {
+        let a: [usize; 5] = [2, 3, 5, 7, 11];
+        let d = Deferred::new(move || assert_eq!(a, [2, 3, 5, 7, 11]));
+        d.call();
+    }
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-epoch-0.9.18/src/epoch.rs

@@ -0,0 +1,132 @@
+//! The global epoch
+//!
+//! The last bit in this number is unused and is always zero. Every so often the global epoch is
+//! incremented, i.e. we say it "advances". A pinned participant may advance the global epoch only
+//! if all currently pinned participants have been pinned in the current epoch.
+//!
+//! If an object became garbage in some epoch, then we can be sure that after two advancements no
+//! participant will hold a reference to it. That is the crux of safe memory reclamation.
+
+use crate::primitive::sync::atomic::{AtomicUsize, Ordering};
+
+/// An epoch that can be marked as pinned or unpinned.
+///
+/// Internally, the epoch is represented as an integer that wraps around at some unspecified point
+/// and a flag that represents whether it is pinned or unpinned.
+#[derive(Copy, Clone, Default, Debug, Eq, PartialEq)]
+pub(crate) struct Epoch {
+    /// The least significant bit is set if pinned. The rest of the bits hold the epoch.
+    data: usize,
+}
+
+impl Epoch {
+    /// Returns the starting epoch in unpinned state.
+    #[inline]
+    pub(crate) fn starting() -> Self {
+        Self::default()
+    }
+
+    /// Returns the number of epochs `self` is ahead of `rhs`.
+    ///
+    /// Internally, epochs are represented as numbers in the range `(isize::MIN / 2) .. (isize::MAX
+    /// / 2)`, so the returned distance will be in the same interval.
+    pub(crate) fn wrapping_sub(self, rhs: Self) -> isize {
+        // The result is the same with `(self.data & !1).wrapping_sub(rhs.data & !1) as isize >> 1`,
+        // because the possible difference of LSB in `(self.data & !1).wrapping_sub(rhs.data & !1)`
+        // will be ignored in the shift operation.
+        self.data.wrapping_sub(rhs.data & !1) as isize >> 1
+    }
+
+    /// Returns `true` if the epoch is marked as pinned.
+    #[inline]
+    pub(crate) fn is_pinned(self) -> bool {
+        (self.data & 1) == 1
+    }
+
+    /// Returns the same epoch, but marked as pinned.
+    #[inline]
+    pub(crate) fn pinned(self) -> Epoch {
+        Epoch {
+            data: self.data | 1,
+        }
+    }
+
+    /// Returns the same epoch, but marked as unpinned.
+    #[inline]
+    pub(crate) fn unpinned(self) -> Epoch {
+        Epoch {
+            data: self.data & !1,
+        }
+    }
+
+    /// Returns the successor epoch.
+    ///
+    /// The returned epoch will be marked as pinned only if the previous one was as well.
+    #[inline]
+    pub(crate) fn successor(self) -> Epoch {
+        Epoch {
+            data: self.data.wrapping_add(2),
+        }
+    }
+}
+
+/// An atomic value that holds an `Epoch`.
+#[derive(Default, Debug)]
+pub(crate) struct AtomicEpoch {
+    /// Since `Epoch` is just a wrapper around `usize`, an `AtomicEpoch` is similarly represented
+    /// using an `AtomicUsize`.
+    data: AtomicUsize,
+}
+
+impl AtomicEpoch {
+    /// Creates a new atomic epoch.
+    #[inline]
+    pub(crate) fn new(epoch: Epoch) -> Self {
+        let data = AtomicUsize::new(epoch.data);
+        AtomicEpoch { data }
+    }
+
+    /// Loads a value from the atomic epoch.
+    #[inline]
+    pub(crate) fn load(&self, ord: Ordering) -> Epoch {
+        Epoch {
+            data: self.data.load(ord),
+        }
+    }
+
+    /// Stores a value into the atomic epoch.
+    #[inline]
+    pub(crate) fn store(&self, epoch: Epoch, ord: Ordering) {
+        self.data.store(epoch.data, ord);
+    }
+
+    /// Stores a value into the atomic epoch if the current value is the same as `current`.
+    ///
+    /// The return value is a result indicating whether the new value was written and containing
+    /// the previous value. On success this value is guaranteed to be equal to `current`.
+    ///
+    /// This method takes two `Ordering` arguments to describe the memory
+    /// ordering of this operation. `success` describes the required ordering for the
+    /// read-modify-write operation that takes place if the comparison with `current` succeeds.
+    /// `failure` describes the required ordering for the load operation that takes place when
+    /// the comparison fails. Using `Acquire` as success ordering makes the store part
+    /// of this operation `Relaxed`, and using `Release` makes the successful load
+    /// `Relaxed`. The failure ordering can only be `SeqCst`, `Acquire` or `Relaxed`
+    /// and must be equivalent to or weaker than the success ordering.
+    #[inline]
+    pub(crate) fn compare_exchange(
+        &self,
+        current: Epoch,
+        new: Epoch,
+        success: Ordering,
+        failure: Ordering,
+    ) -> Result<Epoch, Epoch> {
+        match self
+            .data
+            .compare_exchange(current.data, new.data, success, failure)
+        {
+            Ok(data) => Ok(Epoch { data }),
+            Err(data) => Err(Epoch { data }),
+        }
+    }
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-epoch-0.9.18/src/guard.rs

@@ -0,0 +1,523 @@
+use core::fmt;
+use core::mem;
+
+use crate::atomic::Shared;
+use crate::collector::Collector;
+use crate::deferred::Deferred;
+use crate::internal::Local;
+
+/// A guard that keeps the current thread pinned.
+///
+/// # Pinning
+///
+/// The current thread is pinned by calling [`pin`], which returns a new guard:
+///
+/// ```
+/// use crossbeam_epoch as epoch;
+///
+/// // It is often convenient to prefix a call to `pin` with a `&` in order to create a reference.
+/// // This is not really necessary, but makes passing references to the guard a bit easier.
+/// let guard = &epoch::pin();
+/// ```
+///
+/// When a guard gets dropped, the current thread is automatically unpinned.
+///
+/// # Pointers on the stack
+///
+/// Having a guard allows us to create pointers on the stack to heap-allocated objects.
+/// For example:
+///
+/// ```
+/// use crossbeam_epoch::{self as epoch, Atomic};
+/// use std::sync::atomic::Ordering::SeqCst;
+///
+/// // Create a heap-allocated number.
+/// let a = Atomic::new(777);
+///
+/// // Pin the current thread.
+/// let guard = &epoch::pin();
+///
+/// // Load the heap-allocated object and create pointer `p` on the stack.
+/// let p = a.load(SeqCst, guard);
+///
+/// // Dereference the pointer and print the value:
+/// if let Some(num) = unsafe { p.as_ref() } {
+///     println!("The number is {}.", num);
+/// }
+/// # unsafe { drop(a.into_owned()); } // avoid leak
+/// ```
+///
+/// # Multiple guards
+///
+/// Pinning is reentrant and it is perfectly legal to create multiple guards. In that case, the
+/// thread will actually be pinned only when the first guard is created and unpinned when the last
+/// one is dropped:
+///
+/// ```
+/// use crossbeam_epoch as epoch;
+///
+/// let guard1 = epoch::pin();
+/// let guard2 = epoch::pin();
+/// assert!(epoch::is_pinned());
+/// drop(guard1);
+/// assert!(epoch::is_pinned());
+/// drop(guard2);
+/// assert!(!epoch::is_pinned());
+/// ```
+///
+/// [`pin`]: super::pin
+pub struct Guard {
+    pub(crate) local: *const Local,
+}
+
+impl Guard {
+    /// Stores a function so that it can be executed at some point after all currently pinned
+    /// threads get unpinned.
+    ///
+    /// This method first stores `f` into the thread-local (or handle-local) cache. If this cache
+    /// becomes full, some functions are moved into the global cache. At the same time, some
+    /// functions from both local and global caches may get executed in order to incrementally
+    /// clean up the caches as they fill up.
+    ///
+    /// There is no guarantee when exactly `f` will be executed. The only guarantee is that it
+    /// won't be executed until all currently pinned threads get unpinned. In theory, `f` might
+    /// never run, but the epoch-based garbage collection will make an effort to execute it
+    /// reasonably soon.
+    ///
+    /// If this method is called from an [`unprotected`] guard, the function will simply be
+    /// executed immediately.
+    pub fn defer<F, R>(&self, f: F)
+    where
+        F: FnOnce() -> R,
+        F: Send + 'static,
+    {
+        unsafe {
+            self.defer_unchecked(f);
+        }
+    }
+
+    /// Stores a function so that it can be executed at some point after all currently pinned
+    /// threads get unpinned.
+    ///
+    /// This method first stores `f` into the thread-local (or handle-local) cache. If this cache
+    /// becomes full, some functions are moved into the global cache. At the same time, some
+    /// functions from both local and global caches may get executed in order to incrementally
+    /// clean up the caches as they fill up.
+    ///
+    /// There is no guarantee when exactly `f` will be executed. The only guarantee is that it
+    /// won't be executed until all currently pinned threads get unpinned. In theory, `f` might
+    /// never run, but the epoch-based garbage collection will make an effort to execute it
+    /// reasonably soon.
+    ///
+    /// If this method is called from an [`unprotected`] guard, the function will simply be
+    /// executed immediately.
+    ///
+    /// # Safety
+    ///
+    /// The given function must not hold reference onto the stack. It is highly recommended that
+    /// the passed function is **always** marked with `move` in order to prevent accidental
+    /// borrows.
+    ///
+    /// ```
+    /// use crossbeam_epoch as epoch;
+    ///
+    /// let guard = &epoch::pin();
+    /// let message = "Hello!";
+    /// unsafe {
+    ///     // ALWAYS use `move` when sending a closure into `defer_unchecked`.
+    ///     guard.defer_unchecked(move || {
+    ///         println!("{}", message);
+    ///     });
+    /// }
+    /// ```
+    ///
+    /// Apart from that, keep in mind that another thread may execute `f`, so anything accessed by
+    /// the closure must be `Send`.
+    ///
+    /// We intentionally didn't require `F: Send`, because Rust's type systems usually cannot prove
+    /// `F: Send` for typical use cases. For example, consider the following code snippet, which
+    /// exemplifies the typical use case of deferring the deallocation of a shared reference:
+    ///
+    /// ```ignore
+    /// let shared = Owned::new(7i32).into_shared(guard);
+    /// guard.defer_unchecked(move || shared.into_owned()); // `Shared` is not `Send`!
+    /// ```
+    ///
+    /// While `Shared` is not `Send`, it's safe for another thread to call the deferred function,
+    /// because it's called only after the grace period and `shared` is no longer shared with other
+    /// threads. But we don't expect type systems to prove this.
+    ///
+    /// # Examples
+    ///
+    /// When a heap-allocated object in a data structure becomes unreachable, it has to be
+    /// deallocated. However, the current thread and other threads may be still holding references
+    /// on the stack to that same object. Therefore it cannot be deallocated before those references
+    /// get dropped. This method can defer deallocation until all those threads get unpinned and
+    /// consequently drop all their references on the stack.
+    ///
+    /// ```
+    /// use crossbeam_epoch::{self as epoch, Atomic, Owned};
+    /// use std::sync::atomic::Ordering::SeqCst;
+    ///
+    /// let a = Atomic::new("foo");
+    ///
+    /// // Now suppose that `a` is shared among multiple threads and concurrently
+    /// // accessed and modified...
+    ///
+    /// // Pin the current thread.
+    /// let guard = &epoch::pin();
+    ///
+    /// // Steal the object currently stored in `a` and swap it with another one.
+    /// let p = a.swap(Owned::new("bar").into_shared(guard), SeqCst, guard);
+    ///
+    /// if !p.is_null() {
+    ///     // The object `p` is pointing to is now unreachable.
+    ///     // Defer its deallocation until all currently pinned threads get unpinned.
+    ///     unsafe {
+    ///         // ALWAYS use `move` when sending a closure into `defer_unchecked`.
+    ///         guard.defer_unchecked(move || {
+    ///             println!("{} is now being deallocated.", p.deref());
+    ///             // Now we have unique access to the object pointed to by `p` and can turn it
+    ///             // into an `Owned`. Dropping the `Owned` will deallocate the object.
+    ///             drop(p.into_owned());
+    ///         });
+    ///     }
+    /// }
+    /// # unsafe { drop(a.into_owned()); } // avoid leak
+    /// ```
+    pub unsafe fn defer_unchecked<F, R>(&self, f: F)
+    where
+        F: FnOnce() -> R,
+    {
+        if let Some(local) = self.local.as_ref() {
+            local.defer(Deferred::new(move || drop(f())), self);
+        } else {
+            drop(f());
+        }
+    }
+
+    /// Stores a destructor for an object so that it can be deallocated and dropped at some point
+    /// after all currently pinned threads get unpinned.
+    ///
+    /// This method first stores the destructor into the thread-local (or handle-local) cache. If
+    /// this cache becomes full, some destructors are moved into the global cache. At the same
+    /// time, some destructors from both local and global caches may get executed in order to
+    /// incrementally clean up the caches as they fill up.
+    ///
+    /// There is no guarantee when exactly the destructor will be executed. The only guarantee is
+    /// that it won't be executed until all currently pinned threads get unpinned. In theory, the
+    /// destructor might never run, but the epoch-based garbage collection will make an effort to
+    /// execute it reasonably soon.
+    ///
+    /// If this method is called from an [`unprotected`] guard, the destructor will simply be
+    /// executed immediately.
+    ///
+    /// # Safety
+    ///
+    /// The object must not be reachable by other threads anymore, otherwise it might be still in
+    /// use when the destructor runs.
+    ///
+    /// Apart from that, keep in mind that another thread may execute the destructor, so the object
+    /// must be sendable to other threads.
+    ///
+    /// We intentionally didn't require `T: Send`, because Rust's type systems usually cannot prove
+    /// `T: Send` for typical use cases. For example, consider the following code snippet, which
+    /// exemplifies the typical use case of deferring the deallocation of a shared reference:
+    ///
+    /// ```ignore
+    /// let shared = Owned::new(7i32).into_shared(guard);
+    /// guard.defer_destroy(shared); // `Shared` is not `Send`!
+    /// ```
+    ///
+    /// While `Shared` is not `Send`, it's safe for another thread to call the destructor, because
+    /// it's called only after the grace period and `shared` is no longer shared with other
+    /// threads. But we don't expect type systems to prove this.
+    ///
+    /// # Examples
+    ///
+    /// When a heap-allocated object in a data structure becomes unreachable, it has to be
+    /// deallocated. However, the current thread and other threads may be still holding references
+    /// on the stack to that same object. Therefore it cannot be deallocated before those references
+    /// get dropped. This method can defer deallocation until all those threads get unpinned and
+    /// consequently drop all their references on the stack.
+    ///
+    /// ```
+    /// use crossbeam_epoch::{self as epoch, Atomic, Owned};
+    /// use std::sync::atomic::Ordering::SeqCst;
+    ///
+    /// let a = Atomic::new("foo");
+    ///
+    /// // Now suppose that `a` is shared among multiple threads and concurrently
+    /// // accessed and modified...
+    ///
+    /// // Pin the current thread.
+    /// let guard = &epoch::pin();
+    ///
+    /// // Steal the object currently stored in `a` and swap it with another one.
+    /// let p = a.swap(Owned::new("bar").into_shared(guard), SeqCst, guard);
+    ///
+    /// if !p.is_null() {
+    ///     // The object `p` is pointing to is now unreachable.
+    ///     // Defer its deallocation until all currently pinned threads get unpinned.
+    ///     unsafe {
+    ///         guard.defer_destroy(p);
+    ///     }
+    /// }
+    /// # unsafe { drop(a.into_owned()); } // avoid leak
+    /// ```
+    pub unsafe fn defer_destroy<T>(&self, ptr: Shared<'_, T>) {
+        self.defer_unchecked(move || ptr.into_owned());
+    }
+
+    /// Clears up the thread-local cache of deferred functions by executing them or moving into the
+    /// global cache.
+    ///
+    /// Call this method after deferring execution of a function if you want to get it executed as
+    /// soon as possible. Flushing will make sure it is residing in in the global cache, so that
+    /// any thread has a chance of taking the function and executing it.
+    ///
+    /// If this method is called from an [`unprotected`] guard, it is a no-op (nothing happens).
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use crossbeam_epoch as epoch;
+    ///
+    /// let guard = &epoch::pin();
+    /// guard.defer(move || {
+    ///     println!("This better be printed as soon as possible!");
+    /// });
+    /// guard.flush();
+    /// ```
+    pub fn flush(&self) {
+        if let Some(local) = unsafe { self.local.as_ref() } {
+            local.flush(self);
+        }
+    }
+
+    /// Unpins and then immediately re-pins the thread.
+    ///
+    /// This method is useful when you don't want delay the advancement of the global epoch by
+    /// holding an old epoch. For safety, you should not maintain any guard-based reference across
+    /// the call (the latter is enforced by `&mut self`). The thread will only be repinned if this
+    /// is the only active guard for the current thread.
+    ///
+    /// If this method is called from an [`unprotected`] guard, then the call will be just no-op.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use crossbeam_epoch::{self as epoch, Atomic};
+    /// use std::sync::atomic::Ordering::SeqCst;
+    ///
+    /// let a = Atomic::new(777);
+    /// let mut guard = epoch::pin();
+    /// {
+    ///     let p = a.load(SeqCst, &guard);
+    ///     assert_eq!(unsafe { p.as_ref() }, Some(&777));
+    /// }
+    /// guard.repin();
+    /// {
+    ///     let p = a.load(SeqCst, &guard);
+    ///     assert_eq!(unsafe { p.as_ref() }, Some(&777));
+    /// }
+    /// # unsafe { drop(a.into_owned()); } // avoid leak
+    /// ```
+    pub fn repin(&mut self) {
+        if let Some(local) = unsafe { self.local.as_ref() } {
+            local.repin();
+        }
+    }
+
+    /// Temporarily unpins the thread, executes the given function and then re-pins the thread.
+    ///
+    /// This method is useful when you need to perform a long-running operation (e.g. sleeping)
+    /// and don't need to maintain any guard-based reference across the call (the latter is enforced
+    /// by `&mut self`). The thread will only be unpinned if this is the only active guard for the
+    /// current thread.
+    ///
+    /// If this method is called from an [`unprotected`] guard, then the passed function is called
+    /// directly without unpinning the thread.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use crossbeam_epoch::{self as epoch, Atomic};
+    /// use std::sync::atomic::Ordering::SeqCst;
+    /// use std::thread;
+    /// use std::time::Duration;
+    ///
+    /// let a = Atomic::new(777);
+    /// let mut guard = epoch::pin();
+    /// {
+    ///     let p = a.load(SeqCst, &guard);
+    ///     assert_eq!(unsafe { p.as_ref() }, Some(&777));
+    /// }
+    /// guard.repin_after(|| thread::sleep(Duration::from_millis(50)));
+    /// {
+    ///     let p = a.load(SeqCst, &guard);
+    ///     assert_eq!(unsafe { p.as_ref() }, Some(&777));
+    /// }
+    /// # unsafe { drop(a.into_owned()); } // avoid leak
+    /// ```
+    pub fn repin_after<F, R>(&mut self, f: F) -> R
+    where
+        F: FnOnce() -> R,
+    {
+        // Ensure the Guard is re-pinned even if the function panics
+        struct ScopeGuard(*const Local);
+        impl Drop for ScopeGuard {
+            fn drop(&mut self) {
+                if let Some(local) = unsafe { self.0.as_ref() } {
+                    mem::forget(local.pin());
+                    local.release_handle();
+                }
+            }
+        }
+
+        if let Some(local) = unsafe { self.local.as_ref() } {
+            // We need to acquire a handle here to ensure the Local doesn't
+            // disappear from under us.
+            local.acquire_handle();
+            local.unpin();
+        }
+
+        let _guard = ScopeGuard(self.local);
+
+        f()
+    }
+
+    /// Returns the `Collector` associated with this guard.
+    ///
+    /// This method is useful when you need to ensure that all guards used with
+    /// a data structure come from the same collector.
+    ///
+    /// If this method is called from an [`unprotected`] guard, then `None` is returned.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use crossbeam_epoch as epoch;
+    ///
+    /// let guard1 = epoch::pin();
+    /// let guard2 = epoch::pin();
+    /// assert!(guard1.collector() == guard2.collector());
+    /// ```
+    pub fn collector(&self) -> Option<&Collector> {
+        unsafe { self.local.as_ref().map(|local| local.collector()) }
+    }
+}
+
+impl Drop for Guard {
+    #[inline]
+    fn drop(&mut self) {
+        if let Some(local) = unsafe { self.local.as_ref() } {
+            local.unpin();
+        }
+    }
+}
+
+impl fmt::Debug for Guard {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.pad("Guard { .. }")
+    }
+}
+
+/// Returns a reference to a dummy guard that allows unprotected access to [`Atomic`]s.
+///
+/// This guard should be used in special occasions only. Note that it doesn't actually keep any
+/// thread pinned - it's just a fake guard that allows loading from [`Atomic`]s unsafely.
+///
+/// Note that calling [`defer`] with a dummy guard will not defer the function - it will just
+/// execute the function immediately.
+///
+/// If necessary, it's possible to create more dummy guards by cloning: `unprotected().clone()`.
+///
+/// # Safety
+///
+/// Loading and dereferencing data from an [`Atomic`] using this guard is safe only if the
+/// [`Atomic`] is not being concurrently modified by other threads.
+///
+/// # Examples
+///
+/// ```
+/// use crossbeam_epoch::{self as epoch, Atomic};
+/// use std::sync::atomic::Ordering::Relaxed;
+///
+/// let a = Atomic::new(7);
+///
+/// unsafe {
+///     // Load `a` without pinning the current thread.
+///     a.load(Relaxed, epoch::unprotected());
+///
+///     // It's possible to create more dummy guards.
+///     let dummy = epoch::unprotected();
+///
+///     dummy.defer(move || {
+///         println!("This gets executed immediately.");
+///     });
+///
+///     // Dropping `dummy` doesn't affect the current thread - it's just a noop.
+/// }
+/// # unsafe { drop(a.into_owned()); } // avoid leak
+/// ```
+///
+/// The most common use of this function is when constructing or destructing a data structure.
+///
+/// For example, we can use a dummy guard in the destructor of a Treiber stack because at that
+/// point no other thread could concurrently modify the [`Atomic`]s we are accessing.
+///
+/// If we were to actually pin the current thread during destruction, that would just unnecessarily
+/// delay garbage collection and incur some performance cost, so in cases like these `unprotected`
+/// is very helpful.
+///
+/// ```
+/// use crossbeam_epoch::{self as epoch, Atomic};
+/// use std::mem::ManuallyDrop;
+/// use std::sync::atomic::Ordering::Relaxed;
+///
+/// struct Stack<T> {
+///     head: Atomic<Node<T>>,
+/// }
+///
+/// struct Node<T> {
+///     data: ManuallyDrop<T>,
+///     next: Atomic<Node<T>>,
+/// }
+///
+/// impl<T> Drop for Stack<T> {
+///     fn drop(&mut self) {
+///         unsafe {
+///             // Unprotected load.
+///             let mut node = self.head.load(Relaxed, epoch::unprotected());
+///
+///             while let Some(n) = node.as_ref() {
+///                 // Unprotected load.
+///                 let next = n.next.load(Relaxed, epoch::unprotected());
+///
+///                 // Take ownership of the node, then drop its data and deallocate it.
+///                 let mut o = node.into_owned();
+///                 ManuallyDrop::drop(&mut o.data);
+///                 drop(o);
+///
+///                 node = next;
+///             }
+///         }
+///     }
+/// }
+/// ```
+///
+/// [`Atomic`]: super::Atomic
+/// [`defer`]: Guard::defer
+#[inline]
+pub unsafe fn unprotected() -> &'static Guard {
+    // An unprotected guard is just a `Guard` with its field `local` set to null.
+    // We make a newtype over `Guard` because `Guard` isn't `Sync`, so can't be directly stored in
+    // a `static`
+    struct GuardWrapper(Guard);
+    unsafe impl Sync for GuardWrapper {}
+    static UNPROTECTED: GuardWrapper = GuardWrapper(Guard {
+        local: core::ptr::null(),
+    });
+    &UNPROTECTED.0
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-epoch-0.9.18/src/internal.rs

@@ -0,0 +1,600 @@
+//! The global data and participant for garbage collection.
+//!
+//! # Registration
+//!
+//! In order to track all participants in one place, we need some form of participant
+//! registration. When a participant is created, it is registered to a global lock-free
+//! singly-linked list of registries; and when a participant is leaving, it is unregistered from the
+//! list.
+//!
+//! # Pinning
+//!
+//! Every participant contains an integer that tells whether the participant is pinned and if so,
+//! what was the global epoch at the time it was pinned. Participants also hold a pin counter that
+//! aids in periodic global epoch advancement.
+//!
+//! When a participant is pinned, a `Guard` is returned as a witness that the participant is pinned.
+//! Guards are necessary for performing atomic operations, and for freeing/dropping locations.
+//!
+//! # Thread-local bag
+//!
+//! Objects that get unlinked from concurrent data structures must be stashed away until the global
+//! epoch sufficiently advances so that they become safe for destruction. Pointers to such objects
+//! are pushed into a thread-local bag, and when it becomes full, the bag is marked with the current
+//! global epoch and pushed into the global queue of bags. We store objects in thread-local storages
+//! for amortizing the synchronization cost of pushing the garbages to a global queue.
+//!
+//! # Global queue
+//!
+//! Whenever a bag is pushed into a queue, the objects in some bags in the queue are collected and
+//! destroyed along the way. This design reduces contention on data structures. The global queue
+//! cannot be explicitly accessed: the only way to interact with it is by calling functions
+//! `defer()` that adds an object to the thread-local bag, or `collect()` that manually triggers
+//! garbage collection.
+//!
+//! Ideally each instance of concurrent data structure may have its own queue that gets fully
+//! destroyed as soon as the data structure gets dropped.
+
+use crate::primitive::cell::UnsafeCell;
+use crate::primitive::sync::atomic::{self, Ordering};
+use core::cell::Cell;
+use core::mem::{self, ManuallyDrop};
+use core::num::Wrapping;
+use core::{fmt, ptr};
+
+use crossbeam_utils::CachePadded;
+
+use crate::atomic::{Owned, Shared};
+use crate::collector::{Collector, LocalHandle};
+use crate::deferred::Deferred;
+use crate::epoch::{AtomicEpoch, Epoch};
+use crate::guard::{unprotected, Guard};
+use crate::sync::list::{Entry, IsElement, IterError, List};
+use crate::sync::queue::Queue;
+
+/// Maximum number of objects a bag can contain.
+#[cfg(not(any(crossbeam_sanitize, miri)))]
+const MAX_OBJECTS: usize = 64;
+// Makes it more likely to trigger any potential data races.
+#[cfg(any(crossbeam_sanitize, miri))]
+const MAX_OBJECTS: usize = 4;
+
+/// A bag of deferred functions.
+pub(crate) struct Bag {
+    /// Stashed objects.
+    deferreds: [Deferred; MAX_OBJECTS],
+    len: usize,
+}
+
+/// `Bag::try_push()` requires that it is safe for another thread to execute the given functions.
+unsafe impl Send for Bag {}
+
+impl Bag {
+    /// Returns a new, empty bag.
+    pub(crate) fn new() -> Self {
+        Self::default()
+    }
+
+    /// Returns `true` if the bag is empty.
+    pub(crate) fn is_empty(&self) -> bool {
+        self.len == 0
+    }
+
+    /// Attempts to insert a deferred function into the bag.
+    ///
+    /// Returns `Ok(())` if successful, and `Err(deferred)` for the given `deferred` if the bag is
+    /// full.
+    ///
+    /// # Safety
+    ///
+    /// It should be safe for another thread to execute the given function.
+    pub(crate) unsafe fn try_push(&mut self, deferred: Deferred) -> Result<(), Deferred> {
+        if self.len < MAX_OBJECTS {
+            self.deferreds[self.len] = deferred;
+            self.len += 1;
+            Ok(())
+        } else {
+            Err(deferred)
+        }
+    }
+
+    /// Seals the bag with the given epoch.
+    fn seal(self, epoch: Epoch) -> SealedBag {
+        SealedBag { epoch, _bag: self }
+    }
+}
+
+impl Default for Bag {
+    fn default() -> Self {
+        Bag {
+            len: 0,
+            deferreds: [Deferred::NO_OP; MAX_OBJECTS],
+        }
+    }
+}
+
+impl Drop for Bag {
+    fn drop(&mut self) {
+        // Call all deferred functions.
+        for deferred in &mut self.deferreds[..self.len] {
+            let no_op = Deferred::NO_OP;
+            let owned_deferred = mem::replace(deferred, no_op);
+            owned_deferred.call();
+        }
+    }
+}
+
+// can't #[derive(Debug)] because Debug is not implemented for arrays 64 items long
+impl fmt::Debug for Bag {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Bag")
+            .field("deferreds", &&self.deferreds[..self.len])
+            .finish()
+    }
+}
+
+/// A pair of an epoch and a bag.
+#[derive(Default, Debug)]
+struct SealedBag {
+    epoch: Epoch,
+    _bag: Bag,
+}
+
+/// It is safe to share `SealedBag` because `is_expired` only inspects the epoch.
+unsafe impl Sync for SealedBag {}
+
+impl SealedBag {
+    /// Checks if it is safe to drop the bag w.r.t. the given global epoch.
+    fn is_expired(&self, global_epoch: Epoch) -> bool {
+        // A pinned participant can witness at most one epoch advancement. Therefore, any bag that
+        // is within one epoch of the current one cannot be destroyed yet.
+        global_epoch.wrapping_sub(self.epoch) >= 2
+    }
+}
+
+/// The global data for a garbage collector.
+pub(crate) struct Global {
+    /// The intrusive linked list of `Local`s.
+    locals: List<Local>,
+
+    /// The global queue of bags of deferred functions.
+    queue: Queue<SealedBag>,
+
+    /// The global epoch.
+    pub(crate) epoch: CachePadded<AtomicEpoch>,
+}
+
+impl Global {
+    /// Number of bags to destroy.
+    const COLLECT_STEPS: usize = 8;
+
+    /// Creates a new global data for garbage collection.
+    #[inline]
+    pub(crate) fn new() -> Self {
+        Self {
+            locals: List::new(),
+            queue: Queue::new(),
+            epoch: CachePadded::new(AtomicEpoch::new(Epoch::starting())),
+        }
+    }
+
+    /// Pushes the bag into the global queue and replaces the bag with a new empty bag.
+    pub(crate) fn push_bag(&self, bag: &mut Bag, guard: &Guard) {
+        let bag = mem::replace(bag, Bag::new());
+
+        atomic::fence(Ordering::SeqCst);
+
+        let epoch = self.epoch.load(Ordering::Relaxed);
+        self.queue.push(bag.seal(epoch), guard);
+    }
+
+    /// Collects several bags from the global queue and executes deferred functions in them.
+    ///
+    /// Note: This may itself produce garbage and in turn allocate new bags.
+    ///
+    /// `pin()` rarely calls `collect()`, so we want the compiler to place that call on a cold
+    /// path. In other words, we want the compiler to optimize branching for the case when
+    /// `collect()` is not called.
+    #[cold]
+    pub(crate) fn collect(&self, guard: &Guard) {
+        let global_epoch = self.try_advance(guard);
+
+        let steps = if cfg!(crossbeam_sanitize) {
+            usize::max_value()
+        } else {
+            Self::COLLECT_STEPS
+        };
+
+        for _ in 0..steps {
+            match self.queue.try_pop_if(
+                &|sealed_bag: &SealedBag| sealed_bag.is_expired(global_epoch),
+                guard,
+            ) {
+                None => break,
+                Some(sealed_bag) => drop(sealed_bag),
+            }
+        }
+    }
+
+    /// Attempts to advance the global epoch.
+    ///
+    /// The global epoch can advance only if all currently pinned participants have been pinned in
+    /// the current epoch.
+    ///
+    /// Returns the current global epoch.
+    ///
+    /// `try_advance()` is annotated `#[cold]` because it is rarely called.
+    #[cold]
+    pub(crate) fn try_advance(&self, guard: &Guard) -> Epoch {
+        let global_epoch = self.epoch.load(Ordering::Relaxed);
+        atomic::fence(Ordering::SeqCst);
+
+        // TODO(stjepang): `Local`s are stored in a linked list because linked lists are fairly
+        // easy to implement in a lock-free manner. However, traversal can be slow due to cache
+        // misses and data dependencies. We should experiment with other data structures as well.
+        for local in self.locals.iter(guard) {
+            match local {
+                Err(IterError::Stalled) => {
+                    // A concurrent thread stalled this iteration. That thread might also try to
+                    // advance the epoch, in which case we leave the job to it. Otherwise, the
+                    // epoch will not be advanced.
+                    return global_epoch;
+                }
+                Ok(local) => {
+                    let local_epoch = local.epoch.load(Ordering::Relaxed);
+
+                    // If the participant was pinned in a different epoch, we cannot advance the
+                    // global epoch just yet.
+                    if local_epoch.is_pinned() && local_epoch.unpinned() != global_epoch {
+                        return global_epoch;
+                    }
+                }
+            }
+        }
+        atomic::fence(Ordering::Acquire);
+
+        // All pinned participants were pinned in the current global epoch.
+        // Now let's advance the global epoch...
+        //
+        // Note that if another thread already advanced it before us, this store will simply
+        // overwrite the global epoch with the same value. This is true because `try_advance` was
+        // called from a thread that was pinned in `global_epoch`, and the global epoch cannot be
+        // advanced two steps ahead of it.
+        let new_epoch = global_epoch.successor();
+        self.epoch.store(new_epoch, Ordering::Release);
+        new_epoch
+    }
+}
+
+/// Participant for garbage collection.
+#[repr(C)] // Note: `entry` must be the first field
+pub(crate) struct Local {
+    /// A node in the intrusive linked list of `Local`s.
+    entry: Entry,
+
+    /// A reference to the global data.
+    ///
+    /// When all guards and handles get dropped, this reference is destroyed.
+    collector: UnsafeCell<ManuallyDrop<Collector>>,
+
+    /// The local bag of deferred functions.
+    pub(crate) bag: UnsafeCell<Bag>,
+
+    /// The number of guards keeping this participant pinned.
+    guard_count: Cell<usize>,
+
+    /// The number of active handles.
+    handle_count: Cell<usize>,
+
+    /// Total number of pinnings performed.
+    ///
+    /// This is just an auxiliary counter that sometimes kicks off collection.
+    pin_count: Cell<Wrapping<usize>>,
+
+    /// The local epoch.
+    epoch: CachePadded<AtomicEpoch>,
+}
+
+// Make sure `Local` is less than or equal to 2048 bytes.
+// https://github.com/crossbeam-rs/crossbeam/issues/551
+#[cfg(not(any(crossbeam_sanitize, miri)))] // `crossbeam_sanitize` and `miri` reduce the size of `Local`
+#[test]
+fn local_size() {
+    // TODO: https://github.com/crossbeam-rs/crossbeam/issues/869
+    // assert!(
+    //     core::mem::size_of::<Local>() <= 2048,
+    //     "An allocation of `Local` should be <= 2048 bytes."
+    // );
+}
+
+impl Local {
+    /// Number of pinnings after which a participant will execute some deferred functions from the
+    /// global queue.
+    const PINNINGS_BETWEEN_COLLECT: usize = 128;
+
+    /// Registers a new `Local` in the provided `Global`.
+    pub(crate) fn register(collector: &Collector) -> LocalHandle {
+        unsafe {
+            // Since we dereference no pointers in this block, it is safe to use `unprotected`.
+
+            let local = Owned::new(Local {
+                entry: Entry::default(),
+                collector: UnsafeCell::new(ManuallyDrop::new(collector.clone())),
+                bag: UnsafeCell::new(Bag::new()),
+                guard_count: Cell::new(0),
+                handle_count: Cell::new(1),
+                pin_count: Cell::new(Wrapping(0)),
+                epoch: CachePadded::new(AtomicEpoch::new(Epoch::starting())),
+            })
+            .into_shared(unprotected());
+            collector.global.locals.insert(local, unprotected());
+            LocalHandle {
+                local: local.as_raw(),
+            }
+        }
+    }
+
+    /// Returns a reference to the `Global` in which this `Local` resides.
+    #[inline]
+    pub(crate) fn global(&self) -> &Global {
+        &self.collector().global
+    }
+
+    /// Returns a reference to the `Collector` in which this `Local` resides.
+    #[inline]
+    pub(crate) fn collector(&self) -> &Collector {
+        self.collector.with(|c| unsafe { &**c })
+    }
+
+    /// Returns `true` if the current participant is pinned.
+    #[inline]
+    pub(crate) fn is_pinned(&self) -> bool {
+        self.guard_count.get() > 0
+    }
+
+    /// Adds `deferred` to the thread-local bag.
+    ///
+    /// # Safety
+    ///
+    /// It should be safe for another thread to execute the given function.
+    pub(crate) unsafe fn defer(&self, mut deferred: Deferred, guard: &Guard) {
+        let bag = self.bag.with_mut(|b| &mut *b);
+
+        while let Err(d) = bag.try_push(deferred) {
+            self.global().push_bag(bag, guard);
+            deferred = d;
+        }
+    }
+
+    pub(crate) fn flush(&self, guard: &Guard) {
+        let bag = self.bag.with_mut(|b| unsafe { &mut *b });
+
+        if !bag.is_empty() {
+            self.global().push_bag(bag, guard);
+        }
+
+        self.global().collect(guard);
+    }
+
+    /// Pins the `Local`.
+    #[inline]
+    pub(crate) fn pin(&self) -> Guard {
+        let guard = Guard { local: self };
+
+        let guard_count = self.guard_count.get();
+        self.guard_count.set(guard_count.checked_add(1).unwrap());
+
+        if guard_count == 0 {
+            let global_epoch = self.global().epoch.load(Ordering::Relaxed);
+            let new_epoch = global_epoch.pinned();
+
+            // Now we must store `new_epoch` into `self.epoch` and execute a `SeqCst` fence.
+            // The fence makes sure that any future loads from `Atomic`s will not happen before
+            // this store.
+            if cfg!(all(
+                any(target_arch = "x86", target_arch = "x86_64"),
+                not(miri)
+            )) {
+                // HACK(stjepang): On x86 architectures there are two different ways of executing
+                // a `SeqCst` fence.
+                //
+                // 1. `atomic::fence(SeqCst)`, which compiles into a `mfence` instruction.
+                // 2. `_.compare_exchange(_, _, SeqCst, SeqCst)`, which compiles into a `lock cmpxchg`
+                //    instruction.
+                //
+                // Both instructions have the effect of a full barrier, but benchmarks have shown
+                // that the second one makes pinning faster in this particular case.  It is not
+                // clear that this is permitted by the C++ memory model (SC fences work very
+                // differently from SC accesses), but experimental evidence suggests that this
+                // works fine.  Using inline assembly would be a viable (and correct) alternative,
+                // but alas, that is not possible on stable Rust.
+                let current = Epoch::starting();
+                let res = self.epoch.compare_exchange(
+                    current,
+                    new_epoch,
+                    Ordering::SeqCst,
+                    Ordering::SeqCst,
+                );
+                debug_assert!(res.is_ok(), "participant was expected to be unpinned");
+                // We add a compiler fence to make it less likely for LLVM to do something wrong
+                // here.  Formally, this is not enough to get rid of data races; practically,
+                // it should go a long way.
+                atomic::compiler_fence(Ordering::SeqCst);
+            } else {
+                self.epoch.store(new_epoch, Ordering::Relaxed);
+                atomic::fence(Ordering::SeqCst);
+            }
+
+            // Increment the pin counter.
+            let count = self.pin_count.get();
+            self.pin_count.set(count + Wrapping(1));
+
+            // After every `PINNINGS_BETWEEN_COLLECT` try advancing the epoch and collecting
+            // some garbage.
+            if count.0 % Self::PINNINGS_BETWEEN_COLLECT == 0 {
+                self.global().collect(&guard);
+            }
+        }
+
+        guard
+    }
+
+    /// Unpins the `Local`.
+    #[inline]
+    pub(crate) fn unpin(&self) {
+        let guard_count = self.guard_count.get();
+        self.guard_count.set(guard_count - 1);
+
+        if guard_count == 1 {
+            self.epoch.store(Epoch::starting(), Ordering::Release);
+
+            if self.handle_count.get() == 0 {
+                self.finalize();
+            }
+        }
+    }
+
+    /// Unpins and then pins the `Local`.
+    #[inline]
+    pub(crate) fn repin(&self) {
+        let guard_count = self.guard_count.get();
+
+        // Update the local epoch only if there's only one guard.
+        if guard_count == 1 {
+            let epoch = self.epoch.load(Ordering::Relaxed);
+            let global_epoch = self.global().epoch.load(Ordering::Relaxed).pinned();
+
+            // Update the local epoch only if the global epoch is greater than the local epoch.
+            if epoch != global_epoch {
+                // We store the new epoch with `Release` because we need to ensure any memory
+                // accesses from the previous epoch do not leak into the new one.
+                self.epoch.store(global_epoch, Ordering::Release);
+
+                // However, we don't need a following `SeqCst` fence, because it is safe for memory
+                // accesses from the new epoch to be executed before updating the local epoch. At
+                // worse, other threads will see the new epoch late and delay GC slightly.
+            }
+        }
+    }
+
+    /// Increments the handle count.
+    #[inline]
+    pub(crate) fn acquire_handle(&self) {
+        let handle_count = self.handle_count.get();
+        debug_assert!(handle_count >= 1);
+        self.handle_count.set(handle_count + 1);
+    }
+
+    /// Decrements the handle count.
+    #[inline]
+    pub(crate) fn release_handle(&self) {
+        let guard_count = self.guard_count.get();
+        let handle_count = self.handle_count.get();
+        debug_assert!(handle_count >= 1);
+        self.handle_count.set(handle_count - 1);
+
+        if guard_count == 0 && handle_count == 1 {
+            self.finalize();
+        }
+    }
+
+    /// Removes the `Local` from the global linked list.
+    #[cold]
+    fn finalize(&self) {
+        debug_assert_eq!(self.guard_count.get(), 0);
+        debug_assert_eq!(self.handle_count.get(), 0);
+
+        // Temporarily increment handle count. This is required so that the following call to `pin`
+        // doesn't call `finalize` again.
+        self.handle_count.set(1);
+        unsafe {
+            // Pin and move the local bag into the global queue. It's important that `push_bag`
+            // doesn't defer destruction on any new garbage.
+            let guard = &self.pin();
+            self.global()
+                .push_bag(self.bag.with_mut(|b| &mut *b), guard);
+        }
+        // Revert the handle count back to zero.
+        self.handle_count.set(0);
+
+        unsafe {
+            // Take the reference to the `Global` out of this `Local`. Since we're not protected
+            // by a guard at this time, it's crucial that the reference is read before marking the
+            // `Local` as deleted.
+            let collector: Collector = ptr::read(self.collector.with(|c| &*(*c)));
+
+            // Mark this node in the linked list as deleted.
+            self.entry.delete(unprotected());
+
+            // Finally, drop the reference to the global. Note that this might be the last reference
+            // to the `Global`. If so, the global data will be destroyed and all deferred functions
+            // in its queue will be executed.
+            drop(collector);
+        }
+    }
+}
+
+impl IsElement<Self> for Local {
+    fn entry_of(local: &Self) -> &Entry {
+        // SAFETY: `Local` is `repr(C)` and `entry` is the first field of it.
+        unsafe {
+            let entry_ptr = (local as *const Self).cast::<Entry>();
+            &*entry_ptr
+        }
+    }
+
+    unsafe fn element_of(entry: &Entry) -> &Self {
+        // SAFETY: `Local` is `repr(C)` and `entry` is the first field of it.
+        let local_ptr = (entry as *const Entry).cast::<Self>();
+        &*local_ptr
+    }
+
+    unsafe fn finalize(entry: &Entry, guard: &Guard) {
+        guard.defer_destroy(Shared::from(Self::element_of(entry) as *const _));
+    }
+}
+
+#[cfg(all(test, not(crossbeam_loom)))]
+mod tests {
+    use std::sync::atomic::{AtomicUsize, Ordering};
+
+    use super::*;
+
+    #[test]
+    fn check_defer() {
+        static FLAG: AtomicUsize = AtomicUsize::new(0);
+        fn set() {
+            FLAG.store(42, Ordering::Relaxed);
+        }
+
+        let d = Deferred::new(set);
+        assert_eq!(FLAG.load(Ordering::Relaxed), 0);
+        d.call();
+        assert_eq!(FLAG.load(Ordering::Relaxed), 42);
+    }
+
+    #[test]
+    fn check_bag() {
+        static FLAG: AtomicUsize = AtomicUsize::new(0);
+        fn incr() {
+            FLAG.fetch_add(1, Ordering::Relaxed);
+        }
+
+        let mut bag = Bag::new();
+        assert!(bag.is_empty());
+
+        for _ in 0..MAX_OBJECTS {
+            assert!(unsafe { bag.try_push(Deferred::new(incr)).is_ok() });
+            assert!(!bag.is_empty());
+            assert_eq!(FLAG.load(Ordering::Relaxed), 0);
+        }
+
+        let result = unsafe { bag.try_push(Deferred::new(incr)) };
+        assert!(result.is_err());
+        assert!(!bag.is_empty());
+        assert_eq!(FLAG.load(Ordering::Relaxed), 0);
+
+        drop(bag);
+        assert_eq!(FLAG.load(Ordering::Relaxed), MAX_OBJECTS);
+    }
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-epoch-0.9.18/src/lib.rs

@@ -0,0 +1,166 @@
+//! Epoch-based memory reclamation.
+//!
+//! An interesting problem concurrent collections deal with comes from the remove operation.
+//! Suppose that a thread removes an element from a lock-free map, while another thread is reading
+//! that same element at the same time. The first thread must wait until the second thread stops
+//! reading the element. Only then it is safe to destruct it.
+//!
+//! Programming languages that come with garbage collectors solve this problem trivially. The
+//! garbage collector will destruct the removed element when no thread can hold a reference to it
+//! anymore.
+//!
+//! This crate implements a basic memory reclamation mechanism, which is based on epochs. When an
+//! element gets removed from a concurrent collection, it is inserted into a pile of garbage and
+//! marked with the current epoch. Every time a thread accesses a collection, it checks the current
+//! epoch, attempts to increment it, and destructs some garbage that became so old that no thread
+//! can be referencing it anymore.
+//!
+//! That is the general mechanism behind epoch-based memory reclamation, but the details are a bit
+//! more complicated. Anyhow, memory reclamation is designed to be fully automatic and something
+//! users of concurrent collections don't have to worry much about.
+//!
+//! # Pointers
+//!
+//! Concurrent collections are built using atomic pointers. This module provides [`Atomic`], which
+//! is just a shared atomic pointer to a heap-allocated object. Loading an [`Atomic`] yields a
+//! [`Shared`], which is an epoch-protected pointer through which the loaded object can be safely
+//! read.
+//!
+//! # Pinning
+//!
+//! Before an [`Atomic`] can be loaded, a participant must be [`pin`]ned. By pinning a participant
+//! we declare that any object that gets removed from now on must not be destructed just
+//! yet. Garbage collection of newly removed objects is suspended until the participant gets
+//! unpinned.
+//!
+//! # Garbage
+//!
+//! Objects that get removed from concurrent collections must be stashed away until all currently
+//! pinned participants get unpinned. Such objects can be stored into a thread-local or global
+//! storage, where they are kept until the right time for their destruction comes.
+//!
+//! There is a global shared instance of garbage queue. You can [`defer`](Guard::defer) the execution of an
+//! arbitrary function until the global epoch is advanced enough. Most notably, concurrent data
+//! structures may defer the deallocation of an object.
+//!
+//! # APIs
+//!
+//! For majority of use cases, just use the default garbage collector by invoking [`pin`]. If you
+//! want to create your own garbage collector, use the [`Collector`] API.
+
+#![doc(test(
+    no_crate_inject,
+    attr(
+        deny(warnings, rust_2018_idioms),
+        allow(dead_code, unused_assignments, unused_variables)
+    )
+))]
+#![warn(
+    missing_docs,
+    missing_debug_implementations,
+    rust_2018_idioms,
+    unreachable_pub
+)]
+#![cfg_attr(not(feature = "std"), no_std)]
+
+#[cfg(crossbeam_loom)]
+extern crate loom_crate as loom;
+
+#[cfg(crossbeam_loom)]
+#[allow(unused_imports, dead_code)]
+mod primitive {
+    pub(crate) mod cell {
+        pub(crate) use loom::cell::UnsafeCell;
+    }
+    pub(crate) mod sync {
+        pub(crate) mod atomic {
+            pub(crate) use loom::sync::atomic::{fence, AtomicPtr, AtomicUsize, Ordering};
+
+            // FIXME: loom does not support compiler_fence at the moment.
+            // https://github.com/tokio-rs/loom/issues/117
+            // we use fence as a stand-in for compiler_fence for the time being.
+            // this may miss some races since fence is stronger than compiler_fence,
+            // but it's the best we can do for the time being.
+            pub(crate) use self::fence as compiler_fence;
+        }
+        pub(crate) use loom::sync::Arc;
+    }
+    pub(crate) use loom::thread_local;
+}
+#[cfg(target_has_atomic = "ptr")]
+#[cfg(not(crossbeam_loom))]
+#[allow(unused_imports, dead_code)]
+mod primitive {
+    pub(crate) mod cell {
+        #[derive(Debug)]
+        #[repr(transparent)]
+        pub(crate) struct UnsafeCell<T>(::core::cell::UnsafeCell<T>);
+
+        // loom's UnsafeCell has a slightly different API than the standard library UnsafeCell.
+        // Since we want the rest of the code to be agnostic to whether it's running under loom or
+        // not, we write this small wrapper that provides the loom-supported API for the standard
+        // library UnsafeCell. This is also what the loom documentation recommends:
+        // https://github.com/tokio-rs/loom#handling-loom-api-differences
+        impl<T> UnsafeCell<T> {
+            #[inline]
+            pub(crate) const fn new(data: T) -> UnsafeCell<T> {
+                UnsafeCell(::core::cell::UnsafeCell::new(data))
+            }
+
+            #[inline]
+            pub(crate) fn with<R>(&self, f: impl FnOnce(*const T) -> R) -> R {
+                f(self.0.get())
+            }
+
+            #[inline]
+            pub(crate) fn with_mut<R>(&self, f: impl FnOnce(*mut T) -> R) -> R {
+                f(self.0.get())
+            }
+        }
+    }
+    pub(crate) mod sync {
+        pub(crate) mod atomic {
+            pub(crate) use core::sync::atomic::{
+                compiler_fence, fence, AtomicPtr, AtomicUsize, Ordering,
+            };
+        }
+        #[cfg(feature = "alloc")]
+        pub(crate) use alloc::sync::Arc;
+    }
+
+    #[cfg(feature = "std")]
+    pub(crate) use std::thread_local;
+}
+
+#[cfg(all(feature = "alloc", target_has_atomic = "ptr"))]
+extern crate alloc;
+
+#[cfg(all(feature = "alloc", target_has_atomic = "ptr"))]
+mod atomic;
+#[cfg(all(feature = "alloc", target_has_atomic = "ptr"))]
+mod collector;
+#[cfg(all(feature = "alloc", target_has_atomic = "ptr"))]
+mod deferred;
+#[cfg(all(feature = "alloc", target_has_atomic = "ptr"))]
+mod epoch;
+#[cfg(all(feature = "alloc", target_has_atomic = "ptr"))]
+mod guard;
+#[cfg(all(feature = "alloc", target_has_atomic = "ptr"))]
+mod internal;
+#[cfg(all(feature = "alloc", target_has_atomic = "ptr"))]
+mod sync;
+
+#[cfg(all(feature = "alloc", target_has_atomic = "ptr"))]
+#[allow(deprecated)]
+pub use crate::atomic::{CompareAndSetError, CompareAndSetOrdering};
+#[cfg(all(feature = "alloc", target_has_atomic = "ptr"))]
+pub use crate::{
+    atomic::{Atomic, CompareExchangeError, Owned, Pointable, Pointer, Shared},
+    collector::{Collector, LocalHandle},
+    guard::{unprotected, Guard},
+};
+
+#[cfg(feature = "std")]
+mod default;
+#[cfg(feature = "std")]
+pub use crate::default::{default_collector, is_pinned, pin};

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-epoch-0.9.18/src/sync/list.rs

@@ -0,0 +1,487 @@
+//! Lock-free intrusive linked list.
+//!
+//! Ideas from Michael.  High Performance Dynamic Lock-Free Hash Tables and List-Based Sets.  SPAA
+//! 2002.  <http://dl.acm.org/citation.cfm?id=564870.564881>
+
+use core::marker::PhantomData;
+use core::sync::atomic::Ordering::{Acquire, Relaxed, Release};
+
+use crate::{unprotected, Atomic, Guard, Shared};
+
+/// An entry in a linked list.
+///
+/// An Entry is accessed from multiple threads, so it would be beneficial to put it in a different
+/// cache-line than thread-local data in terms of performance.
+#[derive(Debug)]
+pub(crate) struct Entry {
+    /// The next entry in the linked list.
+    /// If the tag is 1, this entry is marked as deleted.
+    next: Atomic<Entry>,
+}
+
+/// Implementing this trait asserts that the type `T` can be used as an element in the intrusive
+/// linked list defined in this module. `T` has to contain (or otherwise be linked to) an instance
+/// of `Entry`.
+///
+/// # Example
+///
+/// ```ignore
+/// struct A {
+///     entry: Entry,
+///     data: usize,
+/// }
+///
+/// impl IsElement<A> for A {
+///     fn entry_of(a: &A) -> &Entry {
+///         let entry_ptr = ((a as usize) + offset_of!(A, entry)) as *const Entry;
+///         unsafe { &*entry_ptr }
+///     }
+///
+///     unsafe fn element_of(entry: &Entry) -> &T {
+///         let elem_ptr = ((entry as usize) - offset_of!(A, entry)) as *const T;
+///         &*elem_ptr
+///     }
+///
+///     unsafe fn finalize(entry: &Entry, guard: &Guard) {
+///         guard.defer_destroy(Shared::from(Self::element_of(entry) as *const _));
+///     }
+/// }
+/// ```
+///
+/// This trait is implemented on a type separate from `T` (although it can be just `T`), because
+/// one type might be placeable into multiple lists, in which case it would require multiple
+/// implementations of `IsElement`. In such cases, each struct implementing `IsElement<T>`
+/// represents a distinct `Entry` in `T`.
+///
+/// For example, we can insert the following struct into two lists using `entry1` for one
+/// and `entry2` for the other:
+///
+/// ```ignore
+/// struct B {
+///     entry1: Entry,
+///     entry2: Entry,
+///     data: usize,
+/// }
+/// ```
+///
+pub(crate) trait IsElement<T> {
+    /// Returns a reference to this element's `Entry`.
+    fn entry_of(_: &T) -> &Entry;
+
+    /// Given a reference to an element's entry, returns that element.
+    ///
+    /// ```ignore
+    /// let elem = ListElement::new();
+    /// assert_eq!(elem.entry_of(),
+    ///            unsafe { ListElement::element_of(elem.entry_of()) } );
+    /// ```
+    ///
+    /// # Safety
+    ///
+    /// The caller has to guarantee that the `Entry` is called with was retrieved from an instance
+    /// of the element type (`T`).
+    unsafe fn element_of(_: &Entry) -> &T;
+
+    /// The function that is called when an entry is unlinked from list.
+    ///
+    /// # Safety
+    ///
+    /// The caller has to guarantee that the `Entry` is called with was retrieved from an instance
+    /// of the element type (`T`).
+    unsafe fn finalize(_: &Entry, _: &Guard);
+}
+
+/// A lock-free, intrusive linked list of type `T`.
+#[derive(Debug)]
+pub(crate) struct List<T, C: IsElement<T> = T> {
+    /// The head of the linked list.
+    head: Atomic<Entry>,
+
+    /// The phantom data for using `T` and `C`.
+    _marker: PhantomData<(T, C)>,
+}
+
+/// An iterator used for retrieving values from the list.
+pub(crate) struct Iter<'g, T, C: IsElement<T>> {
+    /// The guard that protects the iteration.
+    guard: &'g Guard,
+
+    /// Pointer from the predecessor to the current entry.
+    pred: &'g Atomic<Entry>,
+
+    /// The current entry.
+    curr: Shared<'g, Entry>,
+
+    /// The list head, needed for restarting iteration.
+    head: &'g Atomic<Entry>,
+
+    /// Logically, we store a borrow of an instance of `T` and
+    /// use the type information from `C`.
+    _marker: PhantomData<(&'g T, C)>,
+}
+
+/// An error that occurs during iteration over the list.
+#[derive(PartialEq, Debug)]
+pub(crate) enum IterError {
+    /// A concurrent thread modified the state of the list at the same place that this iterator
+    /// was inspecting. Subsequent iteration will restart from the beginning of the list.
+    Stalled,
+}
+
+impl Default for Entry {
+    /// Returns the empty entry.
+    fn default() -> Self {
+        Self {
+            next: Atomic::null(),
+        }
+    }
+}
+
+impl Entry {
+    /// Marks this entry as deleted, deferring the actual deallocation to a later iteration.
+    ///
+    /// # Safety
+    ///
+    /// The entry should be a member of a linked list, and it should not have been deleted.
+    /// It should be safe to call `C::finalize` on the entry after the `guard` is dropped, where `C`
+    /// is the associated helper for the linked list.
+    pub(crate) unsafe fn delete(&self, guard: &Guard) {
+        self.next.fetch_or(1, Release, guard);
+    }
+}
+
+impl<T, C: IsElement<T>> List<T, C> {
+    /// Returns a new, empty linked list.
+    pub(crate) fn new() -> Self {
+        Self {
+            head: Atomic::null(),
+            _marker: PhantomData,
+        }
+    }
+
+    /// Inserts `entry` into the head of the list.
+    ///
+    /// # Safety
+    ///
+    /// You should guarantee that:
+    ///
+    /// - `container` is not null
+    /// - `container` is immovable, e.g. inside an `Owned`
+    /// - the same `Entry` is not inserted more than once
+    /// - the inserted object will be removed before the list is dropped
+    pub(crate) unsafe fn insert<'g>(&'g self, container: Shared<'g, T>, guard: &'g Guard) {
+        // Insert right after head, i.e. at the beginning of the list.
+        let to = &self.head;
+        // Get the intrusively stored Entry of the new element to insert.
+        let entry: &Entry = C::entry_of(container.deref());
+        // Make a Shared ptr to that Entry.
+        let entry_ptr = Shared::from(entry as *const _);
+        // Read the current successor of where we want to insert.
+        let mut next = to.load(Relaxed, guard);
+
+        loop {
+            // Set the Entry of the to-be-inserted element to point to the previous successor of
+            // `to`.
+            entry.next.store(next, Relaxed);
+            match to.compare_exchange_weak(next, entry_ptr, Release, Relaxed, guard) {
+                Ok(_) => break,
+                // We lost the race or weak CAS failed spuriously. Update the successor and try
+                // again.
+                Err(err) => next = err.current,
+            }
+        }
+    }
+
+    /// Returns an iterator over all objects.
+    ///
+    /// # Caveat
+    ///
+    /// Every object that is inserted at the moment this function is called and persists at least
+    /// until the end of iteration will be returned. Since this iterator traverses a lock-free
+    /// linked list that may be concurrently modified, some additional caveats apply:
+    ///
+    /// 1. If a new object is inserted during iteration, it may or may not be returned.
+    /// 2. If an object is deleted during iteration, it may or may not be returned.
+    /// 3. The iteration may be aborted when it lost in a race condition. In this case, the winning
+    ///    thread will continue to iterate over the same list.
+    pub(crate) fn iter<'g>(&'g self, guard: &'g Guard) -> Iter<'g, T, C> {
+        Iter {
+            guard,
+            pred: &self.head,
+            curr: self.head.load(Acquire, guard),
+            head: &self.head,
+            _marker: PhantomData,
+        }
+    }
+}
+
+impl<T, C: IsElement<T>> Drop for List<T, C> {
+    fn drop(&mut self) {
+        unsafe {
+            let guard = unprotected();
+            let mut curr = self.head.load(Relaxed, guard);
+            while let Some(c) = curr.as_ref() {
+                let succ = c.next.load(Relaxed, guard);
+                // Verify that all elements have been removed from the list.
+                assert_eq!(succ.tag(), 1);
+
+                C::finalize(curr.deref(), guard);
+                curr = succ;
+            }
+        }
+    }
+}
+
+impl<'g, T: 'g, C: IsElement<T>> Iterator for Iter<'g, T, C> {
+    type Item = Result<&'g T, IterError>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        while let Some(c) = unsafe { self.curr.as_ref() } {
+            let succ = c.next.load(Acquire, self.guard);
+
+            if succ.tag() == 1 {
+                // This entry was removed. Try unlinking it from the list.
+                let succ = succ.with_tag(0);
+
+                // The tag should always be zero, because removing a node after a logically deleted
+                // node leaves the list in an invalid state.
+                debug_assert!(self.curr.tag() == 0);
+
+                // Try to unlink `curr` from the list, and get the new value of `self.pred`.
+                let succ = match self
+                    .pred
+                    .compare_exchange(self.curr, succ, Acquire, Acquire, self.guard)
+                {
+                    Ok(_) => {
+                        // We succeeded in unlinking `curr`, so we have to schedule
+                        // deallocation. Deferred drop is okay, because `list.delete()` can only be
+                        // called if `T: 'static`.
+                        unsafe {
+                            C::finalize(self.curr.deref(), self.guard);
+                        }
+
+                        // `succ` is the new value of `self.pred`.
+                        succ
+                    }
+                    Err(e) => {
+                        // `e.current` is the current value of `self.pred`.
+                        e.current
+                    }
+                };
+
+                // If the predecessor node is already marked as deleted, we need to restart from
+                // `head`.
+                if succ.tag() != 0 {
+                    self.pred = self.head;
+                    self.curr = self.head.load(Acquire, self.guard);
+
+                    return Some(Err(IterError::Stalled));
+                }
+
+                // Move over the removed by only advancing `curr`, not `pred`.
+                self.curr = succ;
+                continue;
+            }
+
+            // Move one step forward.
+            self.pred = &c.next;
+            self.curr = succ;
+
+            return Some(Ok(unsafe { C::element_of(c) }));
+        }
+
+        // We reached the end of the list.
+        None
+    }
+}
+
+#[cfg(all(test, not(crossbeam_loom)))]
+mod tests {
+    use super::*;
+    use crate::{Collector, Owned};
+    use crossbeam_utils::thread;
+    use std::sync::Barrier;
+
+    impl IsElement<Entry> for Entry {
+        fn entry_of(entry: &Entry) -> &Entry {
+            entry
+        }
+
+        unsafe fn element_of(entry: &Entry) -> &Entry {
+            entry
+        }
+
+        unsafe fn finalize(entry: &Entry, guard: &Guard) {
+            guard.defer_destroy(Shared::from(Self::element_of(entry) as *const _));
+        }
+    }
+
+    /// Checks whether the list retains inserted elements
+    /// and returns them in the correct order.
+    #[test]
+    fn insert() {
+        let collector = Collector::new();
+        let handle = collector.register();
+        let guard = handle.pin();
+
+        let l: List<Entry> = List::new();
+
+        let e1 = Owned::new(Entry::default()).into_shared(&guard);
+        let e2 = Owned::new(Entry::default()).into_shared(&guard);
+        let e3 = Owned::new(Entry::default()).into_shared(&guard);
+
+        unsafe {
+            l.insert(e1, &guard);
+            l.insert(e2, &guard);
+            l.insert(e3, &guard);
+        }
+
+        let mut iter = l.iter(&guard);
+        let maybe_e3 = iter.next();
+        assert!(maybe_e3.is_some());
+        assert!(maybe_e3.unwrap().unwrap() as *const Entry == e3.as_raw());
+        let maybe_e2 = iter.next();
+        assert!(maybe_e2.is_some());
+        assert!(maybe_e2.unwrap().unwrap() as *const Entry == e2.as_raw());
+        let maybe_e1 = iter.next();
+        assert!(maybe_e1.is_some());
+        assert!(maybe_e1.unwrap().unwrap() as *const Entry == e1.as_raw());
+        assert!(iter.next().is_none());
+
+        unsafe {
+            e1.as_ref().unwrap().delete(&guard);
+            e2.as_ref().unwrap().delete(&guard);
+            e3.as_ref().unwrap().delete(&guard);
+        }
+    }
+
+    /// Checks whether elements can be removed from the list and whether
+    /// the correct elements are removed.
+    #[test]
+    fn delete() {
+        let collector = Collector::new();
+        let handle = collector.register();
+        let guard = handle.pin();
+
+        let l: List<Entry> = List::new();
+
+        let e1 = Owned::new(Entry::default()).into_shared(&guard);
+        let e2 = Owned::new(Entry::default()).into_shared(&guard);
+        let e3 = Owned::new(Entry::default()).into_shared(&guard);
+        unsafe {
+            l.insert(e1, &guard);
+            l.insert(e2, &guard);
+            l.insert(e3, &guard);
+            e2.as_ref().unwrap().delete(&guard);
+        }
+
+        let mut iter = l.iter(&guard);
+        let maybe_e3 = iter.next();
+        assert!(maybe_e3.is_some());
+        assert!(maybe_e3.unwrap().unwrap() as *const Entry == e3.as_raw());
+        let maybe_e1 = iter.next();
+        assert!(maybe_e1.is_some());
+        assert!(maybe_e1.unwrap().unwrap() as *const Entry == e1.as_raw());
+        assert!(iter.next().is_none());
+
+        unsafe {
+            e1.as_ref().unwrap().delete(&guard);
+            e3.as_ref().unwrap().delete(&guard);
+        }
+
+        let mut iter = l.iter(&guard);
+        assert!(iter.next().is_none());
+    }
+
+    const THREADS: usize = 8;
+    const ITERS: usize = 512;
+
+    /// Contends the list on insert and delete operations to make sure they can run concurrently.
+    #[test]
+    fn insert_delete_multi() {
+        let collector = Collector::new();
+
+        let l: List<Entry> = List::new();
+        let b = Barrier::new(THREADS);
+
+        thread::scope(|s| {
+            for _ in 0..THREADS {
+                s.spawn(|_| {
+                    b.wait();
+
+                    let handle = collector.register();
+                    let guard: Guard = handle.pin();
+                    let mut v = Vec::with_capacity(ITERS);
+
+                    for _ in 0..ITERS {
+                        let e = Owned::new(Entry::default()).into_shared(&guard);
+                        v.push(e);
+                        unsafe {
+                            l.insert(e, &guard);
+                        }
+                    }
+
+                    for e in v {
+                        unsafe {
+                            e.as_ref().unwrap().delete(&guard);
+                        }
+                    }
+                });
+            }
+        })
+        .unwrap();
+
+        let handle = collector.register();
+        let guard = handle.pin();
+
+        let mut iter = l.iter(&guard);
+        assert!(iter.next().is_none());
+    }
+
+    /// Contends the list on iteration to make sure that it can be iterated over concurrently.
+    #[test]
+    fn iter_multi() {
+        let collector = Collector::new();
+
+        let l: List<Entry> = List::new();
+        let b = Barrier::new(THREADS);
+
+        thread::scope(|s| {
+            for _ in 0..THREADS {
+                s.spawn(|_| {
+                    b.wait();
+
+                    let handle = collector.register();
+                    let guard: Guard = handle.pin();
+                    let mut v = Vec::with_capacity(ITERS);
+
+                    for _ in 0..ITERS {
+                        let e = Owned::new(Entry::default()).into_shared(&guard);
+                        v.push(e);
+                        unsafe {
+                            l.insert(e, &guard);
+                        }
+                    }
+
+                    let mut iter = l.iter(&guard);
+                    for _ in 0..ITERS {
+                        assert!(iter.next().is_some());
+                    }
+
+                    for e in v {
+                        unsafe {
+                            e.as_ref().unwrap().delete(&guard);
+                        }
+                    }
+                });
+            }
+        })
+        .unwrap();
+
+        let handle = collector.register();
+        let guard = handle.pin();
+
+        let mut iter = l.iter(&guard);
+        assert!(iter.next().is_none());
+    }
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-epoch-0.9.18/src/sync/mod.rs

@@ -0,0 +1,7 @@
+//! Synchronization primitives.
+
+pub(crate) mod list;
+#[cfg(feature = "std")]
+#[cfg(not(crossbeam_loom))]
+pub(crate) mod once_lock;
+pub(crate) mod queue;

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-epoch-0.9.18/src/sync/once_lock.rs

@@ -0,0 +1,88 @@
+// Based on unstable std::sync::OnceLock.
+//
+// Source: https://github.com/rust-lang/rust/blob/8e9c93df464b7ada3fc7a1c8ccddd9dcb24ee0a0/library/std/src/sync/once_lock.rs
+
+use core::cell::UnsafeCell;
+use core::mem::MaybeUninit;
+use std::sync::Once;
+
+pub(crate) struct OnceLock<T> {
+    once: Once,
+    value: UnsafeCell<MaybeUninit<T>>,
+    // Unlike std::sync::OnceLock, we don't need PhantomData here because
+    // we don't use #[may_dangle].
+}
+
+unsafe impl<T: Sync + Send> Sync for OnceLock<T> {}
+unsafe impl<T: Send> Send for OnceLock<T> {}
+
+impl<T> OnceLock<T> {
+    /// Creates a new empty cell.
+    #[must_use]
+    pub(crate) const fn new() -> Self {
+        Self {
+            once: Once::new(),
+            value: UnsafeCell::new(MaybeUninit::uninit()),
+        }
+    }
+
+    /// Gets the contents of the cell, initializing it with `f` if the cell
+    /// was empty.
+    ///
+    /// Many threads may call `get_or_init` concurrently with different
+    /// initializing functions, but it is guaranteed that only one function
+    /// will be executed.
+    ///
+    /// # Panics
+    ///
+    /// If `f` panics, the panic is propagated to the caller, and the cell
+    /// remains uninitialized.
+    ///
+    /// It is an error to reentrantly initialize the cell from `f`. The
+    /// exact outcome is unspecified. Current implementation deadlocks, but
+    /// this may be changed to a panic in the future.
+    pub(crate) fn get_or_init<F>(&self, f: F) -> &T
+    where
+        F: FnOnce() -> T,
+    {
+        // Fast path check
+        if self.once.is_completed() {
+            // SAFETY: The inner value has been initialized
+            return unsafe { self.get_unchecked() };
+        }
+        self.initialize(f);
+
+        // SAFETY: The inner value has been initialized
+        unsafe { self.get_unchecked() }
+    }
+
+    #[cold]
+    fn initialize<F>(&self, f: F)
+    where
+        F: FnOnce() -> T,
+    {
+        let slot = self.value.get();
+
+        self.once.call_once(|| {
+            let value = f();
+            unsafe { slot.write(MaybeUninit::new(value)) }
+        });
+    }
+
+    /// # Safety
+    ///
+    /// The value must be initialized
+    unsafe fn get_unchecked(&self) -> &T {
+        debug_assert!(self.once.is_completed());
+        &*self.value.get().cast::<T>()
+    }
+}
+
+impl<T> Drop for OnceLock<T> {
+    fn drop(&mut self) {
+        if self.once.is_completed() {
+            // SAFETY: The inner value has been initialized
+            unsafe { (*self.value.get()).assume_init_drop() };
+        }
+    }
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-epoch-0.9.18/src/sync/queue.rs

@@ -0,0 +1,468 @@
+//! Michael-Scott lock-free queue.
+//!
+//! Usable with any number of producers and consumers.
+//!
+//! Michael and Scott.  Simple, Fast, and Practical Non-Blocking and Blocking Concurrent Queue
+//! Algorithms.  PODC 1996.  <http://dl.acm.org/citation.cfm?id=248106>
+//!
+//! Simon Doherty, Lindsay Groves, Victor Luchangco, and Mark Moir. 2004b. Formal Verification of a
+//! Practical Lock-Free Queue Algorithm. <https://doi.org/10.1007/978-3-540-30232-2_7>
+
+use core::mem::MaybeUninit;
+use core::sync::atomic::Ordering::{Acquire, Relaxed, Release};
+
+use crossbeam_utils::CachePadded;
+
+use crate::{unprotected, Atomic, Guard, Owned, Shared};
+
+// The representation here is a singly-linked list, with a sentinel node at the front. In general
+// the `tail` pointer may lag behind the actual tail. Non-sentinel nodes are either all `Data` or
+// all `Blocked` (requests for data from blocked threads).
+#[derive(Debug)]
+pub(crate) struct Queue<T> {
+    head: CachePadded<Atomic<Node<T>>>,
+    tail: CachePadded<Atomic<Node<T>>>,
+}
+
+struct Node<T> {
+    /// The slot in which a value of type `T` can be stored.
+    ///
+    /// The type of `data` is `MaybeUninit<T>` because a `Node<T>` doesn't always contain a `T`.
+    /// For example, the sentinel node in a queue never contains a value: its slot is always empty.
+    /// Other nodes start their life with a push operation and contain a value until it gets popped
+    /// out. After that such empty nodes get added to the collector for destruction.
+    data: MaybeUninit<T>,
+
+    next: Atomic<Node<T>>,
+}
+
+// Any particular `T` should never be accessed concurrently, so no need for `Sync`.
+unsafe impl<T: Send> Sync for Queue<T> {}
+unsafe impl<T: Send> Send for Queue<T> {}
+
+impl<T> Queue<T> {
+    /// Create a new, empty queue.
+    pub(crate) fn new() -> Queue<T> {
+        let q = Queue {
+            head: CachePadded::new(Atomic::null()),
+            tail: CachePadded::new(Atomic::null()),
+        };
+        let sentinel = Owned::new(Node {
+            data: MaybeUninit::uninit(),
+            next: Atomic::null(),
+        });
+        unsafe {
+            let guard = unprotected();
+            let sentinel = sentinel.into_shared(guard);
+            q.head.store(sentinel, Relaxed);
+            q.tail.store(sentinel, Relaxed);
+            q
+        }
+    }
+
+    /// Attempts to atomically place `n` into the `next` pointer of `onto`, and returns `true` on
+    /// success. The queue's `tail` pointer may be updated.
+    #[inline(always)]
+    fn push_internal(
+        &self,
+        onto: Shared<'_, Node<T>>,
+        new: Shared<'_, Node<T>>,
+        guard: &Guard,
+    ) -> bool {
+        // is `onto` the actual tail?
+        let o = unsafe { onto.deref() };
+        let next = o.next.load(Acquire, guard);
+        if unsafe { next.as_ref().is_some() } {
+            // if not, try to "help" by moving the tail pointer forward
+            let _ = self
+                .tail
+                .compare_exchange(onto, next, Release, Relaxed, guard);
+            false
+        } else {
+            // looks like the actual tail; attempt to link in `n`
+            let result = o
+                .next
+                .compare_exchange(Shared::null(), new, Release, Relaxed, guard)
+                .is_ok();
+            if result {
+                // try to move the tail pointer forward
+                let _ = self
+                    .tail
+                    .compare_exchange(onto, new, Release, Relaxed, guard);
+            }
+            result
+        }
+    }
+
+    /// Adds `t` to the back of the queue, possibly waking up threads blocked on `pop`.
+    pub(crate) fn push(&self, t: T, guard: &Guard) {
+        let new = Owned::new(Node {
+            data: MaybeUninit::new(t),
+            next: Atomic::null(),
+        });
+        let new = Owned::into_shared(new, guard);
+
+        loop {
+            // We push onto the tail, so we'll start optimistically by looking there first.
+            let tail = self.tail.load(Acquire, guard);
+
+            // Attempt to push onto the `tail` snapshot; fails if `tail.next` has changed.
+            if self.push_internal(tail, new, guard) {
+                break;
+            }
+        }
+    }
+
+    /// Attempts to pop a data node. `Ok(None)` if queue is empty; `Err(())` if lost race to pop.
+    #[inline(always)]
+    fn pop_internal(&self, guard: &Guard) -> Result<Option<T>, ()> {
+        let head = self.head.load(Acquire, guard);
+        let h = unsafe { head.deref() };
+        let next = h.next.load(Acquire, guard);
+        match unsafe { next.as_ref() } {
+            Some(n) => unsafe {
+                self.head
+                    .compare_exchange(head, next, Release, Relaxed, guard)
+                    .map(|_| {
+                        let tail = self.tail.load(Relaxed, guard);
+                        // Advance the tail so that we don't retire a pointer to a reachable node.
+                        if head == tail {
+                            let _ = self
+                                .tail
+                                .compare_exchange(tail, next, Release, Relaxed, guard);
+                        }
+                        guard.defer_destroy(head);
+                        Some(n.data.assume_init_read())
+                    })
+                    .map_err(|_| ())
+            },
+            None => Ok(None),
+        }
+    }
+
+    /// Attempts to pop a data node, if the data satisfies the given condition. `Ok(None)` if queue
+    /// is empty or the data does not satisfy the condition; `Err(())` if lost race to pop.
+    #[inline(always)]
+    fn pop_if_internal<F>(&self, condition: F, guard: &Guard) -> Result<Option<T>, ()>
+    where
+        T: Sync,
+        F: Fn(&T) -> bool,
+    {
+        let head = self.head.load(Acquire, guard);
+        let h = unsafe { head.deref() };
+        let next = h.next.load(Acquire, guard);
+        match unsafe { next.as_ref() } {
+            Some(n) if condition(unsafe { &*n.data.as_ptr() }) => unsafe {
+                self.head
+                    .compare_exchange(head, next, Release, Relaxed, guard)
+                    .map(|_| {
+                        let tail = self.tail.load(Relaxed, guard);
+                        // Advance the tail so that we don't retire a pointer to a reachable node.
+                        if head == tail {
+                            let _ = self
+                                .tail
+                                .compare_exchange(tail, next, Release, Relaxed, guard);
+                        }
+                        guard.defer_destroy(head);
+                        Some(n.data.assume_init_read())
+                    })
+                    .map_err(|_| ())
+            },
+            None | Some(_) => Ok(None),
+        }
+    }
+
+    /// Attempts to dequeue from the front.
+    ///
+    /// Returns `None` if the queue is observed to be empty.
+    pub(crate) fn try_pop(&self, guard: &Guard) -> Option<T> {
+        loop {
+            if let Ok(head) = self.pop_internal(guard) {
+                return head;
+            }
+        }
+    }
+
+    /// Attempts to dequeue from the front, if the item satisfies the given condition.
+    ///
+    /// Returns `None` if the queue is observed to be empty, or the head does not satisfy the given
+    /// condition.
+    pub(crate) fn try_pop_if<F>(&self, condition: F, guard: &Guard) -> Option<T>
+    where
+        T: Sync,
+        F: Fn(&T) -> bool,
+    {
+        loop {
+            if let Ok(head) = self.pop_if_internal(&condition, guard) {
+                return head;
+            }
+        }
+    }
+}
+
+impl<T> Drop for Queue<T> {
+    fn drop(&mut self) {
+        unsafe {
+            let guard = unprotected();
+
+            while self.try_pop(guard).is_some() {}
+
+            // Destroy the remaining sentinel node.
+            let sentinel = self.head.load(Relaxed, guard);
+            drop(sentinel.into_owned());
+        }
+    }
+}
+
+#[cfg(all(test, not(crossbeam_loom)))]
+mod test {
+    use super::*;
+    use crate::pin;
+    use crossbeam_utils::thread;
+
+    struct Queue<T> {
+        queue: super::Queue<T>,
+    }
+
+    impl<T> Queue<T> {
+        pub(crate) fn new() -> Queue<T> {
+            Queue {
+                queue: super::Queue::new(),
+            }
+        }
+
+        pub(crate) fn push(&self, t: T) {
+            let guard = &pin();
+            self.queue.push(t, guard);
+        }
+
+        pub(crate) fn is_empty(&self) -> bool {
+            let guard = &pin();
+            let head = self.queue.head.load(Acquire, guard);
+            let h = unsafe { head.deref() };
+            h.next.load(Acquire, guard).is_null()
+        }
+
+        pub(crate) fn try_pop(&self) -> Option<T> {
+            let guard = &pin();
+            self.queue.try_pop(guard)
+        }
+
+        pub(crate) fn pop(&self) -> T {
+            loop {
+                match self.try_pop() {
+                    None => continue,
+                    Some(t) => return t,
+                }
+            }
+        }
+    }
+
+    #[cfg(miri)]
+    const CONC_COUNT: i64 = 1000;
+    #[cfg(not(miri))]
+    const CONC_COUNT: i64 = 1000000;
+
+    #[test]
+    fn push_try_pop_1() {
+        let q: Queue<i64> = Queue::new();
+        assert!(q.is_empty());
+        q.push(37);
+        assert!(!q.is_empty());
+        assert_eq!(q.try_pop(), Some(37));
+        assert!(q.is_empty());
+    }
+
+    #[test]
+    fn push_try_pop_2() {
+        let q: Queue<i64> = Queue::new();
+        assert!(q.is_empty());
+        q.push(37);
+        q.push(48);
+        assert_eq!(q.try_pop(), Some(37));
+        assert!(!q.is_empty());
+        assert_eq!(q.try_pop(), Some(48));
+        assert!(q.is_empty());
+    }
+
+    #[test]
+    fn push_try_pop_many_seq() {
+        let q: Queue<i64> = Queue::new();
+        assert!(q.is_empty());
+        for i in 0..200 {
+            q.push(i)
+        }
+        assert!(!q.is_empty());
+        for i in 0..200 {
+            assert_eq!(q.try_pop(), Some(i));
+        }
+        assert!(q.is_empty());
+    }
+
+    #[test]
+    fn push_pop_1() {
+        let q: Queue<i64> = Queue::new();
+        assert!(q.is_empty());
+        q.push(37);
+        assert!(!q.is_empty());
+        assert_eq!(q.pop(), 37);
+        assert!(q.is_empty());
+    }
+
+    #[test]
+    fn push_pop_2() {
+        let q: Queue<i64> = Queue::new();
+        q.push(37);
+        q.push(48);
+        assert_eq!(q.pop(), 37);
+        assert_eq!(q.pop(), 48);
+    }
+
+    #[test]
+    fn push_pop_many_seq() {
+        let q: Queue<i64> = Queue::new();
+        assert!(q.is_empty());
+        for i in 0..200 {
+            q.push(i)
+        }
+        assert!(!q.is_empty());
+        for i in 0..200 {
+            assert_eq!(q.pop(), i);
+        }
+        assert!(q.is_empty());
+    }
+
+    #[test]
+    fn push_try_pop_many_spsc() {
+        let q: Queue<i64> = Queue::new();
+        assert!(q.is_empty());
+
+        thread::scope(|scope| {
+            scope.spawn(|_| {
+                let mut next = 0;
+
+                while next < CONC_COUNT {
+                    if let Some(elem) = q.try_pop() {
+                        assert_eq!(elem, next);
+                        next += 1;
+                    }
+                }
+            });
+
+            for i in 0..CONC_COUNT {
+                q.push(i)
+            }
+        })
+        .unwrap();
+    }
+
+    #[test]
+    fn push_try_pop_many_spmc() {
+        fn recv(_t: i32, q: &Queue<i64>) {
+            let mut cur = -1;
+            for _i in 0..CONC_COUNT {
+                if let Some(elem) = q.try_pop() {
+                    assert!(elem > cur);
+                    cur = elem;
+
+                    if cur == CONC_COUNT - 1 {
+                        break;
+                    }
+                }
+            }
+        }
+
+        let q: Queue<i64> = Queue::new();
+        assert!(q.is_empty());
+        thread::scope(|scope| {
+            for i in 0..3 {
+                let q = &q;
+                scope.spawn(move |_| recv(i, q));
+            }
+
+            scope.spawn(|_| {
+                for i in 0..CONC_COUNT {
+                    q.push(i);
+                }
+            });
+        })
+        .unwrap();
+    }
+
+    #[test]
+    fn push_try_pop_many_mpmc() {
+        enum LR {
+            Left(i64),
+            Right(i64),
+        }
+
+        let q: Queue<LR> = Queue::new();
+        assert!(q.is_empty());
+
+        thread::scope(|scope| {
+            for _t in 0..2 {
+                scope.spawn(|_| {
+                    for i in CONC_COUNT - 1..CONC_COUNT {
+                        q.push(LR::Left(i))
+                    }
+                });
+                scope.spawn(|_| {
+                    for i in CONC_COUNT - 1..CONC_COUNT {
+                        q.push(LR::Right(i))
+                    }
+                });
+                scope.spawn(|_| {
+                    let mut vl = vec![];
+                    let mut vr = vec![];
+                    for _i in 0..CONC_COUNT {
+                        match q.try_pop() {
+                            Some(LR::Left(x)) => vl.push(x),
+                            Some(LR::Right(x)) => vr.push(x),
+                            _ => {}
+                        }
+                    }
+
+                    let mut vl2 = vl.clone();
+                    let mut vr2 = vr.clone();
+                    vl2.sort_unstable();
+                    vr2.sort_unstable();
+
+                    assert_eq!(vl, vl2);
+                    assert_eq!(vr, vr2);
+                });
+            }
+        })
+        .unwrap();
+    }
+
+    #[test]
+    fn push_pop_many_spsc() {
+        let q: Queue<i64> = Queue::new();
+
+        thread::scope(|scope| {
+            scope.spawn(|_| {
+                let mut next = 0;
+                while next < CONC_COUNT {
+                    assert_eq!(q.pop(), next);
+                    next += 1;
+                }
+            });
+
+            for i in 0..CONC_COUNT {
+                q.push(i)
+            }
+        })
+        .unwrap();
+        assert!(q.is_empty());
+    }
+
+    #[test]
+    fn is_empty_dont_pop() {
+        let q: Queue<i64> = Queue::new();
+        q.push(20);
+        q.push(20);
+        assert!(!q.is_empty());
+        assert!(!q.is_empty());
+        assert!(q.try_pop().is_some());
+    }
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-epoch-0.9.18/tests/loom.rs

@@ -0,0 +1,157 @@
+#![cfg(crossbeam_loom)]
+
+use crossbeam_epoch as epoch;
+use loom_crate as loom;
+
+use epoch::*;
+use epoch::{Atomic, Owned};
+use loom::sync::atomic::Ordering::{self, Acquire, Relaxed, Release};
+use loom::sync::Arc;
+use loom::thread::spawn;
+use std::mem::ManuallyDrop;
+use std::ptr;
+
+#[test]
+fn it_works() {
+    loom::model(|| {
+        let collector = Collector::new();
+        let item: Atomic<String> = Atomic::from(Owned::new(String::from("boom")));
+        let item2 = item.clone();
+        let collector2 = collector.clone();
+        let guard = collector.register().pin();
+
+        let jh = loom::thread::spawn(move || {
+            let guard = collector2.register().pin();
+            guard.defer(move || {
+                // this isn't really safe, since other threads may still have pointers to the
+                // value, but in this limited test scenario it's okay, since we know the test won't
+                // access item after all the pins are released.
+                let mut item = unsafe { item2.into_owned() };
+                // mutate it as a second measure to make sure the assert_eq below would fail
+                item.retain(|c| c == 'o');
+                drop(item);
+            });
+        });
+
+        let item = item.load(Ordering::SeqCst, &guard);
+        // we pinned strictly before the call to defer_destroy,
+        // so item cannot have been dropped yet
+        assert_eq!(*unsafe { item.deref() }, "boom");
+        drop(guard);
+
+        jh.join().unwrap();
+
+        drop(collector);
+    })
+}
+
+#[test]
+fn treiber_stack() {
+    /// Treiber's lock-free stack.
+    ///
+    /// Usable with any number of producers and consumers.
+    #[derive(Debug)]
+    pub struct TreiberStack<T> {
+        head: Atomic<Node<T>>,
+    }
+
+    #[derive(Debug)]
+    struct Node<T> {
+        data: ManuallyDrop<T>,
+        next: Atomic<Node<T>>,
+    }
+
+    impl<T> TreiberStack<T> {
+        /// Creates a new, empty stack.
+        pub fn new() -> TreiberStack<T> {
+            TreiberStack {
+                head: Atomic::null(),
+            }
+        }
+
+        /// Pushes a value on top of the stack.
+        pub fn push(&self, t: T) {
+            let mut n = Owned::new(Node {
+                data: ManuallyDrop::new(t),
+                next: Atomic::null(),
+            });
+
+            let guard = epoch::pin();
+
+            loop {
+                let head = self.head.load(Relaxed, &guard);
+                n.next.store(head, Relaxed);
+
+                match self
+                    .head
+                    .compare_exchange(head, n, Release, Relaxed, &guard)
+                {
+                    Ok(_) => break,
+                    Err(e) => n = e.new,
+                }
+            }
+        }
+
+        /// Attempts to pop the top element from the stack.
+        ///
+        /// Returns `None` if the stack is empty.
+        pub fn pop(&self) -> Option<T> {
+            let guard = epoch::pin();
+            loop {
+                let head = self.head.load(Acquire, &guard);
+
+                match unsafe { head.as_ref() } {
+                    Some(h) => {
+                        let next = h.next.load(Relaxed, &guard);
+
+                        if self
+                            .head
+                            .compare_exchange(head, next, Relaxed, Relaxed, &guard)
+                            .is_ok()
+                        {
+                            unsafe {
+                                guard.defer_destroy(head);
+                                return Some(ManuallyDrop::into_inner(ptr::read(&(*h).data)));
+                            }
+                        }
+                    }
+                    None => return None,
+                }
+            }
+        }
+
+        /// Returns `true` if the stack is empty.
+        pub fn is_empty(&self) -> bool {
+            let guard = epoch::pin();
+            self.head.load(Acquire, &guard).is_null()
+        }
+    }
+
+    impl<T> Drop for TreiberStack<T> {
+        fn drop(&mut self) {
+            while self.pop().is_some() {}
+        }
+    }
+
+    loom::model(|| {
+        let stack1 = Arc::new(TreiberStack::new());
+        let stack2 = Arc::clone(&stack1);
+
+        // use 5 since it's greater than the 4 used for the sanitize feature
+        let jh = spawn(move || {
+            for i in 0..5 {
+                stack2.push(i);
+                assert!(stack2.pop().is_some());
+            }
+        });
+
+        for i in 0..5 {
+            stack1.push(i);
+            assert!(stack1.pop().is_some());
+        }
+
+        jh.join().unwrap();
+        assert!(stack1.pop().is_none());
+        assert!(stack1.is_empty());
+    });
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/ed25519-2.2.3/src/hex.rs

@@ -0,0 +1,87 @@
+//! Hexadecimal encoding support
+// TODO(tarcieri): use `base16ct`?
+
+use crate::{ComponentBytes, Error, Signature};
+use core::{fmt, str};
+
+/// Format a signature component as hex.
+pub(crate) struct ComponentFormatter<'a>(pub(crate) &'a ComponentBytes);
+
+impl fmt::Debug for ComponentFormatter<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "0x")?;
+
+        for byte in self.0 {
+            write!(f, "{:02x}", byte)?;
+        }
+
+        Ok(())
+    }
+}
+
+impl fmt::LowerHex for Signature {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        for component in [&self.R, &self.s] {
+            for byte in component {
+                write!(f, "{:02x}", byte)?;
+            }
+        }
+        Ok(())
+    }
+}
+
+impl fmt::UpperHex for Signature {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        for component in [&self.R, &self.s] {
+            for byte in component {
+                write!(f, "{:02X}", byte)?;
+            }
+        }
+        Ok(())
+    }
+}
+
+/// Decode a signature from hexadecimal.
+///
+/// Upper and lower case hexadecimal are both accepted, however mixed case is
+/// rejected.
+// TODO(tarcieri): use `base16ct`?
+impl str::FromStr for Signature {
+    type Err = Error;
+
+    fn from_str(hex: &str) -> signature::Result<Self> {
+        if hex.as_bytes().len() != Signature::BYTE_SIZE * 2 {
+            return Err(Error::new());
+        }
+
+        let mut upper_case = None;
+
+        // Ensure all characters are valid and case is not mixed
+        for &byte in hex.as_bytes() {
+            match byte {
+                b'0'..=b'9' => (),
+                b'a'..=b'z' => match upper_case {
+                    Some(true) => return Err(Error::new()),
+                    Some(false) => (),
+                    None => upper_case = Some(false),
+                },
+                b'A'..=b'Z' => match upper_case {
+                    Some(true) => (),
+                    Some(false) => return Err(Error::new()),
+                    None => upper_case = Some(true),
+                },
+                _ => return Err(Error::new()),
+            }
+        }
+
+        let mut result = [0u8; Self::BYTE_SIZE];
+        for (digit, byte) in hex.as_bytes().chunks_exact(2).zip(result.iter_mut()) {
+            *byte = str::from_utf8(digit)
+                .ok()
+                .and_then(|s| u8::from_str_radix(s, 16).ok())
+                .ok_or_else(Error::new)?;
+        }
+
+        Self::try_from(&result[..])
+    }
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/ed25519-2.2.3/src/lib.rs

@@ -0,0 +1,419 @@
+#![no_std]
+#![cfg_attr(docsrs, feature(doc_auto_cfg))]
+#![doc = include_str!("../README.md")]
+#![doc(html_logo_url = "https://raw.githubusercontent.com/RustCrypto/meta/master/logo_small.png")]
+#![allow(non_snake_case)]
+#![forbid(unsafe_code)]
+#![warn(
+    clippy::unwrap_used,
+    missing_docs,
+    rust_2018_idioms,
+    unused_lifetimes,
+    unused_qualifications
+)]
+
+//! # Using Ed25519 generically over algorithm implementations/providers
+//!
+//! By using the `ed25519` crate, you can write code which signs and verifies
+//! messages using the Ed25519 signature algorithm generically over any
+//! supported Ed25519 implementation (see the next section for available
+//! providers).
+//!
+//! This allows consumers of your code to plug in whatever implementation they
+//! want to use without having to add all potential Ed25519 libraries you'd
+//! like to support as optional dependencies.
+//!
+//! ## Example
+//!
+//! ```
+//! use ed25519::signature::{Signer, Verifier};
+//!
+//! pub struct HelloSigner<S>
+//! where
+//!     S: Signer<ed25519::Signature>
+//! {
+//!     pub signing_key: S
+//! }
+//!
+//! impl<S> HelloSigner<S>
+//! where
+//!     S: Signer<ed25519::Signature>
+//! {
+//!     pub fn sign(&self, person: &str) -> ed25519::Signature {
+//!         // NOTE: use `try_sign` if you'd like to be able to handle
+//!         // errors from external signing services/devices (e.g. HSM/KMS)
+//!         // <https://docs.rs/signature/latest/signature/trait.Signer.html#tymethod.try_sign>
+//!         self.signing_key.sign(format_message(person).as_bytes())
+//!     }
+//! }
+//!
+//! pub struct HelloVerifier<V> {
+//!     pub verifying_key: V
+//! }
+//!
+//! impl<V> HelloVerifier<V>
+//! where
+//!     V: Verifier<ed25519::Signature>
+//! {
+//!     pub fn verify(
+//!         &self,
+//!         person: &str,
+//!         signature: &ed25519::Signature
+//!     ) -> Result<(), ed25519::Error> {
+//!         self.verifying_key.verify(format_message(person).as_bytes(), signature)
+//!     }
+//! }
+//!
+//! fn format_message(person: &str) -> String {
+//!     format!("Hello, {}!", person)
+//! }
+//! ```
+//!
+//! ## Using above example with `ed25519-dalek`
+//!
+//! The [`ed25519-dalek`] crate natively supports the [`ed25519::Signature`][`Signature`]
+//! type defined in this crate along with the [`signature::Signer`] and
+//! [`signature::Verifier`] traits.
+//!
+//! Below is an example of how a hypothetical consumer of the code above can
+//! instantiate and use the previously defined `HelloSigner` and `HelloVerifier`
+//! types with [`ed25519-dalek`] as the signing/verification provider:
+//!
+//! *NOTE: requires [`ed25519-dalek`] v2 or newer for compatibility with
+//! `ed25519` v2.2+*.
+//!
+//! ```
+//! use ed25519_dalek::{Signer, Verifier, Signature};
+//! #
+//! # pub struct HelloSigner<S>
+//! # where
+//! #     S: Signer<Signature>
+//! # {
+//! #     pub signing_key: S
+//! # }
+//! #
+//! # impl<S> HelloSigner<S>
+//! # where
+//! #     S: Signer<Signature>
+//! # {
+//! #     pub fn sign(&self, person: &str) -> Signature {
+//! #         // NOTE: use `try_sign` if you'd like to be able to handle
+//! #         // errors from external signing services/devices (e.g. HSM/KMS)
+//! #         // <https://docs.rs/signature/latest/signature/trait.Signer.html#tymethod.try_sign>
+//! #         self.signing_key.sign(format_message(person).as_bytes())
+//! #     }
+//! # }
+//! #
+//! # pub struct HelloVerifier<V> {
+//! #     pub verifying_key: V
+//! # }
+//! #
+//! # impl<V> HelloVerifier<V>
+//! # where
+//! #     V: Verifier<Signature>
+//! # {
+//! #     pub fn verify(
+//! #         &self,
+//! #         person: &str,
+//! #         signature: &Signature
+//! #     ) -> Result<(), ed25519::Error> {
+//! #         self.verifying_key.verify(format_message(person).as_bytes(), signature)
+//! #     }
+//! # }
+//! #
+//! # fn format_message(person: &str) -> String {
+//! #     format!("Hello, {}!", person)
+//! # }
+//! use rand_core::OsRng; // Requires the `std` feature of `rand_core`
+//!
+//! /// `HelloSigner` defined above instantiated with `ed25519-dalek` as
+//! /// the signing provider.
+//! pub type DalekHelloSigner = HelloSigner<ed25519_dalek::SigningKey>;
+//!
+//! let signing_key = ed25519_dalek::SigningKey::generate(&mut OsRng);
+//! let signer = DalekHelloSigner { signing_key };
+//! let person = "Joe"; // Message to sign
+//! let signature = signer.sign(person);
+//!
+//! /// `HelloVerifier` defined above instantiated with `ed25519-dalek`
+//! /// as the signature verification provider.
+//! pub type DalekHelloVerifier = HelloVerifier<ed25519_dalek::VerifyingKey>;
+//!
+//! let verifying_key: ed25519_dalek::VerifyingKey = signer.signing_key.verifying_key();
+//! let verifier = DalekHelloVerifier { verifying_key };
+//! assert!(verifier.verify(person, &signature).is_ok());
+//! ```
+//!
+//! ## Using above example with `ring-compat`
+//!
+//! The [`ring-compat`] crate provides wrappers for [*ring*] which implement
+//! the [`signature::Signer`] and [`signature::Verifier`] traits for
+//! [`ed25519::Signature`][`Signature`].
+//!
+//! Below is an example of how a hypothetical consumer of the code above can
+//! instantiate and use the previously defined `HelloSigner` and `HelloVerifier`
+//! types with [`ring-compat`] as the signing/verification provider:
+//!
+//! ```
+//! use ring_compat::signature::{
+//!     ed25519::{Signature, SigningKey, VerifyingKey},
+//!     Signer, Verifier
+//! };
+//! #
+//! # pub struct HelloSigner<S>
+//! # where
+//! #     S: Signer<Signature>
+//! # {
+//! #     pub signing_key: S
+//! # }
+//! #
+//! # impl<S> HelloSigner<S>
+//! # where
+//! #     S: Signer<Signature>
+//! # {
+//! #     pub fn sign(&self, person: &str) -> Signature {
+//! #         // NOTE: use `try_sign` if you'd like to be able to handle
+//! #         // errors from external signing services/devices (e.g. HSM/KMS)
+//! #         // <https://docs.rs/signature/latest/signature/trait.Signer.html#tymethod.try_sign>
+//! #         self.signing_key.sign(format_message(person).as_bytes())
+//! #     }
+//! # }
+//! #
+//! # pub struct HelloVerifier<V> {
+//! #     pub verifying_key: V
+//! # }
+//! #
+//! # impl<V> HelloVerifier<V>
+//! # where
+//! #     V: Verifier<Signature>
+//! # {
+//! #     pub fn verify(
+//! #         &self,
+//! #         person: &str,
+//! #         signature: &Signature
+//! #     ) -> Result<(), ed25519::Error> {
+//! #         self.verifying_key.verify(format_message(person).as_bytes(), signature)
+//! #     }
+//! # }
+//! #
+//! # fn format_message(person: &str) -> String {
+//! #     format!("Hello, {}!", person)
+//! # }
+//! use rand_core::{OsRng, RngCore}; // Requires the `std` feature of `rand_core`
+//!
+//! /// `HelloSigner` defined above instantiated with *ring* as
+//! /// the signing provider.
+//! pub type RingHelloSigner = HelloSigner<SigningKey>;
+//!
+//! let mut ed25519_seed = [0u8; 32];
+//! OsRng.fill_bytes(&mut ed25519_seed);
+//!
+//! let signing_key = SigningKey::from_bytes(&ed25519_seed);
+//! let verifying_key = signing_key.verifying_key();
+//!
+//! let signer = RingHelloSigner { signing_key };
+//! let person = "Joe"; // Message to sign
+//! let signature = signer.sign(person);
+//!
+//! /// `HelloVerifier` defined above instantiated with *ring*
+//! /// as the signature verification provider.
+//! pub type RingHelloVerifier = HelloVerifier<VerifyingKey>;
+//!
+//! let verifier = RingHelloVerifier { verifying_key };
+//! assert!(verifier.verify(person, &signature).is_ok());
+//! ```
+//!
+//! # Available Ed25519 providers
+//!
+//! The following libraries support the types/traits from the `ed25519` crate:
+//!
+//! - [`ed25519-dalek`] - mature pure Rust implementation of Ed25519
+//! - [`ring-compat`] - compatibility wrapper for [*ring*]
+//! - [`yubihsm`] - host-side client library for YubiHSM2 devices from Yubico
+//!
+//! [`ed25519-dalek`]: https://docs.rs/ed25519-dalek
+//! [`ring-compat`]: https://docs.rs/ring-compat
+//! [*ring*]: https://github.com/briansmith/ring
+//! [`yubihsm`]: https://github.com/iqlusioninc/yubihsm.rs/blob/develop/README.md
+//!
+//! # Features
+//!
+//! The following features are presently supported:
+//!
+//! - `pkcs8`: support for decoding/encoding PKCS#8-formatted private keys using the
+//!   [`KeypairBytes`] type.
+//! - `std` *(default)*: Enable `std` support in [`signature`], which currently only affects whether
+//!   [`signature::Error`] implements `std::error::Error`.
+//! - `serde`: Implement `serde::Deserialize` and `serde::Serialize` for [`Signature`]. Signatures
+//!   are serialized as their bytes.
+//! - `serde_bytes`: Implement `serde_bytes::Deserialize` and `serde_bytes::Serialize` for
+//!   [`Signature`]. This enables more compact representations for formats with an efficient byte
+//!   array representation. As per the `serde_bytes` documentation, this can most easily be realised
+//!   using the `#[serde(with = "serde_bytes")]` annotation, e.g.:
+//!
+//!   ```ignore
+//!   # use ed25519::Signature;
+//!   # use serde::{Deserialize, Serialize};
+//!   #[derive(Deserialize, Serialize)]
+//!   #[serde(transparent)]
+//!   struct SignatureAsBytes(#[serde(with = "serde_bytes")] Signature);
+//!   ```
+
+#[cfg(feature = "alloc")]
+extern crate alloc;
+
+mod hex;
+
+#[cfg(feature = "pkcs8")]
+pub mod pkcs8;
+
+#[cfg(feature = "serde")]
+mod serde;
+
+pub use signature::{self, Error, SignatureEncoding};
+
+#[cfg(feature = "pkcs8")]
+pub use crate::pkcs8::{KeypairBytes, PublicKeyBytes};
+
+use core::fmt;
+
+#[cfg(feature = "alloc")]
+use alloc::vec::Vec;
+
+/// Size of a single component of an Ed25519 signature.
+const COMPONENT_SIZE: usize = 32;
+
+/// Size of an `R` or `s` component of an Ed25519 signature when serialized
+/// as bytes.
+pub type ComponentBytes = [u8; COMPONENT_SIZE];
+
+/// Ed25519 signature serialized as a byte array.
+pub type SignatureBytes = [u8; Signature::BYTE_SIZE];
+
+/// Ed25519 signature.
+///
+/// This type represents a container for the byte serialization of an Ed25519
+/// signature, and does not necessarily represent well-formed field or curve
+/// elements.
+///
+/// Signature verification libraries are expected to reject invalid field
+/// elements at the time a signature is verified.
+#[derive(Copy, Clone, Eq, PartialEq)]
+#[repr(C)]
+pub struct Signature {
+    R: ComponentBytes,
+    s: ComponentBytes,
+}
+
+impl Signature {
+    /// Size of an encoded Ed25519 signature in bytes.
+    pub const BYTE_SIZE: usize = COMPONENT_SIZE * 2;
+
+    /// Parse an Ed25519 signature from a byte slice.
+    pub fn from_bytes(bytes: &SignatureBytes) -> Self {
+        let mut R = ComponentBytes::default();
+        let mut s = ComponentBytes::default();
+
+        let components = bytes.split_at(COMPONENT_SIZE);
+        R.copy_from_slice(components.0);
+        s.copy_from_slice(components.1);
+
+        Self { R, s }
+    }
+
+    /// Parse an Ed25519 signature from its `R` and `s` components.
+    pub fn from_components(R: ComponentBytes, s: ComponentBytes) -> Self {
+        Self { R, s }
+    }
+
+    /// Parse an Ed25519 signature from a byte slice.
+    ///
+    /// # Returns
+    /// - `Ok` on success
+    /// - `Err` if the input byte slice is not 64-bytes
+    pub fn from_slice(bytes: &[u8]) -> signature::Result<Self> {
+        SignatureBytes::try_from(bytes)
+            .map(Into::into)
+            .map_err(|_| Error::new())
+    }
+
+    /// Bytes for the `R` component of a signature.
+    pub fn r_bytes(&self) -> &ComponentBytes {
+        &self.R
+    }
+
+    /// Bytes for the `s` component of a signature.
+    pub fn s_bytes(&self) -> &ComponentBytes {
+        &self.s
+    }
+
+    /// Return the inner byte array.
+    pub fn to_bytes(&self) -> SignatureBytes {
+        let mut ret = [0u8; Self::BYTE_SIZE];
+        let (R, s) = ret.split_at_mut(COMPONENT_SIZE);
+        R.copy_from_slice(&self.R);
+        s.copy_from_slice(&self.s);
+        ret
+    }
+
+    /// Convert this signature into a byte vector.
+    #[cfg(feature = "alloc")]
+    pub fn to_vec(&self) -> Vec<u8> {
+        self.to_bytes().to_vec()
+    }
+}
+
+impl SignatureEncoding for Signature {
+    type Repr = SignatureBytes;
+
+    fn to_bytes(&self) -> SignatureBytes {
+        self.to_bytes()
+    }
+}
+
+impl From<Signature> for SignatureBytes {
+    fn from(sig: Signature) -> SignatureBytes {
+        sig.to_bytes()
+    }
+}
+
+impl From<&Signature> for SignatureBytes {
+    fn from(sig: &Signature) -> SignatureBytes {
+        sig.to_bytes()
+    }
+}
+
+impl From<SignatureBytes> for Signature {
+    fn from(bytes: SignatureBytes) -> Self {
+        Signature::from_bytes(&bytes)
+    }
+}
+
+impl From<&SignatureBytes> for Signature {
+    fn from(bytes: &SignatureBytes) -> Self {
+        Signature::from_bytes(bytes)
+    }
+}
+
+impl TryFrom<&[u8]> for Signature {
+    type Error = Error;
+
+    fn try_from(bytes: &[u8]) -> signature::Result<Self> {
+        Self::from_slice(bytes)
+    }
+}
+
+impl fmt::Debug for Signature {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("ed25519::Signature")
+            .field("R", &hex::ComponentFormatter(self.r_bytes()))
+            .field("s", &hex::ComponentFormatter(self.s_bytes()))
+            .finish()
+    }
+}
+
+impl fmt::Display for Signature {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{:X}", self)
+    }
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/ed25519-2.2.3/src/pkcs8.rs

@@ -0,0 +1,356 @@
+//! PKCS#8 private key support.
+//!
+//! Implements Ed25519 PKCS#8 private keys as described in RFC8410 Section 7:
+//! <https://datatracker.ietf.org/doc/html/rfc8410#section-7>
+//!
+//! ## SemVer Notes
+//!
+//! The `pkcs8` module of this crate is exempted from SemVer as it uses a
+//! pre-1.0 dependency (the `pkcs8` crate).
+//!
+//! However, breaking changes to this module will be accompanied by a minor
+//! version bump.
+//!
+//! Please lock to a specific minor version of the `ed25519` crate to avoid
+//! breaking changes when using this module.
+
+pub use pkcs8::{
+    spki, DecodePrivateKey, DecodePublicKey, Error, ObjectIdentifier, PrivateKeyInfo, Result,
+};
+
+#[cfg(feature = "alloc")]
+pub use pkcs8::{spki::EncodePublicKey, EncodePrivateKey};
+
+#[cfg(feature = "alloc")]
+pub use pkcs8::der::{asn1::BitStringRef, Document, SecretDocument};
+
+use core::fmt;
+
+#[cfg(feature = "pem")]
+use {
+    alloc::string::{String, ToString},
+    core::str,
+};
+
+#[cfg(feature = "zeroize")]
+use zeroize::Zeroize;
+
+/// Algorithm [`ObjectIdentifier`] for the Ed25519 digital signature algorithm
+/// (`id-Ed25519`).
+///
+/// <http://oid-info.com/get/1.3.101.112>
+pub const ALGORITHM_OID: ObjectIdentifier = ObjectIdentifier::new_unwrap("1.3.101.112");
+
+/// Ed25519 Algorithm Identifier.
+pub const ALGORITHM_ID: pkcs8::AlgorithmIdentifierRef<'static> = pkcs8::AlgorithmIdentifierRef {
+    oid: ALGORITHM_OID,
+    parameters: None,
+};
+
+/// Ed25519 keypair serialized as bytes.
+///
+/// This type is primarily useful for decoding/encoding PKCS#8 private key
+/// files (either DER or PEM) encoded using the following traits:
+///
+/// - [`DecodePrivateKey`]: decode DER or PEM encoded PKCS#8 private key.
+/// - [`EncodePrivateKey`]: encode DER or PEM encoded PKCS#8 private key.
+///
+/// PKCS#8 private key files encoded with PEM begin with:
+///
+/// ```text
+/// -----BEGIN PRIVATE KEY-----
+/// ```
+///
+/// Note that this type operates on raw bytes and performs no validation that
+/// keys represent valid Ed25519 field elements.
+pub struct KeypairBytes {
+    /// Ed25519 secret key.
+    ///
+    /// Little endian serialization of an element of the Curve25519 scalar
+    /// field, prior to "clamping" (i.e. setting/clearing bits to ensure the
+    /// scalar is actually a valid field element)
+    pub secret_key: [u8; Self::BYTE_SIZE / 2],
+
+    /// Ed25519 public key (if available).
+    ///
+    /// Compressed Edwards-y encoded curve point.
+    pub public_key: Option<PublicKeyBytes>,
+}
+
+impl KeypairBytes {
+    /// Size of an Ed25519 keypair when serialized as bytes.
+    const BYTE_SIZE: usize = 64;
+
+    /// Parse raw keypair from a 64-byte input.
+    pub fn from_bytes(bytes: &[u8; Self::BYTE_SIZE]) -> Self {
+        let (sk, pk) = bytes.split_at(Self::BYTE_SIZE / 2);
+
+        Self {
+            secret_key: sk.try_into().expect("secret key size error"),
+            public_key: Some(PublicKeyBytes(
+                pk.try_into().expect("public key size error"),
+            )),
+        }
+    }
+
+    /// Serialize as a 64-byte keypair.
+    ///
+    /// # Returns
+    ///
+    /// - `Some(bytes)` if the `public_key` is present.
+    /// - `None` if the `public_key` is absent (i.e. `None`).
+    pub fn to_bytes(&self) -> Option<[u8; Self::BYTE_SIZE]> {
+        if let Some(public_key) = &self.public_key {
+            let mut result = [0u8; Self::BYTE_SIZE];
+            let (sk, pk) = result.split_at_mut(Self::BYTE_SIZE / 2);
+            sk.copy_from_slice(&self.secret_key);
+            pk.copy_from_slice(public_key.as_ref());
+            Some(result)
+        } else {
+            None
+        }
+    }
+}
+
+impl Drop for KeypairBytes {
+    fn drop(&mut self) {
+        #[cfg(feature = "zeroize")]
+        self.secret_key.zeroize()
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl EncodePrivateKey for KeypairBytes {
+    fn to_pkcs8_der(&self) -> Result<SecretDocument> {
+        // Serialize private key as nested OCTET STRING
+        let mut private_key = [0u8; 2 + (Self::BYTE_SIZE / 2)];
+        private_key[0] = 0x04;
+        private_key[1] = 0x20;
+        private_key[2..].copy_from_slice(&self.secret_key);
+
+        let private_key_info = PrivateKeyInfo {
+            algorithm: ALGORITHM_ID,
+            private_key: &private_key,
+            public_key: self.public_key.as_ref().map(|pk| pk.0.as_slice()),
+        };
+
+        let result = SecretDocument::encode_msg(&private_key_info)?;
+
+        #[cfg(feature = "zeroize")]
+        private_key.zeroize();
+
+        Ok(result)
+    }
+}
+
+impl TryFrom<PrivateKeyInfo<'_>> for KeypairBytes {
+    type Error = Error;
+
+    fn try_from(private_key: PrivateKeyInfo<'_>) -> Result<Self> {
+        private_key.algorithm.assert_algorithm_oid(ALGORITHM_OID)?;
+
+        if private_key.algorithm.parameters.is_some() {
+            return Err(Error::ParametersMalformed);
+        }
+
+        // Ed25519 PKCS#8 keys are represented as a nested OCTET STRING
+        // (i.e. an OCTET STRING within an OCTET STRING).
+        //
+        // This match statement checks and removes the inner OCTET STRING
+        // header value:
+        //
+        // - 0x04: OCTET STRING tag
+        // - 0x20: 32-byte length
+        let secret_key = match private_key.private_key {
+            [0x04, 0x20, rest @ ..] => rest.try_into().map_err(|_| Error::KeyMalformed),
+            _ => Err(Error::KeyMalformed),
+        }?;
+
+        let public_key = private_key
+            .public_key
+            .map(|bytes| bytes.try_into().map_err(|_| Error::KeyMalformed))
+            .transpose()?
+            .map(PublicKeyBytes);
+
+        Ok(Self {
+            secret_key,
+            public_key,
+        })
+    }
+}
+
+impl TryFrom<&[u8]> for KeypairBytes {
+    type Error = Error;
+
+    fn try_from(der_bytes: &[u8]) -> Result<Self> {
+        Self::from_pkcs8_der(der_bytes)
+    }
+}
+
+impl fmt::Debug for KeypairBytes {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("KeypairBytes")
+            .field("public_key", &self.public_key)
+            .finish_non_exhaustive()
+    }
+}
+
+#[cfg(feature = "pem")]
+impl str::FromStr for KeypairBytes {
+    type Err = Error;
+
+    fn from_str(pem: &str) -> Result<Self> {
+        Self::from_pkcs8_pem(pem)
+    }
+}
+
+/// Ed25519 public key serialized as bytes.
+///
+/// This type is primarily useful for decoding/encoding SPKI public key
+/// files (either DER or PEM) encoded using the following traits:
+///
+/// - [`DecodePublicKey`]: decode DER or PEM encoded PKCS#8 private key.
+/// - [`EncodePublicKey`]: encode DER or PEM encoded PKCS#8 private key.
+///
+/// SPKI public key files encoded with PEM begin with:
+///
+/// ```text
+/// -----BEGIN PUBLIC KEY-----
+/// ```
+///
+/// Note that this type operates on raw bytes and performs no validation that
+/// public keys represent valid compressed Ed25519 y-coordinates.
+#[derive(Clone, Copy, Eq, PartialEq)]
+pub struct PublicKeyBytes(pub [u8; Self::BYTE_SIZE]);
+
+impl PublicKeyBytes {
+    /// Size of an Ed25519 public key when serialized as bytes.
+    const BYTE_SIZE: usize = 32;
+
+    /// Returns the raw bytes of the public key.
+    pub fn to_bytes(&self) -> [u8; Self::BYTE_SIZE] {
+        self.0
+    }
+}
+
+impl AsRef<[u8; Self::BYTE_SIZE]> for PublicKeyBytes {
+    fn as_ref(&self) -> &[u8; Self::BYTE_SIZE] {
+        &self.0
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl EncodePublicKey for PublicKeyBytes {
+    fn to_public_key_der(&self) -> spki::Result<Document> {
+        pkcs8::SubjectPublicKeyInfoRef {
+            algorithm: ALGORITHM_ID,
+            subject_public_key: BitStringRef::new(0, &self.0)?,
+        }
+        .try_into()
+    }
+}
+
+impl TryFrom<spki::SubjectPublicKeyInfoRef<'_>> for PublicKeyBytes {
+    type Error = spki::Error;
+
+    fn try_from(spki: spki::SubjectPublicKeyInfoRef<'_>) -> spki::Result<Self> {
+        spki.algorithm.assert_algorithm_oid(ALGORITHM_OID)?;
+
+        if spki.algorithm.parameters.is_some() {
+            return Err(spki::Error::KeyMalformed);
+        }
+
+        spki.subject_public_key
+            .as_bytes()
+            .ok_or(spki::Error::KeyMalformed)?
+            .try_into()
+            .map(Self)
+            .map_err(|_| spki::Error::KeyMalformed)
+    }
+}
+
+impl TryFrom<&[u8]> for PublicKeyBytes {
+    type Error = spki::Error;
+
+    fn try_from(der_bytes: &[u8]) -> spki::Result<Self> {
+        Self::from_public_key_der(der_bytes)
+    }
+}
+
+impl TryFrom<KeypairBytes> for PublicKeyBytes {
+    type Error = spki::Error;
+
+    fn try_from(keypair: KeypairBytes) -> spki::Result<PublicKeyBytes> {
+        PublicKeyBytes::try_from(&keypair)
+    }
+}
+
+impl TryFrom<&KeypairBytes> for PublicKeyBytes {
+    type Error = spki::Error;
+
+    fn try_from(keypair: &KeypairBytes) -> spki::Result<PublicKeyBytes> {
+        keypair.public_key.ok_or(spki::Error::KeyMalformed)
+    }
+}
+
+impl fmt::Debug for PublicKeyBytes {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("PublicKeyBytes(")?;
+
+        for &byte in self.as_ref() {
+            write!(f, "{:02X}", byte)?;
+        }
+
+        f.write_str(")")
+    }
+}
+
+#[cfg(feature = "pem")]
+impl str::FromStr for PublicKeyBytes {
+    type Err = spki::Error;
+
+    fn from_str(pem: &str) -> spki::Result<Self> {
+        Self::from_public_key_pem(pem)
+    }
+}
+
+#[cfg(feature = "pem")]
+impl ToString for PublicKeyBytes {
+    fn to_string(&self) -> String {
+        self.to_public_key_pem(Default::default())
+            .expect("PEM serialization error")
+    }
+}
+
+#[cfg(feature = "pem")]
+#[cfg(test)]
+mod tests {
+    use super::{KeypairBytes, PublicKeyBytes};
+    use hex_literal::hex;
+
+    const SECRET_KEY_BYTES: [u8; 32] =
+        hex!("D4EE72DBF913584AD5B6D8F1F769F8AD3AFE7C28CBF1D4FBE097A88F44755842");
+
+    const PUBLIC_KEY_BYTES: [u8; 32] =
+        hex!("19BF44096984CDFE8541BAC167DC3B96C85086AA30B6B6CB0C5C38AD703166E1");
+
+    #[test]
+    fn to_bytes() {
+        let valid_keypair = KeypairBytes {
+            secret_key: SECRET_KEY_BYTES,
+            public_key: Some(PublicKeyBytes(PUBLIC_KEY_BYTES)),
+        };
+
+        assert_eq!(
+            valid_keypair.to_bytes().unwrap(),
+            hex!("D4EE72DBF913584AD5B6D8F1F769F8AD3AFE7C28CBF1D4FBE097A88F4475584219BF44096984CDFE8541BAC167DC3B96C85086AA30B6B6CB0C5C38AD703166E1")
+        );
+
+        let invalid_keypair = KeypairBytes {
+            secret_key: SECRET_KEY_BYTES,
+            public_key: None,
+        };
+
+        assert_eq!(invalid_keypair.to_bytes(), None);
+    }
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/ed25519-2.2.3/src/serde.rs

@@ -0,0 +1,121 @@
+//! `serde` support.
+
+use crate::{Signature, SignatureBytes};
+use ::serde::{de, ser, Deserialize, Serialize};
+use core::fmt;
+
+impl Serialize for Signature {
+    fn serialize<S: ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        use ser::SerializeTuple;
+
+        let mut seq = serializer.serialize_tuple(Signature::BYTE_SIZE)?;
+
+        for byte in self.to_bytes() {
+            seq.serialize_element(&byte)?;
+        }
+
+        seq.end()
+    }
+}
+
+// serde lacks support for deserializing arrays larger than 32-bytes
+// see: <https://github.com/serde-rs/serde/issues/631>
+impl<'de> Deserialize<'de> for Signature {
+    fn deserialize<D: de::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        struct ByteArrayVisitor;
+
+        impl<'de> de::Visitor<'de> for ByteArrayVisitor {
+            type Value = [u8; Signature::BYTE_SIZE];
+
+            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+                formatter.write_str("bytestring of length 64")
+            }
+
+            fn visit_seq<A>(self, mut seq: A) -> Result<[u8; Signature::BYTE_SIZE], A::Error>
+            where
+                A: de::SeqAccess<'de>,
+            {
+                use de::Error;
+                let mut arr = [0u8; Signature::BYTE_SIZE];
+
+                for (i, byte) in arr.iter_mut().enumerate() {
+                    *byte = seq
+                        .next_element()?
+                        .ok_or_else(|| Error::invalid_length(i, &self))?;
+                }
+
+                Ok(arr)
+            }
+        }
+
+        deserializer
+            .deserialize_tuple(Signature::BYTE_SIZE, ByteArrayVisitor)
+            .map(Into::into)
+    }
+}
+
+#[cfg(feature = "serde_bytes")]
+impl serde_bytes::Serialize for Signature {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        serializer.serialize_bytes(&self.to_bytes())
+    }
+}
+
+#[cfg(feature = "serde_bytes")]
+impl<'de> serde_bytes::Deserialize<'de> for Signature {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: de::Deserializer<'de>,
+    {
+        struct ByteArrayVisitor;
+
+        impl<'de> de::Visitor<'de> for ByteArrayVisitor {
+            type Value = SignatureBytes;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+                formatter.write_str("bytestring of length 64")
+            }
+
+            fn visit_bytes<E>(self, bytes: &[u8]) -> Result<Self::Value, E>
+            where
+                E: de::Error,
+            {
+                use de::Error;
+
+                bytes
+                    .try_into()
+                    .map_err(|_| Error::invalid_length(bytes.len(), &self))
+            }
+        }
+
+        deserializer
+            .deserialize_bytes(ByteArrayVisitor)
+            .map(Into::into)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{Signature, SignatureBytes};
+    use hex_literal::hex;
+
+    const SIGNATURE_BYTES: SignatureBytes = hex!(
+        "
+        e5564300c360ac729086e2cc806e828a
+        84877f1eb8e5d974d873e06522490155
+        5fb8821590a33bacc61e39701cf9b46b
+        d25bf5f0595bbe24655141438e7a100b
+        "
+    );
+
+    #[test]
+    fn round_trip() {
+        let signature = Signature::from_bytes(&SIGNATURE_BYTES);
+        let serialized = bincode::serialize(&signature).unwrap();
+        let deserialized = bincode::deserialize(&serialized).unwrap();
+        assert_eq!(signature, deserialized);
+    }
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/ed25519-2.2.3/tests/examples/pkcs8-v1.pem

@@ -0,0 +1,3 @@
+-----BEGIN PRIVATE KEY-----
+MC4CAQAwBQYDK2VwBCIEINTuctv5E1hK1bbY8fdp+K06/nwoy/HU++CXqI9EdVhC
+-----END PRIVATE KEY-----

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/ed25519-2.2.3/tests/examples/pkcs8-v2.pem

@@ -0,0 +1,5 @@
+-----BEGIN PRIVATE KEY-----
+MHICAQEwBQYDK2VwBCIEINTuctv5E1hK1bbY8fdp+K06/nwoy/HU++CXqI9EdVhC
+oB8wHQYKKoZIhvcNAQkJFDEPDA1DdXJkbGUgQ2hhaXJzgSEAGb9ECWmEzf6FQbrB
+Z9w7lshQhqowtrbLDFw4rXAxZuE=
+-----END PRIVATE KEY------

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/ed25519-2.2.3/tests/examples/pubkey.pem

@@ -0,0 +1,3 @@
+-----BEGIN PUBLIC KEY-----
+MCowBQYDK2VwAyEAGb9ECWmEzf6FQbrBZ9w7lshQhqowtrbLDFw4rXAxZuE=
+-----END PUBLIC KEY-----

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/ed25519-2.2.3/tests/hex.rs

@@ -0,0 +1,50 @@
+//! Hexadecimal display/serialization tests.
+
+use ed25519::Signature;
+use hex_literal::hex;
+use std::str::FromStr;
+
+/// Test 1 signature from RFC 8032 § 7.1
+/// <https://datatracker.ietf.org/doc/html/rfc8032#section-7.1>
+const TEST_1_SIGNATURE: [u8; Signature::BYTE_SIZE] = hex!(
+    "e5564300c360ac729086e2cc806e828a
+     84877f1eb8e5d974d873e06522490155
+     5fb8821590a33bacc61e39701cf9b46b
+     d25bf5f0595bbe24655141438e7a100b"
+);
+
+#[test]
+fn display() {
+    let sig = Signature::from_bytes(&TEST_1_SIGNATURE);
+    assert_eq!(sig.to_string(), "E5564300C360AC729086E2CC806E828A84877F1EB8E5D974D873E065224901555FB8821590A33BACC61E39701CF9B46BD25BF5F0595BBE24655141438E7A100B")
+}
+
+#[test]
+fn lower_hex() {
+    let sig = Signature::from_bytes(&TEST_1_SIGNATURE);
+    assert_eq!(format!("{:x}", sig), "e5564300c360ac729086e2cc806e828a84877f1eb8e5d974d873e065224901555fb8821590a33bacc61e39701cf9b46bd25bf5f0595bbe24655141438e7a100b")
+}
+
+#[test]
+fn upper_hex() {
+    let sig = Signature::from_bytes(&TEST_1_SIGNATURE);
+    assert_eq!(format!("{:X}", sig), "E5564300C360AC729086E2CC806E828A84877F1EB8E5D974D873E065224901555FB8821590A33BACC61E39701CF9B46BD25BF5F0595BBE24655141438E7A100B")
+}
+
+#[test]
+fn from_str_lower() {
+    let sig = Signature::from_str("e5564300c360ac729086e2cc806e828a84877f1eb8e5d974d873e065224901555fb8821590a33bacc61e39701cf9b46bd25bf5f0595bbe24655141438e7a100b").unwrap();
+    assert_eq!(sig.to_bytes(), TEST_1_SIGNATURE);
+}
+
+#[test]
+fn from_str_upper() {
+    let sig = Signature::from_str("E5564300C360AC729086E2CC806E828A84877F1EB8E5D974D873E065224901555FB8821590A33BACC61E39701CF9B46BD25BF5F0595BBE24655141438E7A100B").unwrap();
+    assert_eq!(sig.to_bytes(), TEST_1_SIGNATURE);
+}
+
+#[test]
+fn from_str_rejects_mixed_case() {
+    let result = Signature::from_str("E5564300c360ac729086e2cc806e828a84877f1eb8e5d974d873e065224901555fb8821590a33bacc61e39701cf9b46bd25bf5f0595bbe24655141438e7a100b");
+    assert!(result.is_err());
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/ed25519-2.2.3/tests/pkcs8.rs

@@ -0,0 +1,86 @@
+//! PKCS#8 private key tests
+
+#![cfg(feature = "pkcs8")]
+
+use ed25519::pkcs8::{DecodePrivateKey, DecodePublicKey, KeypairBytes, PublicKeyBytes};
+use hex_literal::hex;
+
+#[cfg(feature = "alloc")]
+use ed25519::pkcs8::{EncodePrivateKey, EncodePublicKey};
+
+/// Ed25519 PKCS#8 v1 private key encoded as ASN.1 DER.
+const PKCS8_V1_DER: &[u8] = include_bytes!("examples/pkcs8-v1.der");
+
+/// Ed25519 PKCS#8 v2 private key + public key encoded as ASN.1 DER.
+const PKCS8_V2_DER: &[u8] = include_bytes!("examples/pkcs8-v2.der");
+
+/// Ed25519 SubjectPublicKeyInfo encoded as ASN.1 DER.
+const PUBLIC_KEY_DER: &[u8] = include_bytes!("examples/pubkey.der");
+
+#[test]
+fn decode_pkcs8_v1() {
+    let keypair = KeypairBytes::from_pkcs8_der(PKCS8_V1_DER).unwrap();
+
+    // Extracted with:
+    // $ openssl asn1parse -inform der -in tests/examples/pkcs8-v1.der
+    assert_eq!(
+        keypair.secret_key,
+        &hex!("D4EE72DBF913584AD5B6D8F1F769F8AD3AFE7C28CBF1D4FBE097A88F44755842")[..]
+    );
+
+    assert_eq!(keypair.public_key, None);
+}
+
+#[test]
+fn decode_pkcs8_v2() {
+    let keypair = KeypairBytes::from_pkcs8_der(PKCS8_V2_DER).unwrap();
+
+    // Extracted with:
+    // $ openssl asn1parse -inform der -in tests/examples/pkcs8-v2.der
+    assert_eq!(
+        keypair.secret_key,
+        &hex!("D4EE72DBF913584AD5B6D8F1F769F8AD3AFE7C28CBF1D4FBE097A88F44755842")[..]
+    );
+
+    assert_eq!(
+        keypair.public_key.unwrap().0,
+        hex!("19BF44096984CDFE8541BAC167DC3B96C85086AA30B6B6CB0C5C38AD703166E1")
+    );
+}
+
+#[test]
+fn decode_public_key() {
+    let public_key = PublicKeyBytes::from_public_key_der(PUBLIC_KEY_DER).unwrap();
+
+    // Extracted with:
+    // $ openssl pkey -inform der -in tests/examples/pkcs8-v1.der -pubout -text
+    assert_eq!(
+        public_key.as_ref(),
+        &hex!("19BF44096984CDFE8541BAC167DC3B96C85086AA30B6B6CB0C5C38AD703166E1")
+    );
+}
+
+#[cfg(feature = "alloc")]
+#[test]
+fn encode_pkcs8_v1() {
+    let pk = KeypairBytes::from_pkcs8_der(PKCS8_V1_DER).unwrap();
+    let pk_der = pk.to_pkcs8_der().unwrap();
+    assert_eq!(pk_der.as_bytes(), PKCS8_V1_DER);
+}
+
+#[cfg(feature = "alloc")]
+#[test]
+fn encode_pkcs8_v2() {
+    let pk = KeypairBytes::from_pkcs8_der(PKCS8_V2_DER).unwrap();
+    let pk2 = KeypairBytes::from_pkcs8_der(pk.to_pkcs8_der().unwrap().as_bytes()).unwrap();
+    assert_eq!(pk.secret_key, pk2.secret_key);
+    assert_eq!(pk.public_key, pk2.public_key);
+}
+
+#[cfg(feature = "alloc")]
+#[test]
+fn encode_public_key() {
+    let pk = PublicKeyBytes::from_public_key_der(PUBLIC_KEY_DER).unwrap();
+    let pk_der = pk.to_public_key_der().unwrap();
+    assert_eq!(pk_der.as_ref(), PUBLIC_KEY_DER);
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/ed25519-2.2.3/tests/serde.rs

@@ -0,0 +1,62 @@
+//! Tests for serde serializers/deserializers
+
+#![cfg(feature = "serde")]
+
+use ed25519::{Signature, SignatureBytes};
+use hex_literal::hex;
+
+const EXAMPLE_SIGNATURE: SignatureBytes = hex!(
+    "3f3e3d3c3b3a393837363534333231302f2e2d2c2b2a29282726252423222120"
+    "1f1e1d1c1b1a191817161514131211100f0e0d0c0b0a09080706050403020100"
+);
+
+#[test]
+fn test_serialize() {
+    let signature = Signature::try_from(&EXAMPLE_SIGNATURE[..]).unwrap();
+    dbg!(&signature);
+    let encoded_signature: Vec<u8> = bincode::serialize(&signature).unwrap();
+    assert_eq!(&EXAMPLE_SIGNATURE[..], &encoded_signature[..]);
+}
+
+#[test]
+fn test_deserialize() {
+    let signature = bincode::deserialize::<Signature>(&EXAMPLE_SIGNATURE).unwrap();
+    assert_eq!(EXAMPLE_SIGNATURE, signature.to_bytes());
+}
+
+#[cfg(feature = "serde_bytes")]
+#[test]
+fn test_serialize_bytes() {
+    use bincode::Options;
+
+    let signature = Signature::try_from(&EXAMPLE_SIGNATURE[..]).unwrap();
+
+    let mut encoded_signature = Vec::new();
+    let options = bincode::DefaultOptions::new()
+        .with_fixint_encoding()
+        .allow_trailing_bytes();
+    let mut serializer = bincode::Serializer::new(&mut encoded_signature, options);
+    serde_bytes::serialize(&signature, &mut serializer).unwrap();
+
+    let mut expected = Vec::from(Signature::BYTE_SIZE.to_le_bytes());
+    expected.extend(&EXAMPLE_SIGNATURE[..]);
+    assert_eq!(&expected[..], &encoded_signature[..]);
+}
+
+#[cfg(feature = "serde_bytes")]
+#[test]
+fn test_deserialize_bytes() {
+    use bincode::Options;
+
+    let mut encoded_signature = Vec::from(Signature::BYTE_SIZE.to_le_bytes());
+    encoded_signature.extend(&EXAMPLE_SIGNATURE[..]);
+
+    let options = bincode::DefaultOptions::new()
+        .with_fixint_encoding()
+        .allow_trailing_bytes();
+    let mut deserializer = bincode::de::Deserializer::from_slice(&encoded_signature[..], options);
+
+    let signature: Signature = serde_bytes::deserialize(&mut deserializer).unwrap();
+
+    assert_eq!(EXAMPLE_SIGNATURE, signature.to_bytes());
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/env_logger-0.11.9/src/writer/mod.rs

@@ -0,0 +1,190 @@
+mod buffer;
+mod target;
+
+use std::{io, mem, sync::Mutex};
+
+use buffer::BufferWriter;
+
+pub(crate) use buffer::Buffer;
+
+pub use target::Target;
+
+/// Whether or not to print styles to the target.
+#[allow(clippy::exhaustive_enums)] // By definition don't need more
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, Default)]
+pub enum WriteStyle {
+    /// Try to print styles, but don't force the issue.
+    #[default]
+    Auto,
+    /// Try very hard to print styles.
+    Always,
+    /// Never print styles.
+    Never,
+}
+
+#[cfg(feature = "color")]
+impl From<anstream::ColorChoice> for WriteStyle {
+    fn from(choice: anstream::ColorChoice) -> Self {
+        match choice {
+            anstream::ColorChoice::Auto => Self::Auto,
+            anstream::ColorChoice::Always => Self::Always,
+            anstream::ColorChoice::AlwaysAnsi => Self::Always,
+            anstream::ColorChoice::Never => Self::Never,
+        }
+    }
+}
+
+#[cfg(feature = "color")]
+impl From<WriteStyle> for anstream::ColorChoice {
+    fn from(choice: WriteStyle) -> Self {
+        match choice {
+            WriteStyle::Auto => anstream::ColorChoice::Auto,
+            WriteStyle::Always => anstream::ColorChoice::Always,
+            WriteStyle::Never => anstream::ColorChoice::Never,
+        }
+    }
+}
+
+/// A terminal target with color awareness.
+#[derive(Debug)]
+pub(crate) struct Writer {
+    inner: BufferWriter,
+}
+
+impl Writer {
+    pub(crate) fn write_style(&self) -> WriteStyle {
+        self.inner.write_style()
+    }
+
+    pub(crate) fn buffer(&self) -> Buffer {
+        self.inner.buffer()
+    }
+
+    pub(crate) fn print(&self, buf: &Buffer) -> io::Result<()> {
+        self.inner.print(buf)
+    }
+}
+
+/// A builder for a terminal writer.
+///
+/// The target and style choice can be configured before building.
+#[derive(Debug)]
+pub(crate) struct Builder {
+    target: Target,
+    write_style: WriteStyle,
+    is_test: bool,
+    built: bool,
+}
+
+impl Builder {
+    /// Initialize the writer builder with defaults.
+    pub(crate) fn new() -> Self {
+        Builder {
+            target: Default::default(),
+            write_style: Default::default(),
+            is_test: false,
+            built: false,
+        }
+    }
+
+    /// Set the target to write to.
+    pub(crate) fn target(&mut self, target: Target) -> &mut Self {
+        self.target = target;
+        self
+    }
+
+    /// Parses a style choice string.
+    ///
+    /// See the [Disabling colors] section for more details.
+    ///
+    /// [Disabling colors]: ../index.html#disabling-colors
+    pub(crate) fn parse_write_style(&mut self, write_style: &str) -> &mut Self {
+        self.write_style(parse_write_style(write_style))
+    }
+
+    /// Whether or not to print style characters when writing.
+    pub(crate) fn write_style(&mut self, write_style: WriteStyle) -> &mut Self {
+        self.write_style = write_style;
+        self
+    }
+
+    /// Whether or not to capture logs for `cargo test`.
+    #[allow(clippy::wrong_self_convention)]
+    pub(crate) fn is_test(&mut self, is_test: bool) -> &mut Self {
+        self.is_test = is_test;
+        self
+    }
+
+    /// Build a terminal writer.
+    pub(crate) fn build(&mut self) -> Writer {
+        assert!(!self.built, "attempt to re-use consumed builder");
+        self.built = true;
+
+        let color_choice = self.write_style;
+        #[cfg(feature = "auto-color")]
+        let color_choice = if color_choice == WriteStyle::Auto {
+            match &self.target {
+                Target::Stdout => anstream::AutoStream::choice(&io::stdout()).into(),
+                Target::Stderr => anstream::AutoStream::choice(&io::stderr()).into(),
+                Target::Pipe(_) => color_choice,
+            }
+        } else {
+            color_choice
+        };
+        let color_choice = if color_choice == WriteStyle::Auto {
+            WriteStyle::Never
+        } else {
+            color_choice
+        };
+
+        let writer = match mem::take(&mut self.target) {
+            Target::Stdout => BufferWriter::stdout(self.is_test, color_choice),
+            Target::Stderr => BufferWriter::stderr(self.is_test, color_choice),
+            Target::Pipe(pipe) => BufferWriter::pipe(Box::new(Mutex::new(pipe)), color_choice),
+        };
+
+        Writer { inner: writer }
+    }
+}
+
+impl Default for Builder {
+    fn default() -> Self {
+        Builder::new()
+    }
+}
+
+fn parse_write_style(spec: &str) -> WriteStyle {
+    match spec {
+        "auto" => WriteStyle::Auto,
+        "always" => WriteStyle::Always,
+        "never" => WriteStyle::Never,
+        _ => Default::default(),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parse_write_style_valid() {
+        let inputs = vec![
+            ("auto", WriteStyle::Auto),
+            ("always", WriteStyle::Always),
+            ("never", WriteStyle::Never),
+        ];
+
+        for (input, expected) in inputs {
+            assert_eq!(expected, parse_write_style(input));
+        }
+    }
+
+    #[test]
+    fn parse_write_style_invalid() {
+        let inputs = vec!["", "true", "false", "NEVER!!"];
+
+        for input in inputs {
+            assert_eq!(WriteStyle::Auto, parse_write_style(input));
+        }
+    }
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/env_logger-0.11.9/src/writer/target.rs

@@ -0,0 +1,26 @@
+/// Log target, either `stdout`, `stderr` or a custom pipe.
+#[non_exhaustive]
+#[derive(Default)]
+pub enum Target {
+    /// Logs will be sent to standard output.
+    Stdout,
+    /// Logs will be sent to standard error.
+    #[default]
+    Stderr,
+    /// Logs will be sent to a custom pipe.
+    Pipe(Box<dyn std::io::Write + Send + 'static>),
+}
+
+impl std::fmt::Debug for Target {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}",
+            match self {
+                Self::Stdout => "stdout",
+                Self::Stderr => "stderr",
+                Self::Pipe(_) => "pipe",
+            }
+        )
+    }
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/jiff-0.2.20/src/civil/iso_week_date.rs

@@ -0,0 +1,919 @@
+use crate::{
+    civil::{Date, DateTime, Weekday},
+    error::Error,
+    fmt::temporal::{DEFAULT_DATETIME_PARSER, DEFAULT_DATETIME_PRINTER},
+    util::b,
+    Zoned,
+};
+
+/// A type representing an [ISO 8601 week date].
+///
+/// The ISO 8601 week date scheme devises a calendar where days are identified
+/// by their year, week number and weekday. All years have either precisely
+/// 52 or 53 weeks.
+///
+/// The first week of an ISO 8601 year corresponds to the week containing the
+/// first Thursday of the year. For this reason, an ISO 8601 week year can be
+/// mismatched with the day's corresponding Gregorian year. For example, the
+/// ISO 8601 week date for `1995-01-01` is `1994-W52-7` (with `7` corresponding
+/// to Sunday).
+///
+/// ISO 8601 also considers Monday to be the start of the week, and uses
+/// a 1-based numbering system. That is, Monday corresponds to `1` while
+/// Sunday corresponds to `7` and is the last day of the week. Weekdays are
+/// encapsulated by the [`Weekday`] type, which provides routines for easily
+/// converting between different schemes (such as weeks where Sunday is the
+/// beginning).
+///
+/// [ISO 8601 week date]: https://en.wikipedia.org/wiki/ISO_week_date
+///
+/// # Use case
+///
+/// Some domains use this method of timekeeping. Otherwise, unless you
+/// specifically want a week oriented calendar, it's likely that you'll never
+/// need to care about this type.
+///
+/// # Parsing and printing
+///
+/// The `ISOWeekDate` type provides convenient trait implementations of
+/// [`std::str::FromStr`] and [`std::fmt::Display`]. These use the format
+/// specified by ISO 8601 for week dates:
+///
+/// ```
+/// use jiff::civil::ISOWeekDate;
+///
+/// let week_date: ISOWeekDate = "2024-W24-7".parse()?;
+/// assert_eq!(week_date.to_string(), "2024-W24-7");
+/// assert_eq!(week_date.date().to_string(), "2024-06-16");
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+///
+/// ISO 8601 allows the `-` separator to be absent:
+///
+/// ```
+/// use jiff::civil::ISOWeekDate;
+///
+/// let week_date: ISOWeekDate = "2024W241".parse()?;
+/// assert_eq!(week_date.to_string(), "2024-W24-1");
+/// assert_eq!(week_date.date().to_string(), "2024-06-10");
+///
+/// // But you cannot mix and match. Either `-` separates
+/// // both the year and week, or neither.
+/// assert!("2024W24-1".parse::<ISOWeekDate>().is_err());
+/// assert!("2024-W241".parse::<ISOWeekDate>().is_err());
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+///
+/// And the `W` may also be lowercase:
+///
+/// ```
+/// use jiff::civil::ISOWeekDate;
+///
+/// let week_date: ISOWeekDate = "2024-w24-2".parse()?;
+/// assert_eq!(week_date.to_string(), "2024-W24-2");
+/// assert_eq!(week_date.date().to_string(), "2024-06-11");
+///
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+///
+/// # Default value
+///
+/// For convenience, this type implements the `Default` trait. Its default
+/// value is the first day of the zeroth year. i.e., `0000-W1-1`.
+///
+/// # Example: sample dates
+///
+/// This example shows a couple ISO 8601 week dates and their corresponding
+/// Gregorian equivalents:
+///
+/// ```
+/// use jiff::civil::{ISOWeekDate, Weekday, date};
+///
+/// let d = date(2019, 12, 30);
+/// let weekdate = ISOWeekDate::new(2020, 1, Weekday::Monday).unwrap();
+/// assert_eq!(d.iso_week_date(), weekdate);
+///
+/// let d = date(2024, 3, 9);
+/// let weekdate = ISOWeekDate::new(2024, 10, Weekday::Saturday).unwrap();
+/// assert_eq!(d.iso_week_date(), weekdate);
+/// ```
+///
+/// # Example: overlapping leap and long years
+///
+/// A "long" ISO 8601 week year is a year with 53 weeks. That is, it is a year
+/// that includes a leap week. This example shows all years in the 20th
+/// century that are both Gregorian leap years and long years.
+///
+/// ```
+/// use jiff::civil::date;
+///
+/// let mut overlapping = vec![];
+/// for year in 1900..=1999 {
+///     let date = date(year, 1, 1);
+///     if date.in_leap_year() && date.iso_week_date().in_long_year() {
+///         overlapping.push(year);
+///     }
+/// }
+/// assert_eq!(overlapping, vec![
+///     1904, 1908, 1920, 1932, 1936, 1948, 1960, 1964, 1976, 1988, 1992,
+/// ]);
+/// ```
+///
+/// # Example: printing all weeks in a year
+///
+/// The ISO 8601 week calendar can be useful when you want to categorize
+/// things into buckets of weeks where all weeks are exactly 7 days, _and_
+/// you don't care as much about the precise Gregorian year. Here's an example
+/// that prints all of the ISO 8601 weeks in one ISO 8601 week year:
+///
+/// ```
+/// use jiff::{civil::{ISOWeekDate, Weekday}, ToSpan};
+///
+/// let target_year = 2024;
+/// let iso_week_date = ISOWeekDate::new(target_year, 1, Weekday::Monday)?;
+/// // Create a series of dates via the Gregorian calendar. But since a
+/// // Gregorian week and an ISO 8601 week calendar week are both 7 days,
+/// // this works fine.
+/// let weeks = iso_week_date
+///     .date()
+///     .series(1.week())
+///     .map(|d| d.iso_week_date())
+///     .take_while(|wd| wd.year() == target_year);
+/// for start_of_week in weeks {
+///     let end_of_week = start_of_week.last_of_week()?;
+///     println!(
+///         "ISO week {}: {} - {}",
+///         start_of_week.week(),
+///         start_of_week.date(),
+///         end_of_week.date()
+///     );
+/// }
+/// # Ok::<(), Box<dyn std::error::Error>>(())
+/// ```
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+pub struct ISOWeekDate {
+    year: i16,
+    week: i8,
+    weekday: Weekday,
+}
+
+impl ISOWeekDate {
+    /// The maximum representable ISO week date.
+    ///
+    /// The maximum corresponds to the ISO week date of the maximum [`Date`]
+    /// value. That is, `-9999-01-01`.
+    pub const MIN: ISOWeekDate = ISOWeekDate {
+        year: b::ISOYear::MIN,
+        week: b::ISOWeek::MIN,
+        weekday: Weekday::Monday,
+    };
+
+    /// The minimum representable ISO week date.
+    ///
+    /// The minimum corresponds to the ISO week date of the minimum [`Date`]
+    /// value. That is, `9999-12-31`.
+    pub const MAX: ISOWeekDate = ISOWeekDate {
+        year: b::ISOYear::MAX,
+        // Technical max is 52, but 9999 is not a leap year.
+        week: 52,
+        weekday: Weekday::Friday,
+    };
+
+    /// The first day of the zeroth year.
+    ///
+    /// This is guaranteed to be equivalent to `ISOWeekDate::default()`. Note
+    /// that this is not equivalent to `Date::default()`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::civil::{ISOWeekDate, date};
+    ///
+    /// assert_eq!(ISOWeekDate::ZERO, ISOWeekDate::default());
+    /// // The first day of the 0th year in the ISO week calendar is actually
+    /// // the third day of the 0th year in the proleptic Gregorian calendar!
+    /// assert_eq!(ISOWeekDate::default().date(), date(0, 1, 3));
+    /// ```
+    pub const ZERO: ISOWeekDate =
+        ISOWeekDate { year: 0, week: 1, weekday: Weekday::Monday };
+
+    /// Create a new ISO week date from it constituent parts.
+    ///
+    /// If the given values are out of range (based on what is representable
+    /// as a [`Date`]), then this returns an error. This will also return an
+    /// error if a leap week is given (week number `53`) for a year that does
+    /// not contain a leap week.
+    ///
+    /// # Example
+    ///
+    /// This example shows some the boundary conditions involving minimum
+    /// and maximum dates:
+    ///
+    /// ```
+    /// use jiff::civil::{ISOWeekDate, Weekday, date};
+    ///
+    /// // The year 1949 does not contain a leap week.
+    /// assert!(ISOWeekDate::new(1949, 53, Weekday::Monday).is_err());
+    ///
+    /// // Examples of dates at or exceeding the maximum.
+    /// let max = ISOWeekDate::new(9999, 52, Weekday::Friday).unwrap();
+    /// assert_eq!(max, ISOWeekDate::MAX);
+    /// assert_eq!(max.date(), date(9999, 12, 31));
+    /// assert!(ISOWeekDate::new(9999, 52, Weekday::Saturday).is_err());
+    /// assert!(ISOWeekDate::new(9999, 53, Weekday::Monday).is_err());
+    ///
+    /// // Examples of dates at or exceeding the minimum.
+    /// let min = ISOWeekDate::new(-9999, 1, Weekday::Monday).unwrap();
+    /// assert_eq!(min, ISOWeekDate::MIN);
+    /// assert_eq!(min.date(), date(-9999, 1, 1));
+    /// assert!(ISOWeekDate::new(-10000, 52, Weekday::Sunday).is_err());
+    /// ```
+    #[inline]
+    pub fn new(
+        year: i16,
+        week: i8,
+        weekday: Weekday,
+    ) -> Result<ISOWeekDate, Error> {
+        let year = b::ISOYear::check(year)?;
+        let week = b::ISOWeek::check(week)?;
+
+        // All combinations of years, weeks and weekdays allowed by our
+        // range types are valid ISO week dates with one exception: a week
+        // number of 53 is only valid for "long" years. Or years with an ISO
+        // leap week. It turns out this only happens when the last day of the
+        // year is a Thursday.
+        //
+        // Note that if the ranges in this crate are changed, this could be
+        // a little trickier if the range of ISOYear is different from Year.
+        debug_assert_eq!(b::Year::MIN, b::ISOYear::MIN);
+        debug_assert_eq!(b::Year::MAX, b::ISOYear::MAX);
+        if week == 53 && !is_long_year(year) {
+            return Err(b::ISOWeek::error().into());
+        }
+        // And also, the maximum Date constrains what we can utter with
+        // ISOWeekDate so that we can preserve infallible conversions between
+        // them. So since 9999-12-31 maps to 9999 W52 Friday, it follows that
+        // Saturday and Sunday are not allowed when the year is at the maximum
+        // value. So reject them.
+        //
+        // We don't need to worry about the minimum because the minimum date
+        // (-9999-01-01) corresponds also to the minimum possible combination
+        // of an ISO week date's fields: -9999 W01 Monday. Nice.
+        if year == b::ISOYear::MAX
+            && week == 52
+            && weekday.to_monday_zero_offset()
+                > Weekday::Friday.to_monday_zero_offset()
+        {
+            return Err(b::WeekdayMondayOne::error().into());
+        }
+        Ok(ISOWeekDate { year, week, weekday })
+    }
+
+    /// Like `ISOWeekDate::new`, but constrains out-of-bounds values
+    /// to their closest valid equivalent.
+    ///
+    /// For example, given `9999 W52 Saturday`, this will return
+    /// `9999 W52 Friday`.
+    #[cfg(test)]
+    #[inline]
+    fn new_constrain(
+        year: i16,
+        mut week: i8,
+        mut weekday: Weekday,
+    ) -> ISOWeekDate {
+        debug_assert_eq!(b::Year::MIN, b::ISOYear::MIN);
+        debug_assert_eq!(b::Year::MAX, b::ISOYear::MAX);
+        if week == 53 && !is_long_year(year) {
+            week = 52;
+        }
+        if year == b::ISOYear::MAX
+            && week == 52
+            && weekday.to_monday_zero_offset()
+                > Weekday::Friday.to_monday_zero_offset()
+        {
+            weekday = Weekday::Friday;
+        }
+        ISOWeekDate { year, week, weekday }
+    }
+
+    /// Converts a Gregorian date to an ISO week date.
+    ///
+    /// The minimum and maximum allowed values of an ISO week date are
+    /// set based on the minimum and maximum values of a `Date`. Therefore,
+    /// converting to and from `Date` values is non-lossy and infallible.
+    ///
+    /// This routine is equivalent to [`Date::iso_week_date`]. This routine
+    /// is also available via a `From<Date>` trait implementation for
+    /// `ISOWeekDate`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::civil::{ISOWeekDate, Weekday, date};
+    ///
+    /// let weekdate = ISOWeekDate::from_date(date(1948, 2, 10));
+    /// assert_eq!(
+    ///     weekdate,
+    ///     ISOWeekDate::new(1948, 7, Weekday::Tuesday).unwrap(),
+    /// );
+    /// ```
+    #[inline]
+    pub fn from_date(date: Date) -> ISOWeekDate {
+        date.iso_week_date()
+    }
+
+    // N.B. I tried defining a `ISOWeekDate::constant` for defining ISO week
+    // dates as constants, but it was too annoying to do. We could do it if
+    // there was a compelling reason for it though.
+
+    /// Returns the year component of this ISO 8601 week date.
+    ///
+    /// The value returned is guaranteed to be in the range `-9999..=9999`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::civil::date;
+    ///
+    /// let weekdate = date(2019, 12, 30).iso_week_date();
+    /// assert_eq!(weekdate.year(), 2020);
+    /// ```
+    #[inline]
+    pub fn year(self) -> i16 {
+        self.year
+    }
+
+    /// Returns the week component of this ISO 8601 week date.
+    ///
+    /// The value returned is guaranteed to be in the range `1..=53`. A
+    /// value of `53` can only occur for "long" years. That is, years
+    /// with a leap week. This occurs precisely in cases for which
+    /// [`ISOWeekDate::in_long_year`] returns `true`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::civil::date;
+    ///
+    /// let weekdate = date(2019, 12, 30).iso_week_date();
+    /// assert_eq!(weekdate.year(), 2020);
+    /// assert_eq!(weekdate.week(), 1);
+    ///
+    /// let weekdate = date(1948, 12, 31).iso_week_date();
+    /// assert_eq!(weekdate.year(), 1948);
+    /// assert_eq!(weekdate.week(), 53);
+    /// ```
+    #[inline]
+    pub fn week(self) -> i8 {
+        self.week
+    }
+
+    /// Returns the day component of this ISO 8601 week date.
+    ///
+    /// One can use methods on `Weekday` such as
+    /// [`Weekday::to_monday_one_offset`]
+    /// and
+    /// [`Weekday::to_sunday_zero_offset`]
+    /// to convert the weekday to a number.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::civil::{date, Weekday};
+    ///
+    /// let weekdate = date(1948, 12, 31).iso_week_date();
+    /// assert_eq!(weekdate.year(), 1948);
+    /// assert_eq!(weekdate.week(), 53);
+    /// assert_eq!(weekdate.weekday(), Weekday::Friday);
+    /// assert_eq!(weekdate.weekday().to_monday_zero_offset(), 4);
+    /// assert_eq!(weekdate.weekday().to_monday_one_offset(), 5);
+    /// assert_eq!(weekdate.weekday().to_sunday_zero_offset(), 5);
+    /// assert_eq!(weekdate.weekday().to_sunday_one_offset(), 6);
+    /// ```
+    #[inline]
+    pub fn weekday(self) -> Weekday {
+        self.weekday
+    }
+
+    /// Returns the ISO 8601 week date corresponding to the first day in the
+    /// week of this week date. The date returned is guaranteed to have a
+    /// weekday of [`Weekday::Monday`].
+    ///
+    /// # Errors
+    ///
+    /// Since `-9999-01-01` falls on a Monday, it follows that the minimum
+    /// support Gregorian date is exactly equivalent to the minimum supported
+    /// ISO 8601 week date. This means that this routine can never actually
+    /// fail, but only insomuch as the minimums line up. For that reason, and
+    /// for consistency with [`ISOWeekDate::last_of_week`], the API is
+    /// fallible.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::civil::{ISOWeekDate, Weekday, date};
+    ///
+    /// let wd = ISOWeekDate::new(2025, 5, Weekday::Wednesday).unwrap();
+    /// assert_eq!(wd.date(), date(2025, 1, 29));
+    /// assert_eq!(
+    ///     wd.first_of_week()?,
+    ///     ISOWeekDate::new(2025, 5, Weekday::Monday).unwrap(),
+    /// );
+    ///
+    /// // Works even for the minimum date.
+    /// assert_eq!(
+    ///     ISOWeekDate::MIN.first_of_week()?,
+    ///     ISOWeekDate::new(-9999, 1, Weekday::Monday).unwrap(),
+    /// );
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn first_of_week(self) -> Result<ISOWeekDate, Error> {
+        // I believe this can never return an error because `Monday` is in
+        // bounds for all possible year-and-week combinations. This is *only*
+        // because -9999-01-01 corresponds to -9999-W01-Monday. Which is kinda
+        // lucky. And I guess if we ever change the ranges, this could become
+        // fallible.
+        ISOWeekDate::new(self.year(), self.week(), Weekday::Monday)
+    }
+
+    /// Returns the ISO 8601 week date corresponding to the last day in the
+    /// week of this week date. The date returned is guaranteed to have a
+    /// weekday of [`Weekday::Sunday`].
+    ///
+    /// # Errors
+    ///
+    /// This can return an error if the last day of the week exceeds Jiff's
+    /// maximum Gregorian date of `9999-12-31`. It turns out this can happen
+    /// since `9999-12-31` falls on a Friday.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::civil::{ISOWeekDate, Weekday, date};
+    ///
+    /// let wd = ISOWeekDate::new(2025, 5, Weekday::Wednesday).unwrap();
+    /// assert_eq!(wd.date(), date(2025, 1, 29));
+    /// assert_eq!(
+    ///     wd.last_of_week()?,
+    ///     ISOWeekDate::new(2025, 5, Weekday::Sunday).unwrap(),
+    /// );
+    ///
+    /// // Unlike `first_of_week`, this routine can actually fail on real
+    /// // values, although, only when close to the maximum supported date.
+    /// assert_eq!(
+    ///     ISOWeekDate::MAX.last_of_week().unwrap_err().to_string(),
+    ///     "parameter 'weekday (Monday 1-indexed)' \
+    ///      is not in the required range of 1..=7",
+    /// );
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn last_of_week(self) -> Result<ISOWeekDate, Error> {
+        // This can return an error when in the last week of the maximum year
+        // supported by Jiff. That's because the Saturday and Sunday of that
+        // week are actually in Gregorian year 10,000.
+        ISOWeekDate::new(self.year(), self.week(), Weekday::Sunday)
+    }
+
+    /// Returns the ISO 8601 week date corresponding to the first day in the
+    /// year of this week date. The date returned is guaranteed to have a
+    /// weekday of [`Weekday::Monday`].
+    ///
+    /// # Errors
+    ///
+    /// Since `-9999-01-01` falls on a Monday, it follows that the minimum
+    /// support Gregorian date is exactly equivalent to the minimum supported
+    /// ISO 8601 week date. This means that this routine can never actually
+    /// fail, but only insomuch as the minimums line up. For that reason, and
+    /// for consistency with [`ISOWeekDate::last_of_year`], the API is
+    /// fallible.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::civil::{ISOWeekDate, Weekday, date};
+    ///
+    /// let wd = ISOWeekDate::new(2025, 5, Weekday::Wednesday).unwrap();
+    /// assert_eq!(wd.date(), date(2025, 1, 29));
+    /// assert_eq!(
+    ///     wd.first_of_year()?,
+    ///     ISOWeekDate::new(2025, 1, Weekday::Monday).unwrap(),
+    /// );
+    ///
+    /// // Works even for the minimum date.
+    /// assert_eq!(
+    ///     ISOWeekDate::MIN.first_of_year()?,
+    ///     ISOWeekDate::new(-9999, 1, Weekday::Monday).unwrap(),
+    /// );
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn first_of_year(self) -> Result<ISOWeekDate, Error> {
+        // I believe this can never return an error because `Monday` is in
+        // bounds for all possible years. This is *only* because -9999-01-01
+        // corresponds to -9999-W01-Monday. Which is kinda lucky. And I guess
+        // if we ever change the ranges, this could become fallible.
+        ISOWeekDate::new(self.year(), 1, Weekday::Monday)
+    }
+
+    /// Returns the ISO 8601 week date corresponding to the last day in the
+    /// year of this week date. The date returned is guaranteed to have a
+    /// weekday of [`Weekday::Sunday`].
+    ///
+    /// # Errors
+    ///
+    /// This can return an error if the last day of the year exceeds Jiff's
+    /// maximum Gregorian date of `9999-12-31`. It turns out this can happen
+    /// since `9999-12-31` falls on a Friday.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::civil::{ISOWeekDate, Weekday, date};
+    ///
+    /// let wd = ISOWeekDate::new(2025, 5, Weekday::Wednesday).unwrap();
+    /// assert_eq!(wd.date(), date(2025, 1, 29));
+    /// assert_eq!(
+    ///     wd.last_of_year()?,
+    ///     ISOWeekDate::new(2025, 52, Weekday::Sunday).unwrap(),
+    /// );
+    ///
+    /// // Works correctly for "long" years.
+    /// let wd = ISOWeekDate::new(2026, 5, Weekday::Wednesday).unwrap();
+    /// assert_eq!(wd.date(), date(2026, 1, 28));
+    /// assert_eq!(
+    ///     wd.last_of_year()?,
+    ///     ISOWeekDate::new(2026, 53, Weekday::Sunday).unwrap(),
+    /// );
+    ///
+    /// // Unlike `first_of_year`, this routine can actually fail on real
+    /// // values, although, only when close to the maximum supported date.
+    /// assert_eq!(
+    ///     ISOWeekDate::MAX.last_of_year().unwrap_err().to_string(),
+    ///     "parameter 'weekday (Monday 1-indexed)' \
+    ///      is not in the required range of 1..=7",
+    /// );
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn last_of_year(self) -> Result<ISOWeekDate, Error> {
+        // This can return an error when in the maximum year supported by
+        // Jiff. That's because the last Saturday and Sunday of that year are
+        // actually in Gregorian year 10,000.
+        ISOWeekDate::new(self.year(), self.weeks_in_year(), Weekday::Sunday)
+    }
+
+    /// Returns the total number of days in the year of this ISO 8601 week
+    /// date.
+    ///
+    /// It is guaranteed that the value returned is either 364 or 371. The
+    /// latter case occurs precisely when [`ISOWeekDate::in_long_year`]
+    /// returns `true`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::civil::{ISOWeekDate, Weekday};
+    ///
+    /// let weekdate = ISOWeekDate::new(2025, 7, Weekday::Monday).unwrap();
+    /// assert_eq!(weekdate.days_in_year(), 364);
+    /// let weekdate = ISOWeekDate::new(2026, 7, Weekday::Monday).unwrap();
+    /// assert_eq!(weekdate.days_in_year(), 371);
+    /// ```
+    #[inline]
+    pub fn days_in_year(self) -> i16 {
+        if self.in_long_year() {
+            371
+        } else {
+            364
+        }
+    }
+
+    /// Returns the total number of weeks in the year of this ISO 8601 week
+    /// date.
+    ///
+    /// It is guaranteed that the value returned is either 52 or 53. The
+    /// latter case occurs precisely when [`ISOWeekDate::in_long_year`]
+    /// returns `true`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::civil::{ISOWeekDate, Weekday};
+    ///
+    /// let weekdate = ISOWeekDate::new(2025, 7, Weekday::Monday).unwrap();
+    /// assert_eq!(weekdate.weeks_in_year(), 52);
+    /// let weekdate = ISOWeekDate::new(2026, 7, Weekday::Monday).unwrap();
+    /// assert_eq!(weekdate.weeks_in_year(), 53);
+    /// ```
+    #[inline]
+    pub fn weeks_in_year(self) -> i8 {
+        if self.in_long_year() {
+            53
+        } else {
+            52
+        }
+    }
+
+    /// Returns true if and only if the year of this week date is a "long"
+    /// year.
+    ///
+    /// A long year is one that contains precisely 53 weeks. All other years
+    /// contain precisely 52 weeks.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::civil::{ISOWeekDate, Weekday};
+    ///
+    /// let weekdate = ISOWeekDate::new(1948, 7, Weekday::Monday).unwrap();
+    /// assert!(weekdate.in_long_year());
+    /// let weekdate = ISOWeekDate::new(1949, 7, Weekday::Monday).unwrap();
+    /// assert!(!weekdate.in_long_year());
+    /// ```
+    #[inline]
+    pub fn in_long_year(self) -> bool {
+        is_long_year(self.year())
+    }
+
+    /// Returns the ISO 8601 date immediately following this one.
+    ///
+    /// # Errors
+    ///
+    /// This returns an error when this date is the maximum value.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::civil::{ISOWeekDate, Weekday};
+    ///
+    /// let wd = ISOWeekDate::new(2025, 5, Weekday::Wednesday).unwrap();
+    /// assert_eq!(
+    ///     wd.tomorrow()?,
+    ///     ISOWeekDate::new(2025, 5, Weekday::Thursday).unwrap(),
+    /// );
+    ///
+    /// // The max doesn't have a tomorrow.
+    /// assert!(ISOWeekDate::MAX.tomorrow().is_err());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn tomorrow(self) -> Result<ISOWeekDate, Error> {
+        // I suppose we could probably implement this in a more efficient
+        // manner but avoiding the roundtrip through Gregorian dates.
+        self.date().tomorrow().map(|d| d.iso_week_date())
+    }
+
+    /// Returns the ISO 8601 week date immediately preceding this one.
+    ///
+    /// # Errors
+    ///
+    /// This returns an error when this date is the minimum value.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::civil::{ISOWeekDate, Weekday};
+    ///
+    /// let wd = ISOWeekDate::new(2025, 5, Weekday::Wednesday).unwrap();
+    /// assert_eq!(
+    ///     wd.yesterday()?,
+    ///     ISOWeekDate::new(2025, 5, Weekday::Tuesday).unwrap(),
+    /// );
+    ///
+    /// // The min doesn't have a yesterday.
+    /// assert!(ISOWeekDate::MIN.yesterday().is_err());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn yesterday(self) -> Result<ISOWeekDate, Error> {
+        // I suppose we could probably implement this in a more efficient
+        // manner but avoiding the roundtrip through Gregorian dates.
+        self.date().yesterday().map(|d| d.iso_week_date())
+    }
+
+    /// Converts this ISO week date to a Gregorian [`Date`].
+    ///
+    /// The minimum and maximum allowed values of an ISO week date are
+    /// set based on the minimum and maximum values of a `Date`. Therefore,
+    /// converting to and from `Date` values is non-lossy and infallible.
+    ///
+    /// This routine is equivalent to [`Date::from_iso_week_date`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::civil::{ISOWeekDate, Weekday, date};
+    ///
+    /// let weekdate = ISOWeekDate::new(1948, 7, Weekday::Tuesday).unwrap();
+    /// assert_eq!(weekdate.date(), date(1948, 2, 10));
+    /// ```
+    #[inline]
+    pub fn date(self) -> Date {
+        Date::from_iso_week_date(self)
+    }
+}
+
+impl Default for ISOWeekDate {
+    fn default() -> ISOWeekDate {
+        ISOWeekDate::ZERO
+    }
+}
+
+impl core::fmt::Display for ISOWeekDate {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        use crate::fmt::StdFmtWrite;
+
+        DEFAULT_DATETIME_PRINTER
+            .print_iso_week_date(self, StdFmtWrite(f))
+            .map_err(|_| core::fmt::Error)
+    }
+}
+
+impl core::str::FromStr for ISOWeekDate {
+    type Err = Error;
+
+    fn from_str(string: &str) -> Result<ISOWeekDate, Error> {
+        DEFAULT_DATETIME_PARSER.parse_iso_week_date(string)
+    }
+}
+
+impl Ord for ISOWeekDate {
+    #[inline]
+    fn cmp(&self, other: &ISOWeekDate) -> core::cmp::Ordering {
+        (self.year(), self.week(), self.weekday().to_monday_one_offset()).cmp(
+            &(
+                other.year(),
+                other.week(),
+                other.weekday().to_monday_one_offset(),
+            ),
+        )
+    }
+}
+
+impl PartialOrd for ISOWeekDate {
+    #[inline]
+    fn partial_cmp(&self, other: &ISOWeekDate) -> Option<core::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl From<Date> for ISOWeekDate {
+    #[inline]
+    fn from(date: Date) -> ISOWeekDate {
+        ISOWeekDate::from_date(date)
+    }
+}
+
+impl From<DateTime> for ISOWeekDate {
+    #[inline]
+    fn from(dt: DateTime) -> ISOWeekDate {
+        ISOWeekDate::from(dt.date())
+    }
+}
+
+impl From<Zoned> for ISOWeekDate {
+    #[inline]
+    fn from(zdt: Zoned) -> ISOWeekDate {
+        ISOWeekDate::from(zdt.date())
+    }
+}
+
+impl<'a> From<&'a Zoned> for ISOWeekDate {
+    #[inline]
+    fn from(zdt: &'a Zoned) -> ISOWeekDate {
+        ISOWeekDate::from(zdt.date())
+    }
+}
+
+#[cfg(feature = "serde")]
+impl serde_core::Serialize for ISOWeekDate {
+    #[inline]
+    fn serialize<S: serde_core::Serializer>(
+        &self,
+        serializer: S,
+    ) -> Result<S::Ok, S::Error> {
+        serializer.collect_str(self)
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'de> serde_core::Deserialize<'de> for ISOWeekDate {
+    #[inline]
+    fn deserialize<D: serde_core::Deserializer<'de>>(
+        deserializer: D,
+    ) -> Result<ISOWeekDate, D::Error> {
+        use serde_core::de;
+
+        struct ISOWeekDateVisitor;
+
+        impl<'de> de::Visitor<'de> for ISOWeekDateVisitor {
+            type Value = ISOWeekDate;
+
+            fn expecting(
+                &self,
+                f: &mut core::fmt::Formatter,
+            ) -> core::fmt::Result {
+                f.write_str("an ISO 8601 week date string")
+            }
+
+            #[inline]
+            fn visit_bytes<E: de::Error>(
+                self,
+                value: &[u8],
+            ) -> Result<ISOWeekDate, E> {
+                DEFAULT_DATETIME_PARSER
+                    .parse_iso_week_date(value)
+                    .map_err(de::Error::custom)
+            }
+
+            #[inline]
+            fn visit_str<E: de::Error>(
+                self,
+                value: &str,
+            ) -> Result<ISOWeekDate, E> {
+                self.visit_bytes(value.as_bytes())
+            }
+        }
+
+        deserializer.deserialize_str(ISOWeekDateVisitor)
+    }
+}
+
+#[cfg(test)]
+impl quickcheck::Arbitrary for ISOWeekDate {
+    fn arbitrary(g: &mut quickcheck::Gen) -> ISOWeekDate {
+        let year = b::ISOYear::arbitrary(g);
+        let week = b::ISOWeek::arbitrary(g);
+        let weekday = Weekday::arbitrary(g);
+        ISOWeekDate::new_constrain(year, week, weekday)
+    }
+
+    fn shrink(&self) -> alloc::boxed::Box<dyn Iterator<Item = ISOWeekDate>> {
+        alloc::boxed::Box::new(
+            (self.year(), self.week(), self.weekday()).shrink().map(
+                |(year, week, weekday)| {
+                    ISOWeekDate::new_constrain(year, week, weekday)
+                },
+            ),
+        )
+    }
+}
+
+/// Returns true if the given ISO year is a "long" year or not.
+///
+/// A "long" year is a year with 53 weeks. Otherwise, it's a "short" year
+/// with 52 weeks.
+fn is_long_year(year: i16) -> bool {
+    // Inspired by: https://en.wikipedia.org/wiki/ISO_week_date#Weeks_per_year
+    let last =
+        Date::new(year, 12, 31).expect("last day of year is always valid");
+    let weekday = last.weekday();
+    weekday == Weekday::Thursday
+        || (last.in_leap_year() && weekday == Weekday::Friday)
+}
+
+#[cfg(not(miri))]
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    quickcheck::quickcheck! {
+        fn prop_all_long_years_have_53rd_week(year: i16) -> quickcheck::TestResult {
+            if b::Year::check(year).is_err() {
+                return quickcheck::TestResult::discard();
+            }
+            quickcheck::TestResult::from_bool(!is_long_year(year)
+                || ISOWeekDate::new(year, 53, Weekday::Sunday).is_ok())
+        }
+
+        fn prop_prev_day_is_less(wd: ISOWeekDate) -> quickcheck::TestResult {
+            use crate::ToSpan;
+
+            if wd == ISOWeekDate::MIN {
+                return quickcheck::TestResult::discard();
+            }
+            let prev_date = wd.date().checked_add(-1.days()).unwrap();
+            quickcheck::TestResult::from_bool(prev_date.iso_week_date() < wd)
+        }
+
+        fn prop_next_day_is_greater(wd: ISOWeekDate) -> quickcheck::TestResult {
+            use crate::ToSpan;
+
+            if wd == ISOWeekDate::MAX {
+                return quickcheck::TestResult::discard();
+            }
+            let next_date = wd.date().checked_add(1.days()).unwrap();
+            quickcheck::TestResult::from_bool(wd < next_date.iso_week_date())
+        }
+    }
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/jiff-0.2.20/src/civil/mod.rs

@@ -0,0 +1,290 @@
+/*!
+Facilities for dealing with inexact dates and times.
+
+# Overview
+
+The essential types in this module are:
+
+* [`Date`] is a specific day in the Gregorian calendar.
+* [`Time`] is a specific wall clock time.
+* [`DateTime`] is a combination of a day and a time.
+
+Moreover, the [`date`](date()) and [`time`](time()) free functions can be used
+to conveniently create values of any of three types above:
+
+```
+use jiff::civil::{date, time};
+
+assert_eq!(date(2024, 7, 31).to_string(), "2024-07-31");
+assert_eq!(time(15, 20, 0, 123).to_string(), "15:20:00.000000123");
+assert_eq!(
+    date(2024, 7, 31).at(15, 20, 0, 123).to_string(),
+    "2024-07-31T15:20:00.000000123",
+);
+assert_eq!(
+    time(15, 20, 0, 123).on(2024, 7, 31).to_string(),
+    "2024-07-31T15:20:00.000000123",
+);
+```
+
+# What is "civil" time?
+
+A civil datetime is a calendar date and a clock time. It also goes by the
+names "naive," "local" or "plain." The most important thing to understand
+about civil time is that it does not correspond to a precise instant in
+time. This is in contrast to types like [`Timestamp`](crate::Timestamp) and
+[`Zoned`](crate::Zoned), which _do_ correspond to a precise instant in time (to
+nanosecond precision).
+
+Because a civil datetime _never_ has a time zone associated with it, and
+because some time zones have transitions that skip or repeat clock times, it
+follows that not all civil datetimes precisely map to a single instant in time.
+For example, `2024-03-10 02:30` never existed on a clock in `America/New_York`
+because the 2 o'clock hour was skipped when the clocks were "moved forward"
+for daylight saving time. Conversely, `2024-11-03 01:30` occurred twice in
+`America/New_York` because the 1 o'clock hour was repeated when clocks were
+"moved backward" for daylight saving time. (When time is skipped, it's called a
+"gap." When time is repeated, it's called a "fold.")
+
+In contrast, an instant in time (that is, `Timestamp` or `Zoned`) can _always_
+be converted to a civil datetime. And, when a civil datetime is combined
+with its time zone identifier _and_ its offset, the resulting machine readable
+string is unambiguous 100% of the time:
+
+```
+use jiff::{civil::date, tz::TimeZone};
+
+let tz = TimeZone::get("America/New_York")?;
+let dt = date(2024, 11, 3).at(1, 30, 0, 0);
+// It's ambiguous, so asking for an unambiguous instant presents an error!
+assert!(tz.to_ambiguous_zoned(dt).unambiguous().is_err());
+// Gives you the earlier time in a fold, i.e., before DST ends:
+assert_eq!(
+    tz.to_ambiguous_zoned(dt).earlier()?.to_string(),
+    "2024-11-03T01:30:00-04:00[America/New_York]",
+);
+// Gives you the later time in a fold, i.e., after DST ends.
+// Notice the offset change from the previous example!
+assert_eq!(
+    tz.to_ambiguous_zoned(dt).later()?.to_string(),
+    "2024-11-03T01:30:00-05:00[America/New_York]",
+);
+// "Just give me something reasonable"
+assert_eq!(
+    tz.to_ambiguous_zoned(dt).compatible()?.to_string(),
+    "2024-11-03T01:30:00-04:00[America/New_York]",
+);
+
+# Ok::<(), Box<dyn std::error::Error>>(())
+```
+
+# When should I use civil time?
+
+Here is a likely non-exhaustive list of reasons why you might want to use
+civil time:
+
+* When you want or need to deal with calendar and clock units as an
+intermediate step before and/or after associating it with a time zone. For
+example, perhaps you need to parse strings like `2000-01-01T00:00:00` from a
+CSV file that have no time zone or offset information, but the time zone is
+implied through some out-of-band mechanism.
+* When time zone is actually irrelevant. For example, a fitness tracking app
+that reminds you to work-out at 6am local time, regardless of which time zone
+you're in.
+* When you need to perform arithmetic that deliberately ignores daylight
+saving time.
+* When interacting with legacy systems or systems that specifically do not
+support time zones.
+*/
+
+pub use self::{
+    date::{Date, DateArithmetic, DateDifference, DateSeries, DateWith},
+    datetime::{
+        DateTime, DateTimeArithmetic, DateTimeDifference, DateTimeRound,
+        DateTimeSeries, DateTimeWith,
+    },
+    iso_week_date::ISOWeekDate,
+    time::{
+        Time, TimeArithmetic, TimeDifference, TimeRound, TimeSeries, TimeWith,
+    },
+    weekday::{Weekday, WeekdaysForward, WeekdaysReverse},
+};
+
+mod date;
+mod datetime;
+mod iso_week_date;
+mod time;
+mod weekday;
+
+/// The era corresponding to a particular year.
+///
+/// The BCE era corresponds to years less than or equal to `0`, while the CE
+/// era corresponds to years greater than `0`.
+///
+/// In particular, this crate allows years to be negative and also to be `0`,
+/// which is contrary to the common practice of excluding the year `0` when
+/// writing dates for the Gregorian calendar. Moreover, common practice eschews
+/// negative years in favor of labeling a year with an era notation. That is,
+/// the year `1 BCE` is year `0` in this crate. The year `2 BCE` is the year
+/// `-1` in this crate.
+///
+/// To get the year in its era format, use [`Date::era_year`].
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+pub enum Era {
+    /// The "before common era" era.
+    ///
+    /// This corresponds to all years less than or equal to `0`.
+    ///
+    /// This is precisely equivalent to the "BC" or "before Christ" era.
+    BCE,
+    /// The "common era" era.
+    ///
+    /// This corresponds to all years greater than `0`.
+    ///
+    /// This is precisely equivalent to the "AD" or "anno Domini" or "in the
+    /// year of the Lord" era.
+    CE,
+}
+
+/// Creates a new `DateTime` value in a `const` context.
+///
+/// This is a convenience free function for [`DateTime::constant`]. It is
+/// intended to provide a terse syntax for constructing `DateTime` values from
+/// parameters that are known to be valid.
+///
+/// # Panics
+///
+/// This routine panics when [`DateTime::new`] would return an error. That
+/// is, when the given components do not correspond to a valid datetime.
+/// Namely, all of the following must be true:
+///
+/// * The year must be in the range `-9999..=9999`.
+/// * The month must be in the range `1..=12`.
+/// * The day must be at least `1` and must be at most the number of days
+/// in the corresponding month. So for example, `2024-02-29` is valid but
+/// `2023-02-29` is not.
+/// * `0 <= hour <= 23`
+/// * `0 <= minute <= 59`
+/// * `0 <= second <= 59`
+/// * `0 <= subsec_nanosecond <= 999,999,999`
+///
+/// Similarly, when used in a const context, invalid parameters will prevent
+/// your Rust program from compiling.
+///
+/// # Example
+///
+/// ```
+/// use jiff::civil::DateTime;
+///
+/// let d = DateTime::constant(2024, 2, 29, 21, 30, 5, 123_456_789);
+/// assert_eq!(d.date().year(), 2024);
+/// assert_eq!(d.date().month(), 2);
+/// assert_eq!(d.date().day(), 29);
+/// assert_eq!(d.time().hour(), 21);
+/// assert_eq!(d.time().minute(), 30);
+/// assert_eq!(d.time().second(), 5);
+/// assert_eq!(d.time().millisecond(), 123);
+/// assert_eq!(d.time().microsecond(), 456);
+/// assert_eq!(d.time().nanosecond(), 789);
+/// ```
+#[inline]
+pub const fn datetime(
+    year: i16,
+    month: i8,
+    day: i8,
+    hour: i8,
+    minute: i8,
+    second: i8,
+    subsec_nanosecond: i32,
+) -> DateTime {
+    DateTime::constant(
+        year,
+        month,
+        day,
+        hour,
+        minute,
+        second,
+        subsec_nanosecond,
+    )
+}
+
+/// Creates a new `Date` value in a `const` context.
+///
+/// This is a convenience free function for [`Date::constant`]. It is intended
+/// to provide a terse syntax for constructing `Date` values from parameters
+/// that are known to be valid.
+///
+/// # Panics
+///
+/// This routine panics when [`Date::new`] would return an error. That is,
+/// when the given year-month-day does not correspond to a valid date.
+/// Namely, all of the following must be true:
+///
+/// * The year must be in the range `-9999..=9999`.
+/// * The month must be in the range `1..=12`.
+/// * The day must be at least `1` and must be at most the number of days
+/// in the corresponding month. So for example, `2024-02-29` is valid but
+/// `2023-02-29` is not.
+///
+/// Similarly, when used in a const context, invalid parameters will prevent
+/// your Rust program from compiling.
+///
+/// # Example
+///
+/// ```
+/// use jiff::civil::date;
+///
+/// let d = date(2024, 2, 29);
+/// assert_eq!(d.year(), 2024);
+/// assert_eq!(d.month(), 2);
+/// assert_eq!(d.day(), 29);
+/// ```
+#[inline]
+pub const fn date(year: i16, month: i8, day: i8) -> Date {
+    Date::constant(year, month, day)
+}
+
+/// Creates a new `Time` value in a `const` context.
+///
+/// This is a convenience free function for [`Time::constant`]. It is intended
+/// to provide a terse syntax for constructing `Time` values from parameters
+/// that are known to be valid.
+///
+/// # Panics
+///
+/// This panics if the given values do not correspond to a valid `Time`.
+/// All of the following conditions must be true:
+///
+/// * `0 <= hour <= 23`
+/// * `0 <= minute <= 59`
+/// * `0 <= second <= 59`
+/// * `0 <= subsec_nanosecond <= 999,999,999`
+///
+/// Similarly, when used in a const context, invalid parameters will
+/// prevent your Rust program from compiling.
+///
+/// # Example
+///
+/// This shows an example of a valid time in a `const` context:
+///
+/// ```
+/// use jiff::civil::Time;
+///
+/// const BEDTIME: Time = Time::constant(21, 30, 5, 123_456_789);
+/// assert_eq!(BEDTIME.hour(), 21);
+/// assert_eq!(BEDTIME.minute(), 30);
+/// assert_eq!(BEDTIME.second(), 5);
+/// assert_eq!(BEDTIME.millisecond(), 123);
+/// assert_eq!(BEDTIME.microsecond(), 456);
+/// assert_eq!(BEDTIME.nanosecond(), 789);
+/// assert_eq!(BEDTIME.subsec_nanosecond(), 123_456_789);
+/// ```
+#[inline]
+pub const fn time(
+    hour: i8,
+    minute: i8,
+    second: i8,
+    subsec_nanosecond: i32,
+) -> Time {
+    Time::constant(hour, minute, second, subsec_nanosecond)
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/jiff-0.2.20/src/civil/weekday.rs

@@ -0,0 +1,802 @@
+use crate::{error::Error, shared::util::itime::IWeekday, util::b};
+
+/// A representation for the day of the week.
+///
+/// The default representation follows ISO 8601. That is, the week starts with
+/// Monday and numbering starts at `1`. However, the various constructors and
+/// accessors support using other schemes in wide use:
+///
+/// * [`Weekday::from_monday_zero_offset`] builds a weekday from
+/// a scheme that starts the week on Monday at offset `0`, while
+/// [`Weekday::to_monday_zero_offset`] converts to it.
+/// * [`Weekday::from_monday_one_offset`] builds a weekday from a scheme
+/// that starts the week on Monday at offset `1` (the default representation),
+/// while [`Weekday::to_monday_one_offset`] converts to it.
+/// * [`Weekday::from_sunday_zero_offset`] builds a weekday from
+/// a scheme that starts the week on Sunday at offset `0`, while
+/// [`Weekday::to_sunday_zero_offset`] converts to it.
+/// * [`Weekday::from_sunday_one_offset`] builds a weekday from
+/// a scheme that starts the week on Sunday at offset `1`, while
+/// [`Weekday::to_sunday_one_offset`] converts to it.
+///
+/// # Arithmetic
+///
+/// This type provides [`Weekday::wrapping_add`] and [`Weekday::wrapping_sub`]
+/// for performing wrapping arithmetic on weekdays. These are also available
+/// via operator overloading:
+///
+/// ```
+/// use jiff::civil::Weekday;
+///
+/// assert_eq!(Weekday::Monday + 1, Weekday::Tuesday);
+/// assert_eq!(Weekday::Sunday - 1, Weekday::Saturday);
+/// ```
+///
+/// # Comparisons
+///
+/// This type provides `Eq` and `PartialEq` trait implementations for easy
+/// comparison:
+///
+/// ```
+/// use jiff::civil::Weekday;
+///
+/// assert_eq!(Weekday::Wednesday, Weekday::Wednesday + 7);
+/// assert_ne!(Weekday::Thursday, Weekday::Friday);
+/// ```
+///
+/// But this type specifically does not provide `Ord` or `PartialOrd` trait
+/// implementations. Such an implementation would require deciding whether
+/// Sunday is less than Monday or greater than Monday. The former case
+/// corresponds to a week scheme where Sunday is the first day in the week,
+/// where as the latter corresponds to a scheme where Monday is the first day.
+/// Since both schemes are in widespread use, it would be inappropriate to bake
+/// in an assumption of one or the other. Instead, one can convert a weekday
+/// into the desired offset scheme, and then compare the offsets:
+///
+/// ```
+/// use jiff::civil::Weekday;
+///
+/// let (sun, mon) = (Weekday::Sunday, Weekday::Monday);
+/// assert!(sun.to_sunday_zero_offset() < mon.to_sunday_zero_offset());
+/// assert!(sun.to_monday_zero_offset() > mon.to_monday_zero_offset());
+/// ```
+///
+/// # Example
+///
+/// This example shows the result of converting to and from different schemes:
+///
+/// ```
+/// use jiff::civil::Weekday;
+///
+/// // The different representations of Monday.
+/// assert_eq!(Weekday::Monday.to_monday_zero_offset(), 0);
+/// assert_eq!(Weekday::Monday.to_monday_one_offset(), 1);
+/// assert_eq!(Weekday::Monday.to_sunday_zero_offset(), 1);
+/// assert_eq!(Weekday::Monday.to_sunday_one_offset(), 2);
+///
+/// // The different representations of Sunday.
+/// assert_eq!(Weekday::Sunday.to_monday_zero_offset(), 6);
+/// assert_eq!(Weekday::Sunday.to_monday_one_offset(), 7);
+/// assert_eq!(Weekday::Sunday.to_sunday_zero_offset(), 0);
+/// assert_eq!(Weekday::Sunday.to_sunday_one_offset(), 1);
+/// ```
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+#[repr(u8)]
+#[allow(missing_docs)]
+pub enum Weekday {
+    Monday = 1,
+    Tuesday = 2,
+    Wednesday = 3,
+    Thursday = 4,
+    Friday = 5,
+    Saturday = 6,
+    Sunday = 7,
+}
+
+impl Weekday {
+    /// Convert an offset to a structured `Weekday`.
+    ///
+    /// The offset should be from a scheme where the first day of the week
+    /// is Monday and starts numbering at `0`.
+    ///
+    /// # Errors
+    ///
+    /// This returns an error when the given offset is not in the range
+    /// `0..=6`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::civil::Weekday;
+    ///
+    /// let weekday = Weekday::from_monday_zero_offset(3)?;
+    /// assert_eq!(weekday, Weekday::Thursday);
+    ///
+    /// assert!(Weekday::from_monday_zero_offset(7).is_err());
+    /// assert!(Weekday::from_monday_zero_offset(-1).is_err());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn from_monday_zero_offset(offset: i8) -> Result<Weekday, Error> {
+        Ok(Weekday::from_monday_zero_offset_unchecked(
+            b::WeekdayMondayZero::check(offset)?,
+        ))
+    }
+
+    #[inline]
+    fn from_monday_zero_offset_unchecked(offset: impl Into<i64>) -> Weekday {
+        match offset.into() {
+            0 => Weekday::Monday,
+            1 => Weekday::Tuesday,
+            2 => Weekday::Wednesday,
+            3 => Weekday::Thursday,
+            4 => Weekday::Friday,
+            5 => Weekday::Saturday,
+            6 => Weekday::Sunday,
+            _ => unreachable!(),
+        }
+    }
+
+    /// Convert an offset to a structured `Weekday`.
+    ///
+    /// The offset should be from a scheme where the first day of the week
+    /// is Monday and starts numbering at `1`.
+    ///
+    /// # Errors
+    ///
+    /// This returns an error when the given offset is not in the range
+    /// `1..=7`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::civil::Weekday;
+    ///
+    /// let weekday = Weekday::from_monday_one_offset(4)?;
+    /// assert_eq!(weekday, Weekday::Thursday);
+    ///
+    /// assert!(Weekday::from_monday_one_offset(8).is_err());
+    /// assert!(Weekday::from_monday_one_offset(0).is_err());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn from_monday_one_offset(offset: i8) -> Result<Weekday, Error> {
+        let offset = b::WeekdayMondayOne::check(offset)?;
+        Weekday::from_monday_zero_offset(offset - 1)
+    }
+
+    /// Convert an offset to a structured `Weekday`.
+    ///
+    /// The offset should be from a scheme where the first day of the week
+    /// is Sunday and starts numbering at `0`.
+    ///
+    /// # Errors
+    ///
+    /// This returns an error when the given offset is not in the range
+    /// `0..=6`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::civil::Weekday;
+    ///
+    /// let weekday = Weekday::from_sunday_zero_offset(0)?;
+    /// assert_eq!(weekday, Weekday::Sunday);
+    /// let weekday = Weekday::from_sunday_zero_offset(4)?;
+    /// assert_eq!(weekday, Weekday::Thursday);
+    ///
+    /// assert!(Weekday::from_sunday_zero_offset(7).is_err());
+    /// assert!(Weekday::from_sunday_zero_offset(-1).is_err());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn from_sunday_zero_offset(offset: i8) -> Result<Weekday, Error> {
+        let offset = b::WeekdaySundayZero::check(offset)?;
+        Weekday::from_monday_zero_offset((offset - 1).rem_euclid(7))
+    }
+
+    /// Convert an offset to a structured `Weekday`.
+    ///
+    /// The offset should be from a scheme where the first day of the week
+    /// is Sunday and starts numbering at `1`.
+    ///
+    /// # Errors
+    ///
+    /// This returns an error when the given offset is not in the range
+    /// `1..=7`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::civil::Weekday;
+    ///
+    /// let weekday = Weekday::from_sunday_one_offset(5)?;
+    /// assert_eq!(weekday, Weekday::Thursday);
+    ///
+    /// assert!(Weekday::from_sunday_one_offset(8).is_err());
+    /// assert!(Weekday::from_sunday_one_offset(0).is_err());
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn from_sunday_one_offset(offset: i8) -> Result<Weekday, Error> {
+        let offset = b::WeekdaySundayOne::check(offset)?;
+        Weekday::from_monday_zero_offset((offset - 2).rem_euclid(7))
+    }
+
+    /// Returns this weekday as an offset.
+    ///
+    /// The offset returned is computed based on a week that starts with Monday
+    /// and begins numbering at `0`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::civil::Weekday;
+    ///
+    /// assert_eq!(Weekday::Thursday.to_monday_zero_offset(), 3);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn to_monday_zero_offset(self) -> i8 {
+        self.to_monday_one_offset() - 1
+    }
+
+    /// Returns this weekday as an offset.
+    ///
+    /// The offset returned is computed based on a week that starts with Monday
+    /// and begins numbering at `1`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::civil::Weekday;
+    ///
+    /// assert_eq!(Weekday::Thursday.to_monday_one_offset(), 4);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn to_monday_one_offset(self) -> i8 {
+        self as i8
+    }
+
+    /// Returns this weekday as an offset.
+    ///
+    /// The offset returned is computed based on a week that starts with Sunday
+    /// and begins numbering at `0`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::civil::Weekday;
+    ///
+    /// assert_eq!(Weekday::Thursday.to_sunday_zero_offset(), 4);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn to_sunday_zero_offset(self) -> i8 {
+        let offset = self.to_monday_one_offset();
+        if offset == 7 {
+            0
+        } else {
+            offset
+        }
+    }
+
+    /// Returns this weekday as an offset.
+    ///
+    /// The offset returned is computed based on a week that starts with Sunday
+    /// and begins numbering at `1`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::civil::Weekday;
+    ///
+    /// assert_eq!(Weekday::Thursday.to_sunday_one_offset(), 5);
+    ///
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// ```
+    #[inline]
+    pub fn to_sunday_one_offset(self) -> i8 {
+        self.to_sunday_zero_offset() + 1
+    }
+
+    /// Returns the next weekday, wrapping around at the end of week to the
+    /// beginning of the week.
+    ///
+    /// This is a convenience routing for calling [`Weekday::wrapping_add`]
+    /// with a value of `1`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::civil::Weekday;
+    ///
+    /// assert_eq!(Weekday::Wednesday.next(), Weekday::Thursday);
+    /// assert_eq!(Weekday::Sunday.next(), Weekday::Monday);
+    /// assert_eq!(Weekday::Saturday.next(), Weekday::Sunday);
+    /// ```
+    #[inline]
+    pub fn next(self) -> Weekday {
+        self.wrapping_add(1)
+    }
+
+    /// Returns the previous weekday, wrapping around at the beginning of week
+    /// to the end of the week.
+    ///
+    /// This is a convenience routing for calling [`Weekday::wrapping_sub`]
+    /// with a value of `1`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::civil::Weekday;
+    ///
+    /// assert_eq!(Weekday::Wednesday.previous(), Weekday::Tuesday);
+    /// assert_eq!(Weekday::Sunday.previous(), Weekday::Saturday);
+    /// assert_eq!(Weekday::Saturday.previous(), Weekday::Friday);
+    /// ```
+    #[inline]
+    pub fn previous(self) -> Weekday {
+        self.wrapping_sub(1)
+    }
+
+    /// Returns the number of days from `other` to this weekday.
+    ///
+    /// Adding the returned number of days to `other` is guaranteed to sum to
+    /// this weekday. The number of days returned is guaranteed to be in the
+    /// range `0..=6`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::civil::Weekday;
+    ///
+    /// assert_eq!(Weekday::Friday.since(Weekday::Tuesday), 3);
+    /// assert_eq!(Weekday::Tuesday.since(Weekday::Tuesday), 0);
+    /// assert_eq!(Weekday::Monday.since(Weekday::Sunday), 1);
+    /// assert_eq!(Weekday::Sunday.since(Weekday::Monday), 6);
+    /// ```
+    #[inline]
+    pub fn since(self, other: Weekday) -> i8 {
+        (self.to_monday_zero_offset() - other.to_monday_zero_offset())
+            .rem_euclid(7)
+    }
+
+    /// Returns the number of days until `other` from this weekday.
+    ///
+    /// Adding the returned number of days to this weekday is guaranteed to sum
+    /// to `other` weekday. The number of days returned is guaranteed to be in
+    /// the range `0..=6`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::civil::Weekday;
+    ///
+    /// assert_eq!(Weekday::Friday.until(Weekday::Tuesday), 4);
+    /// assert_eq!(Weekday::Tuesday.until(Weekday::Tuesday), 0);
+    /// assert_eq!(Weekday::Monday.until(Weekday::Sunday), 6);
+    /// assert_eq!(Weekday::Sunday.until(Weekday::Monday), 1);
+    /// ```
+    #[inline]
+    pub fn until(self, other: Weekday) -> i8 {
+        other.since(self)
+    }
+
+    /// Add the given number of days to this weekday, using wrapping arithmetic,
+    /// and return the resulting weekday.
+    ///
+    /// Adding a multiple of `7` (including `0`) is guaranteed to produce the
+    /// same weekday as this one.
+    ///
+    /// Note that this routine is also available via the `+` operator.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::civil::Weekday;
+    ///
+    /// assert_eq!(Weekday::Sunday.wrapping_add(1), Weekday::Monday);
+    /// assert_eq!(Weekday::Sunday.wrapping_add(2), Weekday::Tuesday);
+    /// assert_eq!(Weekday::Saturday.wrapping_add(1), Weekday::Sunday);
+    /// assert_eq!(Weekday::Saturday.wrapping_add(7), Weekday::Saturday);
+    /// assert_eq!(Weekday::Sunday.wrapping_add(-1), Weekday::Saturday);
+    /// ```
+    ///
+    /// Wrapping arithmetic is also performed by the `+` operator:
+    ///
+    /// ```
+    /// use jiff::civil::Weekday;
+    ///
+    /// assert_eq!(Weekday::Sunday + 1, Weekday::Monday);
+    /// assert_eq!(Weekday::Sunday + 2, Weekday::Tuesday);
+    /// assert_eq!(Weekday::Saturday + 1, Weekday::Sunday);
+    /// assert_eq!(Weekday::Saturday + 7, Weekday::Saturday);
+    /// assert_eq!(Weekday::Sunday + -1, Weekday::Saturday);
+    /// // The weekday can also be on the right hand side of addition:
+    /// assert_eq!(1 + Weekday::Sunday, Weekday::Monday);
+    /// ```
+    #[inline]
+    pub fn wrapping_add<D: Into<i64>>(self, days: D) -> Weekday {
+        let start = i64::from(self.to_monday_zero_offset());
+        let rhs = days.into();
+        let end = start.wrapping_add(rhs).rem_euclid(7);
+        // Always valid because of the mod 7 above.
+        Weekday::from_monday_zero_offset_unchecked(end)
+    }
+
+    /// Subtract the given number of days from this weekday, using wrapping
+    /// arithmetic, and return the resulting weekday.
+    ///
+    /// Subtracting a multiple of `7` (including `0`) is guaranteed to produce
+    /// the same weekday as this one.
+    ///
+    /// Note that this routine is also available via the `-` operator.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::civil::Weekday;
+    ///
+    /// assert_eq!(Weekday::Sunday.wrapping_sub(1), Weekday::Saturday);
+    /// assert_eq!(Weekday::Sunday.wrapping_sub(2), Weekday::Friday);
+    /// assert_eq!(Weekday::Saturday.wrapping_sub(1), Weekday::Friday);
+    /// assert_eq!(Weekday::Saturday.wrapping_sub(7), Weekday::Saturday);
+    /// assert_eq!(Weekday::Sunday.wrapping_sub(-1), Weekday::Monday);
+    /// ```
+    ///
+    /// Wrapping arithmetic is also performed by the `-` operator:
+    ///
+    /// ```
+    /// use jiff::civil::Weekday;
+    ///
+    /// assert_eq!(Weekday::Sunday - 1, Weekday::Saturday);
+    /// assert_eq!(Weekday::Sunday - 2, Weekday::Friday);
+    /// assert_eq!(Weekday::Saturday - 1, Weekday::Friday);
+    /// assert_eq!(Weekday::Saturday - 7, Weekday::Saturday);
+    /// assert_eq!(Weekday::Sunday - -1, Weekday::Monday);
+    /// ```
+    ///
+    /// Unlike addition, since subtraction is not commutative and negating a
+    /// weekday has no semantic meaning, the weekday cannot be on the right
+    /// hand side of the `-` operator.
+    #[inline]
+    pub fn wrapping_sub<D: Into<i64>>(self, days: D) -> Weekday {
+        self.wrapping_add(-days.into())
+    }
+
+    /// Starting with this weekday, this returns an unending iterator that
+    /// cycles forward through the days of the week.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::civil::Weekday;
+    ///
+    /// let mut it = Weekday::Tuesday.cycle_forward();
+    /// assert_eq!(it.next(), Some(Weekday::Tuesday));
+    /// assert_eq!(it.next(), Some(Weekday::Wednesday));
+    /// assert_eq!(it.next(), Some(Weekday::Thursday));
+    /// assert_eq!(it.next(), Some(Weekday::Friday));
+    /// assert_eq!(it.next(), Some(Weekday::Saturday));
+    /// assert_eq!(it.next(), Some(Weekday::Sunday));
+    /// assert_eq!(it.next(), Some(Weekday::Monday));
+    /// assert_eq!(it.next(), Some(Weekday::Tuesday));
+    /// ```
+    #[inline]
+    pub fn cycle_forward(self) -> WeekdaysForward {
+        let nexts = [
+            self,
+            self.wrapping_add(1),
+            self.wrapping_add(2),
+            self.wrapping_add(3),
+            self.wrapping_add(4),
+            self.wrapping_add(5),
+            self.wrapping_add(6),
+        ];
+        WeekdaysForward { it: nexts.into_iter().cycle() }
+    }
+
+    /// Starting with this weekday, this returns an unending iterator that
+    /// cycles backward through the days of the week.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use jiff::civil::Weekday;
+    ///
+    /// let mut it = Weekday::Tuesday.cycle_reverse();
+    /// assert_eq!(it.next(), Some(Weekday::Tuesday));
+    /// assert_eq!(it.next(), Some(Weekday::Monday));
+    /// assert_eq!(it.next(), Some(Weekday::Sunday));
+    /// assert_eq!(it.next(), Some(Weekday::Saturday));
+    /// assert_eq!(it.next(), Some(Weekday::Friday));
+    /// assert_eq!(it.next(), Some(Weekday::Thursday));
+    /// assert_eq!(it.next(), Some(Weekday::Wednesday));
+    /// assert_eq!(it.next(), Some(Weekday::Tuesday));
+    /// ```
+    #[inline]
+    pub fn cycle_reverse(self) -> WeekdaysReverse {
+        let nexts = [
+            self,
+            self.wrapping_sub(1),
+            self.wrapping_sub(2),
+            self.wrapping_sub(3),
+            self.wrapping_sub(4),
+            self.wrapping_sub(5),
+            self.wrapping_sub(6),
+        ];
+        WeekdaysReverse { it: nexts.into_iter().cycle() }
+    }
+}
+
+impl Weekday {
+    #[inline]
+    pub(crate) fn from_iweekday(iweekday: IWeekday) -> Weekday {
+        match iweekday.to_monday_one_offset() {
+            1 => Weekday::Monday,
+            2 => Weekday::Tuesday,
+            3 => Weekday::Wednesday,
+            4 => Weekday::Thursday,
+            5 => Weekday::Friday,
+            6 => Weekday::Saturday,
+            7 => Weekday::Sunday,
+            _ => unreachable!(),
+        }
+    }
+
+    #[inline]
+    pub(crate) fn to_iweekday(self) -> IWeekday {
+        IWeekday::from_monday_one_offset(self.to_monday_one_offset())
+    }
+}
+
+impl core::ops::Add<i8> for Weekday {
+    type Output = Weekday;
+
+    #[inline]
+    fn add(self, rhs: i8) -> Weekday {
+        self.wrapping_add(rhs)
+    }
+}
+
+impl core::ops::Add<i16> for Weekday {
+    type Output = Weekday;
+
+    #[inline]
+    fn add(self, rhs: i16) -> Weekday {
+        self.wrapping_add(rhs)
+    }
+}
+
+impl core::ops::Add<i32> for Weekday {
+    type Output = Weekday;
+
+    #[inline]
+    fn add(self, rhs: i32) -> Weekday {
+        self.wrapping_add(rhs)
+    }
+}
+
+impl core::ops::Add<i64> for Weekday {
+    type Output = Weekday;
+
+    #[inline]
+    fn add(self, rhs: i64) -> Weekday {
+        self.wrapping_add(rhs)
+    }
+}
+
+// Since addition is commutative, we don't might if users write `n + weekday`
+// or `weekday + n`.
+
+impl core::ops::Add<Weekday> for i8 {
+    type Output = Weekday;
+
+    #[inline]
+    fn add(self, rhs: Weekday) -> Weekday {
+        rhs.wrapping_add(self)
+    }
+}
+
+impl core::ops::Add<Weekday> for i16 {
+    type Output = Weekday;
+
+    #[inline]
+    fn add(self, rhs: Weekday) -> Weekday {
+        rhs.wrapping_add(self)
+    }
+}
+
+impl core::ops::Add<Weekday> for i32 {
+    type Output = Weekday;
+
+    #[inline]
+    fn add(self, rhs: Weekday) -> Weekday {
+        rhs.wrapping_add(self)
+    }
+}
+
+impl core::ops::Add<Weekday> for i64 {
+    type Output = Weekday;
+
+    #[inline]
+    fn add(self, rhs: Weekday) -> Weekday {
+        rhs.wrapping_add(self)
+    }
+}
+
+impl core::ops::AddAssign<i8> for Weekday {
+    #[inline]
+    fn add_assign(&mut self, rhs: i8) {
+        *self = *self + rhs;
+    }
+}
+
+impl core::ops::AddAssign<i16> for Weekday {
+    #[inline]
+    fn add_assign(&mut self, rhs: i16) {
+        *self = *self + rhs;
+    }
+}
+
+impl core::ops::AddAssign<i32> for Weekday {
+    #[inline]
+    fn add_assign(&mut self, rhs: i32) {
+        *self = *self + rhs;
+    }
+}
+
+impl core::ops::AddAssign<i64> for Weekday {
+    #[inline]
+    fn add_assign(&mut self, rhs: i64) {
+        *self = *self + rhs;
+    }
+}
+
+// Subtraction isn't commutative, so we only define it when the right hand
+// side is an integer. Otherwise we'd need a concept of what it means to
+// "negate" a weekday, which doesn't really make sense?
+
+impl core::ops::Sub<i8> for Weekday {
+    type Output = Weekday;
+
+    #[inline]
+    fn sub(self, rhs: i8) -> Weekday {
+        self.wrapping_sub(rhs)
+    }
+}
+
+impl core::ops::Sub<i16> for Weekday {
+    type Output = Weekday;
+
+    #[inline]
+    fn sub(self, rhs: i16) -> Weekday {
+        self.wrapping_sub(rhs)
+    }
+}
+
+impl core::ops::Sub<i32> for Weekday {
+    type Output = Weekday;
+
+    #[inline]
+    fn sub(self, rhs: i32) -> Weekday {
+        self.wrapping_sub(rhs)
+    }
+}
+
+impl core::ops::Sub<i64> for Weekday {
+    type Output = Weekday;
+
+    #[inline]
+    fn sub(self, rhs: i64) -> Weekday {
+        self.wrapping_sub(rhs)
+    }
+}
+
+impl core::ops::SubAssign<i8> for Weekday {
+    #[inline]
+    fn sub_assign(&mut self, rhs: i8) {
+        *self = *self - rhs;
+    }
+}
+
+impl core::ops::SubAssign<i16> for Weekday {
+    #[inline]
+    fn sub_assign(&mut self, rhs: i16) {
+        *self = *self - rhs;
+    }
+}
+
+impl core::ops::SubAssign<i32> for Weekday {
+    #[inline]
+    fn sub_assign(&mut self, rhs: i32) {
+        *self = *self - rhs;
+    }
+}
+
+impl core::ops::SubAssign<i64> for Weekday {
+    #[inline]
+    fn sub_assign(&mut self, rhs: i64) {
+        *self = *self - rhs;
+    }
+}
+
+#[cfg(test)]
+impl quickcheck::Arbitrary for Weekday {
+    fn arbitrary(g: &mut quickcheck::Gen) -> Weekday {
+        let offset = b::WeekdayMondayZero::arbitrary(g);
+        Weekday::from_monday_zero_offset(offset).unwrap()
+    }
+
+    fn shrink(&self) -> alloc::boxed::Box<dyn Iterator<Item = Weekday>> {
+        alloc::boxed::Box::new(
+            self.to_monday_zero_offset()
+                .shrink()
+                .filter_map(|n| Weekday::from_monday_zero_offset(n).ok()),
+        )
+    }
+}
+
+/// An unending iterator of the days of the week.
+///
+/// This iterator is created by calling [`Weekday::cycle_forward`].
+#[derive(Clone, Debug)]
+pub struct WeekdaysForward {
+    it: core::iter::Cycle<core::array::IntoIter<Weekday, 7>>,
+}
+
+impl Iterator for WeekdaysForward {
+    type Item = Weekday;
+
+    #[inline]
+    fn next(&mut self) -> Option<Weekday> {
+        self.it.next()
+    }
+}
+
+impl core::iter::FusedIterator for WeekdaysForward {}
+
+/// An unending iterator of the days of the week in reverse.
+///
+/// This iterator is created by calling [`Weekday::cycle_reverse`].
+#[derive(Clone, Debug)]
+pub struct WeekdaysReverse {
+    it: core::iter::Cycle<core::array::IntoIter<Weekday, 7>>,
+}
+
+impl Iterator for WeekdaysReverse {
+    type Item = Weekday;
+
+    #[inline]
+    fn next(&mut self) -> Option<Weekday> {
+        self.it.next()
+    }
+}
+
+impl core::iter::FusedIterator for WeekdaysReverse {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    quickcheck::quickcheck! {
+        fn prop_since_add_equals_self(wd1: Weekday, wd2: Weekday) -> bool {
+            let days = wd1.since(wd2);
+            wd2.wrapping_add(days) == wd1
+        }
+
+        fn prop_until_add_equals_other(wd1: Weekday, wd2: Weekday) -> bool {
+            let days = wd1.until(wd2);
+            wd1.wrapping_add(days) == wd2
+        }
+    }
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/jiff-0.2.20/src/duration.rs

@@ -0,0 +1,146 @@
+use core::time::Duration as UnsignedDuration;
+
+use crate::{
+    error::{duration::Error as E, ErrorContext},
+    Error, SignedDuration, Span,
+};
+
+/// An internal type for abstracting over different duration types.
+#[derive(Clone, Copy, Debug)]
+pub(crate) enum Duration {
+    Span(Span),
+    Signed(SignedDuration),
+    Unsigned(UnsignedDuration),
+}
+
+impl Duration {
+    /// Convert this to a signed duration.
+    ///
+    /// This returns an error only in the case where this is an unsigned
+    /// duration with a number of whole seconds that exceeds `|i64::MIN|`.
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(crate) fn to_signed(&self) -> Result<SDuration<'_>, Error> {
+        match *self {
+            Duration::Span(ref span) => Ok(SDuration::Span(span)),
+            Duration::Signed(sdur) => Ok(SDuration::Absolute(sdur)),
+            Duration::Unsigned(udur) => {
+                let sdur = SignedDuration::try_from(udur)
+                    .context(E::RangeUnsignedDuration)?;
+                Ok(SDuration::Absolute(sdur))
+            }
+        }
+    }
+
+    /// Negates this duration.
+    ///
+    /// When the duration is a span, this can never fail because a span defines
+    /// its min and max values such that negation is always possible.
+    ///
+    /// When the duration is signed, then this attempts to return a signed
+    /// duration and only falling back to an unsigned duration when the number
+    /// of seconds corresponds to `i64::MIN`.
+    ///
+    /// When the duration is unsigned, then this fails when the whole seconds
+    /// exceed the absolute value of `i64::MIN`. Otherwise, a signed duration
+    /// is returned.
+    ///
+    /// The failures for large unsigned durations here are okay because the
+    /// point at which absolute durations overflow on negation, they would also
+    /// cause overflow when adding or subtracting to *any* valid datetime value
+    /// for *any* datetime type in this crate. So while the error message may
+    /// be different, the actual end result is the same (failure).
+    ///
+    /// TODO: Write unit tests for this.
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(crate) fn checked_neg(self) -> Result<Duration, Error> {
+        match self {
+            Duration::Span(span) => Ok(Duration::Span(span.negate())),
+            Duration::Signed(sdur) => {
+                // We try to stick with signed durations, but in the case
+                // where negation fails, we can represent its negation using
+                // an unsigned duration.
+                if let Some(sdur) = sdur.checked_neg() {
+                    Ok(Duration::Signed(sdur))
+                } else {
+                    let udur = UnsignedDuration::new(
+                        i64::MIN.unsigned_abs(),
+                        sdur.subsec_nanos().unsigned_abs(),
+                    );
+                    Ok(Duration::Unsigned(udur))
+                }
+            }
+            Duration::Unsigned(udur) => {
+                // We can permit negating i64::MIN.unsigned_abs() to
+                // i64::MIN, but we need to handle it specially since
+                // i64::MIN.unsigned_abs() exceeds i64::MAX.
+                let sdur = if udur.as_secs() == i64::MIN.unsigned_abs() {
+                    SignedDuration::new_without_nano_overflow(
+                        i64::MIN,
+                        // OK because `udur.subsec_nanos()` < 999_999_999.
+                        -i32::try_from(udur.subsec_nanos()).unwrap(),
+                    )
+                } else {
+                    // The negation here is always correct because it can only
+                    // panic with `sdur.as_secs() == i64::MIN`, which is
+                    // impossible because it must be positive.
+                    //
+                    // Otherwise, this is the only failure point in this entire
+                    // routine. And specifically, we fail here in precisely
+                    // the cases where `udur.as_secs() > |i64::MIN|`.
+                    -SignedDuration::try_from(udur)
+                        .context(E::FailedNegateUnsignedDuration)?
+                };
+                Ok(Duration::Signed(sdur))
+            }
+        }
+    }
+
+    /// Returns true if and only if this duration is negative.
+    #[cfg_attr(feature = "perf-inline", inline(always))]
+    pub(crate) fn is_negative(&self) -> bool {
+        match *self {
+            Duration::Span(ref span) => span.is_negative(),
+            Duration::Signed(ref sdur) => sdur.is_negative(),
+            Duration::Unsigned(_) => false,
+        }
+    }
+}
+
+impl From<Span> for Duration {
+    #[inline]
+    fn from(span: Span) -> Duration {
+        Duration::Span(span)
+    }
+}
+
+impl From<SignedDuration> for Duration {
+    #[inline]
+    fn from(sdur: SignedDuration) -> Duration {
+        Duration::Signed(sdur)
+    }
+}
+
+impl From<UnsignedDuration> for Duration {
+    #[inline]
+    fn from(udur: UnsignedDuration) -> Duration {
+        Duration::Unsigned(udur)
+    }
+}
+
+/// An internal type for abstracting over signed durations.
+///
+/// This is typically converted to from a `Duration`. It enables callers
+/// downstream to implement datetime arithmetic on only two duration types
+/// instead of doing it for three duration types (including
+/// `std::time::Duration`).
+///
+/// The main thing making this idea work is that if an unsigned duration cannot
+/// fit into a signed duration, then it would overflow any calculation on any
+/// datetime type in Jiff anyway. If this weren't true, then we'd need to
+/// support doing actual arithmetic with unsigned durations separately from
+/// signed durations.
+#[derive(Clone, Copy, Debug)]
+pub(crate) enum SDuration<'a> {
+    Span(&'a Span),
+    Absolute(SignedDuration),
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/jiff-0.2.20/src/error/civil.rs

@@ -0,0 +1,66 @@
+use crate::error;
+
+#[derive(Clone, Debug)]
+pub(crate) enum Error {
+    FailedAddDays,
+    FailedAddDurationOverflowing,
+    FailedAddSpanDate,
+    FailedAddSpanOverflowing,
+    FailedAddSpanTime,
+    IllegalTimeWithMicrosecond,
+    IllegalTimeWithMillisecond,
+    IllegalTimeWithNanosecond,
+    OverflowDaysDuration,
+    OverflowTimeNanoseconds,
+}
+
+impl From<Error> for error::Error {
+    #[cold]
+    #[inline(never)]
+    fn from(err: Error) -> error::Error {
+        error::ErrorKind::Civil(err).into()
+    }
+}
+
+impl error::IntoError for Error {
+    fn into_error(self) -> error::Error {
+        self.into()
+    }
+}
+
+impl core::fmt::Display for Error {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        use self::Error::*;
+
+        match *self {
+            FailedAddDays => f.write_str("failed to add days to date"),
+            FailedAddDurationOverflowing => {
+                f.write_str("failed to add overflowing duration")
+            }
+            FailedAddSpanDate => f.write_str("failed to add span to date"),
+            FailedAddSpanOverflowing => {
+                f.write_str("failed to add overflowing span")
+            }
+            FailedAddSpanTime => f.write_str("failed to add span to time"),
+            IllegalTimeWithMicrosecond => f.write_str(
+                "cannot set both `TimeWith::microsecond` \
+                 and `TimeWith::subsec_nanosecond`",
+            ),
+            IllegalTimeWithMillisecond => f.write_str(
+                "cannot set both `TimeWith::millisecond` \
+                 and `TimeWith::subsec_nanosecond`",
+            ),
+            IllegalTimeWithNanosecond => f.write_str(
+                "cannot set both `TimeWith::nanosecond` \
+                 and `TimeWith::subsec_nanosecond`",
+            ),
+            OverflowDaysDuration => f.write_str(
+                "number of days derived from duration exceed's \
+                 Jiff's datetime limits",
+            ),
+            OverflowTimeNanoseconds => {
+                f.write_str("adding duration to time overflowed")
+            }
+        }
+    }
+}