1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
|
//! Misc helper functions and types for use in parsing network documents
use derive_deftly::define_derive_deftly;
pub(crate) mod rangemap_ext;
pub(crate) mod str;
pub mod batching_split_before;
use std::iter::Peekable;
define_derive_deftly! {
/// Implement `AsMut<Self>`
///
/// For Reasons, Rust does not have a blanket:
///
/// ```rust,ignore
/// impl<T> AsMut<T> for T { .. }
/// ```
///
/// This derive macro expands to the obvious and trivial implementation,
/// for the type that it's applied to.
//
// TODO move this somewhere lower in the stack, eg tor-basic-utils
export AsMutSelf expect items:
impl<$tgens> ::std::convert::AsMut<Self> for $ttype where $twheres {
fn as_mut(&mut self) -> &mut Self {
self
}
}
}
/// An iterator with a `.peek()` method
///
/// We make this a trait to avoid entangling all the types with `Peekable`.
/// Ideally we would do this with `Itertools::PeekingNext`
/// but that was not implemented for `&mut PeekingNext`
/// when we wrote this code,
/// and we need that because we use a lot of `&mut NetdocReader`.
/// <https://github.com/rust-itertools/itertools/issues/678>
///
/// TODO: As of itertools 0.11.0, `PeekingNext` _is_ implemented for
/// `&'a mut I where I: PeekingNext`, so we can remove this type some time.
///
/// # **UNSTABLE**
///
/// This type is UNSTABLE and not part of the semver guarantees.
/// You'll only see it if you ran rustdoc with `--document-private-items`.
// This is needed because this is a trait bound for batching_split_before.
#[doc(hidden)]
pub trait PeekableIterator: Iterator {
/// Inspect the next item, if there is one
fn peek(&mut self) -> Option<&Self::Item>;
}
impl<I: Iterator> PeekableIterator for Peekable<I> {
fn peek(&mut self) -> Option<&Self::Item> {
self.peek()
}
}
impl<I: PeekableIterator> PeekableIterator for &mut I {
fn peek(&mut self) -> Option<&Self::Item> {
<I as PeekableIterator>::peek(*self)
}
}
/// A Private module for declaring a "sealed" trait.
pub(crate) mod private {
/// A non-exported trait, used to prevent others from implementing a trait.
///
/// For more information on this pattern, see [the Rust API
/// guidelines](https://rust-lang.github.io/api-guidelines/future-proofing.html#c-sealed).
#[expect(dead_code, unreachable_pub)] // TODO keep this Sealed trait in case we want it again?
pub trait Sealed {}
}
#[cfg(test)]
#[allow(unused)]
fn test_as_mut_compiles() {
use derive_deftly::Deftly;
#[derive(Deftly)]
#[derive_deftly(AsMutSelf)]
struct S<T: Clone>
where
Option<T>: Clone,
{
t: T,
}
let _: &mut S<()> = S { t: () }.as_mut();
}
|
